WebSVN – Games.Chess Giants – Diff – //inifile.cpp

 // 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 STRING_MAXSIZE 65536
 #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
+   wchar_t *key; // key string (mallocated)
    unsigned long hash; // key hash value
-   wchar_t value[MAX_VALUE_SIZE]; // value string
+   wchar_t *value; // value string (mallocated)
 } dictionary_entry_t;
 typedef struct dictionary_s
+{
 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 *INIFile_default_section = L"__default"; // MUST BE A READ-WRITE VARIABLE AND NOT A DEFINE
-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
 static void Dictionary_DestroyDictionary (dictionary_t *dictionary)
+{
    // frees a dictionary object and all memory associated to it.
+   int entry_index;
    if (dictionary == NULL)
       return; // consistency check
+   for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)
+   {
+      SAFE_free ((void **) &dictionary->entries[entry_index].key); // free all dictionary keys
+      SAFE_free ((void **) &dictionary->entries[entry_index].value); // free all dictionary values
+   }
    SAFE_free ((void **) &dictionary->entries); // free the entries array
    SAFE_free ((void **) &dictionary); // and finally, free the dictionary itself
    return; // finished
    // 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;
+   size_t bufsize;
    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++)
       // 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)
+         if (value == NULL)
-            wcscpy_s (dictionary->entries[entry_index].value, WSIZEOF (dictionary->entries[entry_index].value), value); // copy the value string
+            value = L""; // if a null value was specified, use an empty string
-         else
+         bufsize = wcslen (value) + 1;
+         dictionary->entries[entry_index].value = (wchar_t *) SAFE_realloc (dictionary->entries[entry_index].value, 0, bufsize, sizeof (wchar_t), false);
-            dictionary->entries[entry_index].value[0] = 0; // reset the value string
+         wcscpy_s (dictionary->entries[entry_index].value, bufsize, value); // copy the value string
          return; // value has been modified: return
+      }
+   }
       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
+   bufsize = wcslen (key) + 1;
+   dictionary->entries[entry_index].key = (wchar_t *) SAFE_malloc (bufsize, sizeof (wchar_t), false);
-   wcscpy_s (dictionary->entries[entry_index].key, WSIZEOF (dictionary->entries[entry_index].key), key); // copy the key string...
+   wcscpy_s (dictionary->entries[entry_index].key, bufsize, key); // copy the key string...
    dictionary->entries[entry_index].hash = hash; // ...and store the hash value
-   // have we provided a valid value ?
+   // copy the new value
-   if (value != NULL)
+   if (value == NULL)
-      wcscpy_s (dictionary->entries[entry_index].value, WSIZEOF (dictionary->entries[entry_index].value), value); // copy the value string
+      value = L""; // if a null value was specified, use an empty string
-   else
+   bufsize = wcslen (value) + 1;
+   dictionary->entries[entry_index].value = (wchar_t *) SAFE_malloc (bufsize, sizeof (wchar_t), false);
-      dictionary->entries[entry_index].value[0] = 0; // reset the value string
+   wcscpy_s (dictionary->entries[entry_index].value, bufsize, value); // copy the value string
    dictionary->entry_count++; // there is one more entry in the dictionary now
    return;
+}
+   }
    if (entry_index == dictionary->entry_count)
       return; // if key was not found, just return
-   // clear the key, the hash and its value data
+   // free its buffers, then clear the key, the hash and its value data
+   SAFE_free ((void **) &dictionary->entries[entry_index].key);
+   SAFE_free ((void **) &dictionary->entries[entry_index].value);
    memset (&dictionary->entries[entry_index], 0, sizeof (dictionary_entry_t));
    dictionary->entry_count--; // there is one entry less in the dictionary now
    return;
+}
    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);
+   length = wcslen (section);
    // 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)
+      if ((wcsncmp (entry->key, section, length) != 0) || (entry->key[length] != INI_SECTION_SEPARATOR))
          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
+         return (&entry->key[length + 1]); // 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
    // 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;
+   size_t length;
-   int i;
+   size_t i;
+   size_t keysize;
+   wchar_t *key;
    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
+   // allocate some space for the dictionary key name
+   keysize = wcslen (section) + 1 + wcslen (entry) + 1;
+   key = (wchar_t *) SAFE_malloc (keysize, sizeof (wchar_t), false);
    // 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
+      swprintf_s (key, keysize, L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key
-      i = (int) wcslen (temp_key); // get the key string length
+      i = wcslen (key); // get the key string length
-      if (i < WSIZEOF (temp_key))
+      if (i < keysize)
          length = i;
       else
-         length = WSIZEOF (temp_key) - 1; // clamp it to a max value
+         length = keysize - 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++)
+      for (i = wcslen (section) + 1; i < length; i++)
-         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase
+         key[i] = towlower (key[i]); // convert it to lowercase
-      temp_key[i] = 0; // terminate the string
+      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
+      wcscpy_s (key, keysize, section); // copy the name into the key
-   value = Dictionary_ReadKey ((dictionary_t *) ini_data, temp_key, default_value); // query the dictionary...
+   value = Dictionary_ReadKey ((dictionary_t *) ini_data, key, default_value); // query the dictionary...
+   SAFE_free ((void **) &key); // free the key name, we no longer need it
    return (value); // ...and return the 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)
+{
    // 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);
+   wchar_t *number_as_string;
+   // allocate some space for the number's string representation
+   number_as_string = (wchar_t *) SAFE_malloc (32, sizeof (wchar_t), false);
+   // build the long integer value equivalent string (use printf facility)
+   swprintf_s (number_as_string, 32, L"%ld", value);
    INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry
+   SAFE_free ((void **) &number_as_string); // free the number's string representation, we no longer need it
    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);
+   wchar_t *number_as_string;
+   // allocate some space for the number's string representation
+   number_as_string = (wchar_t *) SAFE_malloc (32, sizeof (wchar_t), false);
+   // build the long integer value equivalent string (use printf facility)
+   swprintf_s (number_as_string, 32, L"%lu", value);
    INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry
+   SAFE_free ((void **) &number_as_string); // free the number's string representation, we no longer need it
    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);
+   wchar_t *number_as_string;
+   // allocate some space for the number's string representation
+   number_as_string = (wchar_t *) SAFE_malloc (64, sizeof (wchar_t), false);
+   // build the long integer value equivalent string (use printf facility)
+   swprintf_s (number_as_string, 64, L"%g", value);
    INIFile_WriteEntryAsString ((dictionary_t *) ini_data, section, entry, number_as_string); // write the new entry
+   SAFE_free ((void **) &number_as_string); // free the number's string representation, we no longer need it
    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;
+   size_t length;
-   int i;
+   size_t i;
+   size_t keysize;
+   wchar_t *key;
    if (ini_data == NULL)
       return; // consistency check
    if (section == NULL)
       section = INIFile_default_section; // if no section was provided, use empty section name
+   // allocate some space for the dictionary key name
+   keysize = wcslen (section) + 1 + (entry != NULL ? wcslen (entry) + 1 : 0);
+   key = (wchar_t *) SAFE_malloc (keysize, sizeof (wchar_t), false);
    // 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
+      swprintf_s (key, keysize, L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key
-      i = (int) wcslen (temp_key); // get the key string length
+      i = wcslen (key); // get the key string length
-      if (i < WSIZEOF (temp_key))
+      if (i < keysize)
          length = i;
       else
-         length = WSIZEOF (temp_key) - 1; // clamp it to a max value
+         length = keysize - 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++)
+      for (i = wcslen (section) + 1; i < length; i++)
-         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase
+         key[i] = towlower (key[i]); // convert it to lowercase
-      temp_key[i] = 0; // terminate the string
+      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
+      wcscpy_s (key, keysize, section); // copy the name into the key
-   Dictionary_WriteKey ((dictionary_t *) ini_data, temp_key, value); // write the new key in the dictionary
+   Dictionary_WriteKey ((dictionary_t *) ini_data, key, value); // write the new key in the dictionary
+   SAFE_free ((void **) &key); // free the key name, we no longer need it
    return; // finished
+}
 void INIFile_DeleteEntry (void *ini_data, wchar_t *section, wchar_t *entry)
+{
    // deletes an entry in the dictionary
-   int length;
+   size_t length;
-   int i;
+   size_t i;
+   size_t keysize;
+   wchar_t *key;
    if (ini_data == NULL)
       return; // consistency check
    if (section == NULL)
       section = INIFile_default_section; // if no section was provided, use empty section name
+   // allocate some space for the dictionary key name
+   keysize = wcslen (section) + 1 + wcslen (entry) + 1;
+   key = (wchar_t *) SAFE_malloc (keysize, sizeof (wchar_t), false);
    // 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
+      swprintf_s (key, keysize, L"%s%c%s", section, INI_SECTION_SEPARATOR, entry); // compose the key
-      i = (int) wcslen (temp_key); // get the key string length
+      i = wcslen (key); // get the key string length
-      if (i < WSIZEOF (temp_key))
+      if (i < keysize)
          length = i;
       else
-         length = WSIZEOF (temp_key) - 1; // clamp it to a max value
+         length = keysize - 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++)
+      for (i = wcslen (section) + 1; i < length; i++)
-         temp_key[i] = towlower (temp_key[i]); // convert it to lowercase
+         key[i] = towlower (key[i]); // convert it to lowercase
-      temp_key[i] = 0; // terminate the string
+      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
+      wcscpy_s (key, keysize, section); // copy the name into the key
-   Dictionary_DeleteKey ((dictionary_t *) ini_data, temp_key);
+   Dictionary_DeleteKey ((dictionary_t *) ini_data, key);
+   SAFE_free ((void **) &key); // free the key name, we no longer need it
    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;
+   dictionary_entry_t *entry;
    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
+   length = (int) wcslen (section); // get the section string length
    // for each entry in the dictionary...
    for (i = 0; i < dictionary->entry_count; i++)
+   {
+      entry = &dictionary->entries[i]; // quick access to each entry
-      if (dictionary->entries[i].key[0] == 0)
+      if (entry->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)
+      if ((wcsncmp (entry->key, section, length) == 0) && (entry->key[length] == INI_SECTION_SEPARATOR))
-         Dictionary_DeleteKey (dictionary, dictionary->entries[i].key); // yes, delete it
+         Dictionary_DeleteKey (dictionary, entry->key); // yes, delete it
+   }
    Dictionary_DeleteKey (dictionary, section); // and finally delete the section name itself
    return;
+}
+{
    // 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.
+   wchar_t *line_buffer;
    FILE *fp;
    int fieldstart;
    int fieldstop;
    int length;
    int i;
    dictionary_t *dictionary;
+   wchar_t *current_section;
+   wchar_t *current_entry;
+   wchar_t *current_value;
    // 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);
+   // allocate some space for the current section, entry and values
+   current_section = (wchar_t *) SAFE_malloc (STRING_MAXSIZE, sizeof (wchar_t), false);
+   current_entry = (wchar_t *) SAFE_malloc (STRING_MAXSIZE, sizeof (wchar_t), false);
+   current_value = (wchar_t *) SAFE_malloc (STRING_MAXSIZE, sizeof (wchar_t), false);
    // set the default section for orphaned entries and add it to the dictionary
-   wcscpy_s (temp_section, WSIZEOF (temp_section), INIFile_default_section);
+   wcscpy_s (current_section, STRING_MAXSIZE, INIFile_default_section);
-   INIFile_WriteEntryAsString (dictionary, temp_section, NULL, NULL);
+   INIFile_WriteEntryAsString (dictionary, current_section, NULL, NULL);
+   // allocate some space for a line buffer
+   line_buffer = (wchar_t *) SAFE_malloc (STRING_MAXSIZE + STRING_MAXSIZE, sizeof (wchar_t), false);
    // read line per line...
-   while (fgetws (line_buffer, WSIZEOF (line_buffer), fp) != NULL)
+   while (fgetws (line_buffer, STRING_MAXSIZE + STRING_MAXSIZE, 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
       if ((line_buffer[0] == ';') || (line_buffer[0] == '#') || (line_buffer[0] == 0))
          continue; // skip comment lines
       // is it a valid section name ?
-      if (swscanf_s (line_buffer, L"[%[^]]", temp_section, WSIZEOF (temp_section)) == 1)
+      if (swscanf_s (line_buffer, L"[%[^]]", current_section, STRING_MAXSIZE) == 1)
+      {
-         length = (int) wcslen (temp_section); // get the section string length
+         length = (int) wcslen (current_section); // get the section string length
          fieldstart = 0; // let's now strip leading blanks
-         while ((fieldstart < length) && iswspace (temp_section[fieldstart]))
+         while ((fieldstart < length) && iswspace (current_section[fieldstart]))
             fieldstart++; // ignore any tabs or spaces, going forward from the start
          fieldstop = length - 1; // let's now strip trailing blanks
-         while ((fieldstop >= 0) && iswspace (temp_section[fieldstop]))
+         while ((fieldstop >= 0) && iswspace (current_section[fieldstop]))
             fieldstop--; // ignore any tabs or spaces, going backwards from the end
          for (i = fieldstart; i <= fieldstop; i++)
-            temp_section[i - fieldstart] = temp_section[i]; // recopy section name w/out spaces
+            current_section[i - fieldstart] = current_section[i]; // recopy section name w/out spaces
-         temp_section[i - fieldstart] = 0; // and terminate the string
+         current_section[i - fieldstart] = 0; // and terminate the string
-         INIFile_WriteEntryAsString (dictionary, temp_section, NULL, NULL); // add to dictionary
+         INIFile_WriteEntryAsString (dictionary, current_section, NULL, NULL); // add to dictionary
+      }
       // else is it a valid entry/value pair that is enclosed between quotes?
-      else if (swscanf_s (line_buffer, L"%[^=] = \"%[^\"]\"", temp_entry, WSIZEOF (temp_entry), temp_value, WSIZEOF (temp_value)) == 2)
+      else if (swscanf_s (line_buffer, L"%[^=] = \"%[^\"]\"", current_entry, STRING_MAXSIZE, current_value, STRING_MAXSIZE) == 2)
+      {
-         length = (int) wcslen (temp_entry); // get the entry string length
+         length = (int) wcslen (current_entry); // get the entry string length
          fieldstart = 0; // let's now strip leading blanks
-         while ((fieldstart < length) && iswspace (temp_entry[fieldstart]))
+         while ((fieldstart < length) && iswspace (current_entry[fieldstart]))
             fieldstart++; // ignore any tabs or spaces, going forward from the start
          fieldstop = length - 1; // let's now strip trailing blanks
-         while ((fieldstop >= 0) && iswspace (temp_entry[fieldstop]))
+         while ((fieldstop >= 0) && iswspace (current_entry[fieldstop]))
             fieldstop--; // ignore any tabs or spaces, going backwards from the end
          for (i = fieldstart; i <= fieldstop; i++)
-            temp_entry[i - fieldstart] = towlower (temp_entry[i]); // recopy entry name w/out spaces
+            current_entry[i - fieldstart] = towlower (current_entry[i]); // recopy entry name w/out spaces
-         temp_entry[i - fieldstart] = 0; // and terminate the string
+         current_entry[i - fieldstart] = 0; // and terminate the string
          // when value is enclosed between quotes, DO NOT strip the blanks
          // sscanf cannot handle "" or '' as empty value, this is done here
-         if ((wcscmp (temp_value, L"\"\"") == 0) || (wcscmp (temp_value, L"''") == 0))
+         if ((wcscmp (current_value, L"\"\"") == 0) || (wcscmp (current_value, L"''") == 0))
-            temp_value[0] = 0; // empty string
+            current_value[0] = 0; // empty string
-         INIFile_WriteEntryAsString (dictionary, temp_section, temp_entry, temp_value); // add to dictionary
+         INIFile_WriteEntryAsString (dictionary, current_section, current_entry, current_value); // add to dictionary
+      }
       // else is it a valid entry/value pair without quotes ?
-      else if ((swscanf_s (line_buffer, L"%[^=] = '%[^\']'", temp_entry, WSIZEOF (temp_entry), temp_value, WSIZEOF (temp_value)) == 2)
+      else if ((swscanf_s (line_buffer, L"%[^=] = '%[^\']'", current_entry, STRING_MAXSIZE, current_value, STRING_MAXSIZE) == 2)
-               || (swscanf_s (line_buffer, L"%[^=] = %[^;#]", temp_entry, WSIZEOF (temp_entry), temp_value, WSIZEOF (temp_value)) == 2))
+               || (swscanf_s (line_buffer, L"%[^=] = %[^;#]", current_entry, STRING_MAXSIZE, current_value, STRING_MAXSIZE) == 2))
+      {
-         length = (int) wcslen (temp_entry); // get the entry string length
+         length = (int) wcslen (current_entry); // get the entry string length
          fieldstart = 0; // let's now strip leading blanks
-         while ((fieldstart < length) && iswspace (temp_entry[fieldstart]))
+         while ((fieldstart < length) && iswspace (current_entry[fieldstart]))
             fieldstart++; // ignore any tabs or spaces, going forward from the start
          fieldstop = length - 1; // let's now strip trailing blanks
-         while ((fieldstop >= 0) && iswspace (temp_entry[fieldstop]))
+         while ((fieldstop >= 0) && iswspace (current_entry[fieldstop]))
             fieldstop--; // ignore any tabs or spaces, going backwards from the end
          for (i = fieldstart; i <= fieldstop; i++)
-            temp_entry[i - fieldstart] = towlower (temp_entry[i]); // recopy entry name w/out spaces
+            current_entry[i - fieldstart] = towlower (current_entry[i]); // recopy entry name w/out spaces
-         temp_entry[i - fieldstart] = 0; // and terminate the string
+         current_entry[i - fieldstart] = 0; // and terminate the string
-         length = (int) wcslen (temp_value); // get the value string length
+         length = (int) wcslen (current_value); // get the value string length
          fieldstart = 0; // let's now strip leading blanks
-         while ((fieldstart < length) && iswspace (temp_value[fieldstart]))
+         while ((fieldstart < length) && iswspace (current_value[fieldstart]))
             fieldstart++; // ignore any tabs or spaces, going forward from the start
          fieldstop = length - 1; // let's now strip trailing blanks
-         while ((fieldstop >= 0) && iswspace (temp_value[fieldstop]))
+         while ((fieldstop >= 0) && iswspace (current_value[fieldstop]))
             fieldstop--; // ignore any tabs or spaces, going backwards from the end
          for (i = fieldstart; i <= fieldstop; i++)
-            temp_value[i - fieldstart] = temp_value[i]; // recopy entry name w/out spaces
+            current_value[i - fieldstart] = current_value[i]; // recopy entry name w/out spaces
-         temp_value[i - fieldstart] = 0; // and terminate the string
+         current_value[i - fieldstart] = 0; // and terminate the string
          // sscanf cannot handle "" or '' as empty value, this is done here
-         if ((wcscmp (temp_value, L"\"\"") == 0) || (wcscmp (temp_value, L"''") == 0))
+         if ((wcscmp (current_value, L"\"\"") == 0) || (wcscmp (current_value, L"''") == 0))
-            temp_value[0] = 0; // empty string
+            current_value[0] = 0; // empty string
-         INIFile_WriteEntryAsString (dictionary, temp_section, temp_entry, temp_value); // add to dictionary
+         INIFile_WriteEntryAsString (dictionary, current_section, current_entry, current_value); // add to dictionary
+      }
+   }
    fclose (fp); // finished, close the file
+   SAFE_free ((void **) &line_buffer); // free the line buffer we allocated at the beginning of the function
+   SAFE_free ((void **) &current_value); // free the current value buffer we allocated at the beginning of the function
+   SAFE_free ((void **) &current_entry); // free the current entry buffer we allocated at the beginning of the function
+   SAFE_free ((void **) &current_section); // free the current section buffer we allocated at the beginning of the function
-   return ((void *) dictionary); // and return
+   return ((void *) dictionary); // and return a pointer to it
+}
 unsigned char INIFile_SaveINIFile (const wchar_t *filename, void *ini_data)
+{
       if (wcscmp (section_name, INIFile_default_section) == 0)
          fwprintf (fp, L"\n"); // don't put the default section's name in the INI file
       else
          fwprintf (fp, L"\n[%s]\n", section_name); // dump all other sections into the INI file
-      // build the section identifier to be used when looking up the dictionary
-      swprintf_s (temp_key, WSIZEOF (temp_key), L"%s%c", section_name, INI_SECTION_SEPARATOR);
-      length = (int) wcslen (temp_key);
+      length = (int) wcslen (section_name);
       // then for each entry in the dictionary...
       for (entry_index = 0; entry_index < dictionary->entry_count; entry_index++)
+      {
          entry = &dictionary->entries[entry_index]; // quick access to entry
          if (entry->key[0] == 0)
             continue; // skip empty slots
          // does this key belong to the section we want ? if so, dump it
-         if (wcsncmp (entry->key, temp_key, length) == 0)
+         if ((wcsncmp (entry->key, section_name, length) == 0) && (entry->key[length] == INI_SECTION_SEPARATOR))
+         {
             // if key starts or ends with a space, enclose it between quotes, else don't
             if ((entry->value[0] != 0)
                 && (iswspace (entry->value[0]) || iswspace (entry->value[wcslen (entry->value) - 1])))
-               fwprintf (fp, L"%s = \"%s\"\n", entry->key + length, entry->value);
+               fwprintf (fp, L"%s = \"%s\"\n", &entry->key[length + 1], entry->value);
             else
-               fwprintf (fp, L"%s = %s\n", entry->key + length, entry->value);
+               fwprintf (fp, L"%s = %s\n", &entry->key[length + 1], entry->value);
+         }
+      }
+   }
    fclose (fp); // finished, close the file

Subversion Repositories Games.Chess Giants

Games.Chess Giants//inifile.cpp – Rev 1 → 136