iniparser.cpp

不需移植

/*************************************************
  Function:			iniparser_getstring
  Description:		Get the string associated to a key, return NULL if not found
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to search,Key string to look for,Default value to return if key not found
  Output:
  Return:			pointer to statically allocated character string, or NULL.
  Others:			This function queries a dictionary for a key. A key as read from an
					ini file is given as "section:key". If the key cannot be found,
					the pointer passed as 'def' is returned.
					The returned char pointer is pointing to a string allocated in
					the dictionary, do not free or modify it.

*************************************************/
char * iniparser_getstring(dictionary * d, char * key, char * def)
{
	char * lc_key ;
	char * sval ;

	if (d==NULL || key==NULL)
	{
		return def ;
	}
#ifndef DONOT_USE_LOW_LETTER_SECTION_NAME
	lc_key = _strdup(strlwc(key));
#else
	lc_key = _strdup(key);
#endif
	sval = dictionary_get(d, lc_key, def);
	free(lc_key);
	return sval ;
}

/*************************************************
  Function:			iniparser_getint
  Description:		Get the string associated to a key, convert to an int
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to search,Key string to look for,
					notfound Value to return in case of error
  Output:
  Return:			integer
  Others:			This function queries a dictionary for a key. A key as read from an
					ini file is given as "section:key". If the key cannot be found,
					the notfound value is returned.

*************************************************/
int iniparser_getint(dictionary * d, char * key, int notfound)
{
	char    *   str ;

	str = iniparser_getstring(d, key, INI_INVALID_KEY);
	if (str==INI_INVALID_KEY)
	{
		return notfound ;
	}

	return atoi(str);
}

/*************************************************
  Function:			iniparser_getdouble
  Description:		Get the string associated to a key, convert to a double
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to search,Key string to look for,
					notfound Value to return in case of error
  Output:
  Return:			double
  Others:			This function queries a dictionary for a key. A key as read from an
					ini file is given as "section:key". If the key cannot be found,
					the notfound value is returned.

*************************************************/
double iniparser_getdouble(dictionary * d, char * key, double notfound)
{
	char    *   str ;

	str = iniparser_getstring(d, key, INI_INVALID_KEY);
	if (str==INI_INVALID_KEY)
	{
		return notfound ;
	}
	return atof(str);
}

/*************************************************
  Function:			iniparser_getboolean
  Description:		Get the string associated to a key, convert to a boolean
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to search,Key string to look for,
					notfound Value to return in case of error
  Output:
  Return:			integer
  Others:			This function queries a dictionary for a key. A key as read from an
					ini file is given as "section:key". If the key cannot be found,
					the notfound value is returned.

					A true boolean is found if one of the following is matched:

					- A string starting with 'y'
					- A string starting with 'Y'
					- A string starting with 't'
					- A string starting with 'T'
					- A string starting with '1'

					A false boolean is found if one of the following is matched:

					- A string starting with 'n'
					- A string starting with 'N'
					- A string starting with 'f'
					- A string starting with 'F'
					- A string starting with '0'

					The notfound value returned if no boolean is identified, does not
					necessarily have to be 0 or 1.
*************************************************/
int iniparser_getboolean(dictionary * d, char * key, int notfound)
{
	char    *   c ;
	int         ret ;

	c = iniparser_getstring(d, key, INI_INVALID_KEY);
	if (c==INI_INVALID_KEY)
	{
		return notfound;
	}

	if (c[0]=='y' || c[0]=='Y' || c[0]=='1' || c[0]=='t' || c[0]=='T')
	{
		ret = 1 ;
	}
	else if (c[0]=='n' || c[0]=='N' || c[0]=='0' || c[0]=='f' || c[0]=='F')
	{
		ret = 0 ;
	} 
	else
	{
		ret = notfound ;
	}

	return ret;
}

/*************************************************
  Function:			iniparser_find_entry
  Description:		Finds out if a given entry exists in a dictionary
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to search,Key string to look for
  Output:
  Return:			integer 1 if entry exists, 0 otherwise
  Others:			Finds out if a given entry exists in the dictionary. Since sections
					are stored as keys with NULL associated values, this is the only way
					of querying for the presence of sections in a dictionary.

*************************************************/
int iniparser_find_entry(
						 dictionary  *   ini,
						 char        *   entry
						 )
{
	int found=0 ;
	if (iniparser_getstring(ini, entry, INI_INVALID_KEY)!=INI_INVALID_KEY)
	{
		found = 1 ;
	}
	return found ;
}

/*************************************************
  Function:			iniparser_setstr
  Description:		Finds out if a given entry exists in a dictionary
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to modify,Entry to modify (entry name),New value to associate to the entry.
  Output:
  Return:			int 0 if Ok, -1 otherwise.
  Others:			If the given entry can be found in the dictionary, it is modified to
					contain the provided value. If it cannot be found, -1 is returned.
					It is Ok to set val to NULL.
*************************************************/
int iniparser_setstr(dictionary * ini, char * entry, char * val)
{
#ifndef DONOT_USE_LOW_LETTER_SECTION_NAME		
	dictionary_set(ini, strlwc(entry), val);
#else
	dictionary_set(ini, entry, val);
#endif
	return 0 ;
}

/*************************************************
  Function:			iniparser_unset
  Description:		Delete an entry in a dictionary
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to modify,Entry to delete (entry name)
  Output:
  Return:			
  Others:			If the given entry can be found, it is deleted from the dictionary.
*************************************************/
void iniparser_unset(dictionary * ini, char * entry)
{
#ifndef DONOT_USE_LOW_LETTER_SECTION_NAME				
	dictionary_unset(ini, strlwc(entry));
#else
	dictionary_unset(ini, entry);
#endif
}

/*************************************************
  Function:			iniparser_load
  Description:		Parse an ini file and return an allocated dictionary object
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			ininame Name of the ini file to read.
  Output:
  Return:			Pointer to newly allocated dictionary
  Others:			This is the parser for ini files. This function is called, providing
					the name of the file to be read. It returns a dictionary object that
					should not be accessed directly, but through accessor functions
					instead.

					The returned dictionary must be freed using iniparser_freedict().
*************************************************/
dictionary * iniparser_load(char * ininame)
{
	dictionary  *   d ;
	char        lin[ASCIILINESZ+1];
	char        sec[ASCIILINESZ+1];    
	char        key[ASCIILINESZ+1];
	char        val[ASCIILINESZ+1];
	char    *   where ;
	FILE    *   ini ;
	int         lineno ;

	if ((ini=fopen(ininame, "r"))==NULL)
	{
		return NULL ;
	}    

	sec[0]=0;

	/*
	* Initialize a new dictionary entry
	*/


	d = dictionary_new(0);


	lineno = 0 ;
	while (fgets(lin, ASCIILINESZ, ini)!=NULL)
	{
		lineno++ ;
		where = strskp(lin); /* Skip leading spaces */

		if (*where==';' || *where=='#' || *where==0)
		{
			continue ; /* Comment lines */
		}
		else
		{
			if (sscanf(where, "[%[^]]", sec)==1)
			{
				/* Valid section name */     
#ifndef DONOT_USE_LOW_LETTER_SECTION_NAME				
				strcpy(sec,strlwc (sec)); 				
#endif
				iniparser_add_entry(d, sec, NULL, NULL);				
			}
			else if (
				    sscanf (where, "\"%[^\"=]\" = \"%[^\"]\"", key, val) == 2
				||  sscanf (where, "\"%[^\"=]\" = '%[^\']'", key, val) == 2
				||  sscanf (where, "\"%[^\"=]\" = %[^;#]", key, val) == 2
				||  sscanf (where, "%[^=] = \"%[^\"]\"", key, val) == 2
				||  sscanf (where, "%[^=] = '%[^\']'",   key, val) == 2
				||  sscanf (where, "%[^=] = %[^;#]",     key, val) == 2)
			{
#ifndef DONOT_USE_LOW_LETTER_SECTION_NAME				
				strcpy(key, strlwc(strcrop(key)));		
#else
				strcpy(key, strcrop(key));
#endif
				/*
				 sscanf cannot handle "" or '' as empty value,
				 this is done here
				*/
				if (!strcmp(val, "\"\"") || !strcmp(val, "''")) 
				{
					val[0] = (char)0;
				} 
				else 
				{
					strcpy(val, strcrop(val));
				}
				iniparser_add_entry(d, sec, key, val);
			}
		}
	}

	fclose(ini);
	return d ;
}

/*************************************************
  Function:			iniparser_freedict
  Description:		Free all memory associated to an ini dictionary
  Calls:			
  Called By:		
  Table Accessed:
  Table Updated:
  Input:			Dictionary to free
  Output:
  Return:			
  Others:			Free all memory associated to an ini dictionary.
					It is mandatory to call this function before the dictionary object
					gets out of the current context.
*************************************************/
void iniparser_freedict(dictionary * d)
{
	dictionary_del(d);
}

}; //!namespace INI {