Subversion Repositories Games.Chess Giants

// inifile.c

#include "common.h"

// WARNING: INI SECTION NAMES ARE CASE SENSITIVE, BUT KEY NAMES ARE NOT!

// internal definitions

#define MAX_KEY_SIZE 124

#define MAX_VALUE_SIZE 3968

#define DICTIONARY_PAGE_SIZE 128

#define INI_SECTION_SEPARATOR ']'

#define INI_INVALID_KEY (wchar_t *) 0x7fffffff

#define WSIZEOF(a) (sizeof (a) / sizeof (wchar_t))

// dictionary structure definitions

typedef struct dictionary_entry_s

{

   wchar_t key[MAX_KEY_SIZE]; // key string

   unsigned long hash; // key hash value

   wchar_t value[MAX_VALUE_SIZE]; // value string

} dictionary_entry_t;

typedef struct dictionary_s

{

   int size; // storage size

   dictionary_entry_t *entries; // array of entries (mallocated)

   int entry_count; // number of entries in dictionary

} dictionary_t;

// dictionary function prototypes

static dictionary_t *Dictionary_CreateDictionary (int size);

static void Dictionary_DestroyDictionary (dictionary_t *dictionary);

static dictionary_entry_t *Dictionary_GetKey (dictionary_t *dictionary, wchar_t *key);

static wchar_t *Dictionary_ReadKey (dictionary_t *dictionary, wchar_t *key, wchar_t *default_value);

static void Dictionary_WriteKey (dictionary_t *dictionary, wchar_t *key, wchar_t *value);

static void Dictionary_DeleteKey (dictionary_t *dictionary, wchar_t *key);

static unsigned long Dictionary_ComputeHashValueForKey (wchar_t *key);

// ini file function prototypes

void *INIFile_NewINIFile (void);

int INIFile_GetNumberOfSections (void *ini_data);

wchar_t *INIFile_GetSectionName (void *ini_data, int section_index);

int INIFile_GetNumberOfEntries (void *ini_data, wchar_t *section);

wchar_t *INIFile_GetEntryName (void *ini_data, wchar_t *section, int entry_index);

unsigned char INIFile_ReadEntryAsBool (void *ini_data, wchar_t *section, wchar_t *entry, unsigned char default_value);

long INIFile_ReadEntryAsLong (void *ini_data, wchar_t *section, wchar_t *entry, long default_value);

unsigned long INIFile_ReadEntryAsUnsignedLong (void *ini_data, wchar_t *section, wchar_t *entry, unsigned long default_value);

double INIFile_ReadEntryAsDouble (void *ini_data, wchar_t *section, wchar_t *entry, double default_value);

wchar_t *INIFile_ReadEntryAsString (void *ini_data, wchar_t *section, wchar_t *entry, wchar_t *default_value);

void INIFile_WriteEntryAsBool (void *ini_data, wchar_t *section, wchar_t *entry, unsigned char value);

void INIFile_WriteEntryAsLong (void *ini_data, wchar_t *section, wchar_t *entry, long value);

void INIFile_WriteEntryAsUnsignedLong (void *ini_data, wchar_t *section, wchar_t *entry, unsigned long value);

void INIFile_WriteEntryAsDouble (void *ini_data, wchar_t *section, wchar_t *entry, double value);

void INIFile_WriteEntryAsString (void *ini_data, wchar_t *section, wchar_t *entry, wchar_t *value);

void INIFile_DeleteEntry (void *ini_data, wchar_t *section, wchar_t *entry);

void INIFile_DeleteSection (void *ini_data, wchar_t *section);

void *INIFile_LoadINIFile (const wchar_t *filename);

unsigned char INIFile_SaveINIFile (const wchar_t *filename, void *ini_data);

void INIFile_FreeINIFile (void *ini_data);

// internal variables

static wchar_t *INIFile_default_section = L"__default";

static wchar_t line_buffer[MAX_KEY_SIZE + MAX_VALUE_SIZE];

static wchar_t temp_key[MAX_KEY_SIZE];

static wchar_t number_as_string[256];

static wchar_t temp_section[MAX_KEY_SIZE];

static wchar_t temp_entry[MAX_KEY_SIZE];

static wchar_t temp_value[MAX_VALUE_SIZE];

static dictionary_t *Dictionary_CreateDictionary (int size)

{

   // this function allocates a new dictionary object of given size and returns it. If you do

   // not know in advance (roughly) the number of entries in the dictionary, give size = 0.

   dictionary_t *dictionary;

   // if no size was specified, allocate space for one page

   if (size < DICTIONARY_PAGE_SIZE)

      size = DICTIONARY_PAGE_SIZE;

   // allocate one instance of the dictionary and blank it out

   dictionary = (dictionary_t *) SAFE_malloc (1, sizeof (dictionary_t), true);

   dictionary->size = size; // dictionary can currently hold size entries

   // allocate space for the dictionary entries and zero all the crap out

   dictionary->entries = (dictionary_entry_t *) SAFE_malloc (size, sizeof (dictionary_entry_t), true);

   return (dictionary); // finished, return a pointer to the dictionary object

}

static void Dictionary_DestroyDictionary (dictionary_t *dictionary)

{

   // frees a dictionary object and all memory associated to it.

   if (dictionary == NULL)

      return; // consistency check

   SAFE_free ((void **) &dictionary->entries); // free the entries array

   SAFE_free ((void **) &dictionary); // and finally, free the dictionary itself

   return; // finished

}

static dictionary_entry_t *Dictionary_GetKey (dictionary_t *dictionary, wchar_t *key)

{

   // this function locates a key in a dictionary and returns a pointer to it, or a NULL

   // pointer if no such key can be found in dictionary. The returned pointer points to data

   // internal to the dictionary object, do not try to free or modify it.

   unsigned long hash;

   register int entry_index;

   hash = Dictionary_ComputeHashValueForKey (key); // get the hash value for key

   // cycle through all entries in the dictionary

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

         continue; // skip empty slots

      // compare hash AND string, to avoid hash collisions

      if ((hash == dictionary->entries[entry_index].hash) && (wcscmp (key, dictionary->entries[entry_index].key) == 0))

         return (&dictionary->entries[entry_index]); // return a pointer to the key if we find it

   }

   return (NULL); // else return a NULL pointer

}

static wchar_t *Dictionary_ReadKey (dictionary_t *dictionary, wchar_t *key, wchar_t *default_value)

{

   // this function locates a key in a dictionary and returns a pointer to its value, or the

   // passed 'def' pointer if no such key can be found in dictionary. The returned char pointer

   // points to data internal to the dictionary object, do not try to free or modify it.

   dictionary_entry_t *element;

   element = Dictionary_GetKey (dictionary, key); // query the dictionary for the key

   if (element != NULL)

      return (element->value); // if we found a valid key, return the value associed to it

   return (default_value); // else return the default value

}

static void Dictionary_WriteKey (dictionary_t *dictionary, wchar_t *key, wchar_t *value)

{

   // sets a value in a dictionary. If the given key is found in the dictionary, the associated

   // value is replaced by the provided one. If the key cannot be found in the dictionary, it

   // is added to it.

   unsigned long hash;

   register int entry_index;

   hash = Dictionary_ComputeHashValueForKey (key); // compute hash for this key

   // for each entry in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

          continue; // skip empty slots

      // does that key have the same hash value AND the same name ?

      if ((hash == dictionary->entries[entry_index].hash) && (wcscmp (key, dictionary->entries[entry_index].key) == 0))

      {

         // we've found the right key: modify its value and return

         // have we provided a valid value ?

         if (value != NULL)

            wcscpy_s (dictionary->entries[entry_index].value, WSIZEOF (dictionary->entries[entry_index].value), value); // copy the value string

         else

            dictionary->entries[entry_index].value[0] = 0; // reset the value string

         return; // value has been modified: return

      }

   }

   // here either the dictionary was empty, or we couldn't find a similar value: add a new one

   // cycle through all entries in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

      if (dictionary->entries[entry_index].key[0] == 0)

         break; // and stop at the first empty one we find

   // no empty entry found, see if dictionary needs to grow or if there's still room left

   if (entry_index == dictionary->size)

   {

      // mallocate some more space for the dictionary and zero all that crap out

      dictionary->entries = (dictionary_entry_t *) SAFE_realloc (dictionary->entries, dictionary->size, dictionary->size + DICTIONARY_PAGE_SIZE, sizeof (dictionary_entry_t), false); // alloc 1 more page

      dictionary->size += DICTIONARY_PAGE_SIZE; // increase dictionary size

   }

   // copy the new key

   wcscpy_s (dictionary->entries[entry_index].key, WSIZEOF (dictionary->entries[entry_index].key), key); // copy the key string...

   dictionary->entries[entry_index].hash = hash; // ...and store the hash value

   // have we provided a valid value ?

   if (value != NULL)

      wcscpy_s (dictionary->entries[entry_index].value, WSIZEOF (dictionary->entries[entry_index].value), value); // copy the value string

   else

      dictionary->entries[entry_index].value[0] = 0; // reset the value string

   dictionary->entry_count++; // there is one more entry in the dictionary now

   return;

}

static void Dictionary_DeleteKey (dictionary_t *dictionary, wchar_t *key)

{

   // this function deletes a key in a dictionary. Nothing is done if the key cannot be found.

   unsigned long hash;

   register int entry_index;

   hash = Dictionary_ComputeHashValueForKey (key); // get the hash value for key

   // cycle through all entries in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

         continue; // skip empty slots

      // compare hash AND string, to avoid hash collisions

      if ((hash == dictionary->entries[entry_index].hash) && (wcscmp (key, dictionary->entries[entry_index].key) == 0))

         break; // break as soon as we've found the key we want

   }

   if (entry_index == dictionary->entry_count)

      return; // if key was not found, just return

   // clear the key, the hash and its value data

   memset (&dictionary->entries[entry_index], 0, sizeof (dictionary_entry_t));

   dictionary->entry_count--; // there is one entry less in the dictionary now

   return;

}

static unsigned long Dictionary_ComputeHashValueForKey (wchar_t *key)

{

   // Compute the hash key for a string. This hash function has been taken from an article in

   // Dr Dobbs Journal. This is normally a collision-free function, distributing keys evenly.

   // The key is stored anyway in the struct so that collision can be avoided by comparing the

   // key itself in last resort. THIS FUNCTION IS TO BE USED INTERNALLY ONLY!

   register unsigned long hash;

   int length;

   int char_index;

   hash = 0;

   length = (int) wcslen (key);

   // for each character of the string...

   for (char_index = 0; char_index < length; char_index++)

   {

      hash += (unsigned long) key[char_index]; // take it in account and compute the hash value

      hash += (hash << 10);

      hash ^= (hash >> 6);

   }

   hash += (hash << 3); // finalize hashing (what the hell does it do, I have no clue)

   hash ^= (hash >> 11);

   hash += (hash << 15);

   return (hash); // and return the hash value

}

void *INIFile_NewINIFile (void)

{

   // allocates a dictionary for a new INI file. Mostly a helper function.

   return ((void *) Dictionary_CreateDictionary (0));

}

int INIFile_GetNumberOfSections (void  *ini_data)

{

   // this function returns the number of sections found in a dictionary. The test to recognize

   // sections is done on the string stored in the dictionary: a section name is given as

   // "section" whereas a key is stored as "section]key", thus the test looks for entries that

   // do NOT contain a ']'. This clearly fails in the case a section name contains a ']',

   // but this should simply be avoided.

   int section_count;

   int entry_index;

   dictionary_t *dictionary;

   if (ini_data == NULL)

      return (0); // consistency check

   dictionary = (dictionary_t *) ini_data;

   section_count = 0; // no sections found yet

   // for each entry in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

         continue; // skip empty slots

      if (wcschr (dictionary->entries[entry_index].key, INI_SECTION_SEPARATOR) == NULL)

         section_count++; // if this entry has NO section separator, then it's a section name

   }

   return (section_count); // return the section count we found

}

wchar_t *INIFile_GetSectionName (void *ini_data, int section_index)

{

   // this function locates the n-th section in a dictionary and returns its name as a pointer

   // to a string allocated inside the dictionary. Do not free or modify the returned string!!

   // This function returns NULL in case of error.

   int sections_found;

   int entry_index;

   dictionary_t *dictionary;

   if ((ini_data == NULL) || (section_index < 0))

      return (NULL); // consistency check

   dictionary = (dictionary_t *) ini_data;

   sections_found = 0; // no sections found yet

   // for each entry in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

         continue; // skip empty slots

      // is this entry a section name ?

      if (wcschr (dictionary->entries[entry_index].key, INI_SECTION_SEPARATOR) == NULL)

      {

         // is it the section we want ?

         if (sections_found == section_index)

            return (dictionary->entries[entry_index].key); // then return its name

         sections_found++; // we found one section more

      }

   }

   return (INIFile_default_section); // section was not found, return the default section name

}

int INIFile_GetNumberOfEntries (void  *ini_data, wchar_t *section)

{

   // this function returns the number of entries found in a dictionary within a given section.

   // The test to recognize section entries is done on the string stored in the dictionary: a

   // section name is given as "section" whereas a key is stored as "section]key", thus the test

   // looks for all entries that begin with "section]".

   int entry_count;

   int entry_index;

   int sectionname_length;

   dictionary_t *dictionary;

   if (ini_data == NULL)

      return (0); // consistency check

   dictionary = (dictionary_t *) ini_data;

   sectionname_length = wcslen (section);

   entry_count = 0; // no entries found yet

   // for each entry in the dictionary...

   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)

   {

      if (dictionary->entries[entry_index].key[0] == 0)

         continue; // skip empty slots

      if ((wcsncmp (dictionary->entries[entry_index].key, section, sectionname_length) == 0)

          && (dictionary->entries[entry_index].key[sectionname_length] == INI_SECTION_SEPARATOR))

         entry_count++; // if this entry has section name + separator, then it's one of those we want

   }

   return (entry_count); // return the number of entries we found in the given section

}

wchar_t *INIFile_GetEntryName (void *ini_data, wchar_t *section, int entry_index)

{

   // 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, NULL is returned. The returned char pointer

   // points to a string allocated in the dictionary, do not free or modify it.

   int i;

   int length;

   int found_keys;

   dictionary_t *dictionary;

   dictionary_entry_t *entry;

   if (ini_data == NULL)

      return (NULL); // consistency check

   if (section == NULL)

      section = INIFile_default_section; // if no section was provided, use empty section name

   dictionary = (dictionary_t *) ini_data; // quick access to dictionary

   // build the key entry prefix

   swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c", section, INI_SECTION_SEPARATOR); // compose the key

   length = wcslen (temp_key);

   // cycle through all remaining entries

   found_keys = 0;

   for (i = 0; i < dictionary->entry_count; i++)

   {

      entry = &dictionary->entries[i]; // quick access to each entry

      if (wcsncmp (entry->key, temp_key, length) != 0)

         continue; // if this key doesn't belong to the wanted section, skip it

      // this key belongs to the wanted section. Is it the key we want ?

      if (found_keys == entry_index)

         return (&entry->key[length]); // if so, return its name

      found_keys++; // it wasn't the key we want, so increase counter and proceed to the next one

   }

   return (NULL); // if not found, return NULL

}

unsigned char INIFile_ReadEntryAsBool (void *ini_data, wchar_t *section, wchar_t *entry, unsigned char default_value)

{

   // 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 a string starting with either 'y', 'Y', 't', 'T' or '1' is matched. A false

   // boolean is found if a string starting with 'n', 'N', 'f', 'F' or '0' is matched.

   wchar_t *value;

   if (ini_data == NULL)

      return (default_value); // consistency check

   // get the value as a string first

   value = INIFile_ReadEntryAsString ((dictionary_t *) ini_data, section, entry, INI_INVALID_KEY);

   if (value == INI_INVALID_KEY)

      return (default_value); // if the entry could not be read, return the default value

   // decide of the boolean's value by looking at the first character

   if ((toupper (value[0]) == 'T') || (toupper (value[0]) == 'Y') || (value[0] == '1'))

     return (1); // boolean value is TRUE

   else if ((toupper (value[0]) == 'F') || (toupper (value[0]) == 'N') || (value[0] == '0'))

     return (0); // boolean value is FALSE

   return (default_value); // boolean value is undefined, return default value

}

long INIFile_ReadEntryAsLong (void *ini_data, wchar_t *section, wchar_t *entry, long default_value)

{

   // 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.

   wchar_t *value;

   if (ini_data == NULL)

      return (default_value); // consistency check

   // get the value as a string first

   value = INIFile_ReadEntryAsString ((dictionary_t *) ini_data, section, entry, INI_INVALID_KEY);

   if (value == INI_INVALID_KEY)

      return (default_value); // if the entry could not be read, return the default value

   return (_wtol (value)); // else convert the value to a long integer and return it

}

unsigned long INIFile_ReadEntryAsUnsignedLong (void *ini_data, wchar_t *section, wchar_t *entry, unsigned long default_value)

{

   // 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.

   wchar_t *value;

   if (ini_data == NULL)

      return (default_value); // consistency check

   // get the value as a string first

   value = INIFile_ReadEntryAsString ((dictionary_t *) ini_data, section, entry, INI_INVALID_KEY);

   if (value == INI_INVALID_KEY)

      return (default_value); // if the entry could not be read, return the default value

   return (wcstoul (value, NULL, 10)); // else convert the value to a long integer and return it

}

double INIFile_ReadEntryAsDouble (void *ini_data, wchar_t *section, wchar_t *entry, double default_value)

{

   // 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.

   wchar_t *value;

   if (ini_data == NULL)

      return (default_value); // consistency check

   // get the value as a string first

   value = INIFile_ReadEntryAsString ((dictionary_t *) ini_data, section, entry, INI_INVALID_KEY);

   if (value == INI_INVALID_KEY)

      return (default_value); // if the entry could not be read, return the default value

   return (_wtof (value)); // else convert the value to a double precision number and return it

}

wchar_t *INIFile_ReadEntryAsString (void *ini_data, wchar_t *section, wchar_t *entry, wchar_t *default_value)

{

   // 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 points to a string allocated in the dictionary, do not free or

   // modify it.

   int length;

   int i;

   wchar_t *value;

   if (ini_data == NULL)

      return (default_value); // consistency check

   if (section == NULL)

      section = INIFile_default_section; // if no section was provided, use empty section name

   // if we were given an entry, build a key as section]entry

   if (entry != NULL)

   {

      swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key

      i = (int) wcslen (temp_key); // get the key string length

      if (i < WSIZEOF (temp_key))

         length = i;

      else

         length = WSIZEOF (temp_key) - 1; // clamp it to a max value

      // for each character in the string after the section separator...

      for (i = (int) wcslen (section) + 1; i < length; i++)

         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase

      temp_key[i] = 0; // terminate the string

   }

   // else it must be a section name

   else

      wcscpy_s (temp_key, WSIZEOF (temp_key), section); // copy the name into the key

   value = Dictionary_ReadKey ((dictionary_t *) ini_data, temp_key, default_value); // query the dictionary...

   return (value); // ...and return the value

}

void INIFile_WriteEntryAsBool (void *ini_data, wchar_t *section, wchar_t *entry, unsigned char value)

{

   // sets an entry in a dictionary. If the given entry can be found in the dictionary, it is

   // modified to contain the provided value. If it cannot be found, it is created.

   // according the boolean's value, write the equivalent string

   if (value)

      INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, L"true"); // write the new entry

   else

      INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, L"false"); // write the new entry

   return; // finished

}

void INIFile_WriteEntryAsLong (void *ini_data, wchar_t *section, wchar_t *entry, long value)

{

   // sets an entry in a dictionary. If the given entry can be found in the dictionary, it is

   // modified to contain the provided value. If it cannot be found, it is created.

   // build the long integer value equivalent string (use printf facility)

   swprintf_s (number_as_string, WSIZEOF (number_as_string), L"%ld", value);

   INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry

   return; // finished

}

void INIFile_WriteEntryAsUnsignedLong (void *ini_data, wchar_t *section, wchar_t *entry, unsigned long value)

{

   // sets an entry in a dictionary. If the given entry can be found in the dictionary, it is

   // modified to contain the provided value. If it cannot be found, it is created.

   // build the long integer value equivalent string (use printf facility)

   swprintf_s (number_as_string, WSIZEOF (number_as_string), L"%lu", value);

   INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry

   return; // finished

}

void INIFile_WriteEntryAsDouble (void *ini_data, wchar_t *section, wchar_t *entry, double value)

{

   // sets an entry in a dictionary. If the given entry can be found in the dictionary, it is

   // modified to contain the provided value. If it cannot be found, it is created.

   // build the long integer value equivalent string (use printf facility)

   swprintf_s (number_as_string, WSIZEOF (number_as_string), L"%g", value);

   INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry

   return; // finished

}

void INIFile_WriteEntryAsString (void *ini_data, wchar_t *section, wchar_t *entry, wchar_t *value)

{

   // sets an entry in a dictionary. If the given entry can be found in the dictionary, it is

   // modified to contain the provided value. If it cannot be found, it is created.

   int length;

   int i;

   if (ini_data == NULL)

      return; // consistency check

   if (section == NULL)

      section = INIFile_default_section; // if no section was provided, use empty section name

   // if we were given an entry, build a key as section#entry

   if (entry != NULL)

   {

      Dictionary_WriteKey ((dictionary_t *) ini_data, section, NULL); // create the section if it doesn't exist

      swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key

      i = (int) wcslen (temp_key); // get the key string length

      if (i < WSIZEOF (temp_key))

         length = i;

      else

         length = WSIZEOF (temp_key) - 1; // clamp it to a max value

      // for each character in the string after the section separator...

      for (i = (int) wcslen (section) + 1; i < length; i++)

         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase

      temp_key[i] = 0; // terminate the string

   }

   // else it must be a section name

   else

      wcscpy_s (temp_key, WSIZEOF (temp_key), section); // copy the name into the key

   Dictionary_WriteKey ((dictionary_t *) ini_data, temp_key, value); // write the new key in the dictionary

   return; // finished

}

void INIFile_DeleteEntry (void *ini_data, wchar_t *section, wchar_t *entry)

{

   // deletes an entry in the dictionary

   int length;

   int i;

   if (ini_data == NULL)

      return; // consistency check

   if (section == NULL)

      section = INIFile_default_section; // if no section was provided, use empty section name

   // if we were given an entry, build a key as section#entry

   if (entry != NULL)

   {

      swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key

      i = (int) wcslen (temp_key); // get the key string length

      if (i < WSIZEOF (temp_key))

         length = i;

      else

         length = WSIZEOF (temp_key) - 1; // clamp it to a max value

      // for each character in the string after the section separator...

      for (i = (int) wcslen (section) + 1; i < length; i++)

         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase

      temp_key[i] = 0; // terminate the string

   }

   // else it must be a section name

   else

      wcscpy_s (temp_key, WSIZEOF (temp_key), section); // copy the name into the key

   Dictionary_DeleteKey ((dictionary_t *) ini_data, temp_key);

   return;

}

void INIFile_DeleteSection (void *ini_data, wchar_t *section)

{

   // deletes a whole INI section in the dictionary

   int length;

   int i;

   dictionary_t *dictionary;

   if (ini_data == NULL)

      return; // consistency check

   if (section == NULL)

      section = INIFile_default_section; // if no section was provided, use empty section name

   dictionary = (dictionary_t *) ini_data;

   swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c", section, INI_SECTION_SEPARATOR); // compose the key

   length = (int) wcslen (temp_key); // get the key string length

   // for each entry in the dictionary...

   for (i = 0; i < dictionary->entry_count; i++)

   {

      if (dictionary->entries[i].key[0] == 0)

         continue; // skip empty slots

      // does this entry belong to the section we want ?

      if (wcsncmp (dictionary->entries[i].key, temp_key, length) == 0)

         Dictionary_DeleteKey (dictionary, dictionary->entries[i].key); // yes, delete it

   }

   Dictionary_DeleteKey (dictionary, section); // and finally delete the section name itself

   return;

}

void *INIFile_LoadINIFile (const wchar_t *filename)

{

   // 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.

   FILE *fp;

   int fieldstart;

   int fieldstop;

   int length;

   int i;

   dictionary_t *dictionary;

   // try to open the INI file in ASCII read-only mode

   fp = _wfsopen (filename, L"r, ccs=UNICODE", _SH_DENYNO);

   if (fp == NULL)

      return (NULL); // cancel if file not found

   dictionary = Dictionary_CreateDictionary (0);

   // set the default section for orphaned entries and add it to the dictionary

   wcscpy_s (temp_section, WSIZEOF (temp_section), INIFile_default_section);

   INIFile_WriteEntryAsString (dictionary, temp_section, NULL, NULL);

   // read line per line...

   while (fgetws (line_buffer, WSIZEOF (line_buffer), fp) != NULL)

   {

      length = (int) wcslen (line_buffer); // get line length

      while ((length > 0) && ((line_buffer[length - 1] == '\n') || (line_buffer[length - 1] == '\r')))

         length--; // discard trailing newlines

      fieldstart = 0; // let's now strip leading blanks

      while ((fieldstart < length) && iswspace (line_buffer[fieldstart]))