From 2dc3d8ac2cbbd86533ef73b8e842d34df1618129 Mon Sep 17 00:00:00 2001 From: Darkvater Date: Sat, 4 Feb 2006 22:48:57 +0000 Subject: [PATCH] (svn r3547) - [Patches]: do some general cleanup, commentarization before starting actual work. This patch contains no functional changes (I hope). It might break GPMI-builds though when trying to join a trunk/ network game or vice versa. To solve, you can change the order of the first 8 enums in SettingDescType. I think that'll work. --- settings.c | 324 ++++++++++++++++++++++++++++++----------------------- settings.h | 61 ++++++---- 2 files changed, 223 insertions(+), 162 deletions(-) diff --git a/settings.c b/settings.c index b0e16b9777..148fe3e6fd 100644 --- a/settings.c +++ b/settings.c @@ -286,14 +286,12 @@ static IniItem *ini_getitem(IniGroup *group, const char *name, bool create) uint len = strlen(name); for (item = group->item; item; item = item->next) - if (!strcmp(item->name, name)) - return item; + if (strcmp(item->name, name) == 0) return item; if (!create) return NULL; // otherwise make a new one - item = ini_item_alloc(group, name, len); - return item; + return ini_item_alloc(group, name, len); } // save ini file from the "abstract" format. @@ -328,6 +326,11 @@ static void ini_free(IniFile *ini) pool_free(&ini->pool); } +/* Find the index value of a ONEofMANY type in a string seperated by | + * @param many full domain of values the ONEofMANY setting can have + * @param one the current value of the setting for which a value needs found + * @param onelen force calculation of the *one parameter + * @return the integer index of the full-list, or -1 if not found */ static int lookup_oneofmany(const char *many, const char *one, int onelen) { const char *s; @@ -351,6 +354,11 @@ static int lookup_oneofmany(const char *many, const char *one, int onelen) } } +/* Find the set-integer value MANYofMANY type in a string + * @param many full domain of values the MANYofMANY setting can have + * @param str the current string value of the setting, each individual + * of seperated by a whitespace\tab or | character + * @return the 'fully' set integer, or -1 if a set is not found */ static uint32 lookup_manyofmany(const char *many, const char *str) { const char *s; @@ -368,13 +376,18 @@ static uint32 lookup_manyofmany(const char *many, const char *str) r = lookup_oneofmany(many, str, s - str); if (r == -1) return (uint32)-1; - res |= (1 << r); + SETBIT(res, r); // value found, set it if (*s == 0) break; str = s + 1; } return res; } +/** Parse an integerlist string and set each found value + * @param p the string to be parsed. Each element in the list is seperated by a comma + * @param items pointer to the integerlist-array that will be filled with values + * @param maxitems the maximum number of elements the integerlist-array has + * @return returns the number of items found, or -1 on an error */ static int parse_intlist(const char *p, int *items, int maxitems) { int n = 0, v; @@ -393,59 +406,73 @@ static int parse_intlist(const char *p, int *items, int maxitems) return n; } +/* Load parsed string-values into an integer-array (intlist) + * @param str the string that contains the values (and will be parsed) + * @param array pointer to the integer-arrays that will be filled + * @param nelems the number of elements the array holds. Maximum is 64 elements + * @param type the type of elements the array holds (eg INT8, UINT16, etc.) + * @return return true on success and false on error */ static bool load_intlist(const char *str, void *array, int nelems, int type) { int items[64]; - int i,nitems; + int i, nitems; if (str == NULL) { memset(items, 0, sizeof(items)); nitems = nelems; } else { nitems = parse_intlist(str, items, lengthof(items)); - if (nitems != nelems) - return false; + if (nitems != nelems) return false; } switch (type) { - case SDT_INT8 >> 4: - case SDT_UINT8 >> 4: + case SDT_INT8: + case SDT_UINT8: for (i = 0; i != nitems; i++) ((byte*)array)[i] = items[i]; break; - case SDT_INT16 >> 4: - case SDT_UINT16 >> 4: + case SDT_INT16: + case SDT_UINT16: for (i = 0; i != nitems; i++) ((uint16*)array)[i] = items[i]; break; - case SDT_INT32 >> 4: - case SDT_UINT32 >> 4: + case SDT_INT32: + case SDT_UINT32: for (i = 0; i != nitems; i++) ((uint32*)array)[i] = items[i]; break; - default: - NOT_REACHED(); + default: NOT_REACHED(); } return true; } -static void make_intlist(char *buf, void *array, int nelems, int type) +/* Convert an integer-array (intlist) to a string representation. Each value + * is seperated by a comma + * @param buf output buffer where the string-representation will be stored + * @param array pointer to the integer-arrays that is read from + * @param nelems the number of elements the array holds. + * @param type the type of elements the array holds (eg INT8, UINT16, etc.) */ +static void make_intlist(char *buf, const void *array, int nelems, int type) { int i, v = 0; - byte *p = (byte*)array; + const byte *p = (const byte*)array; for (i = 0; i != nelems; i++) { switch (type) { - case SDT_INT8 >> 4: v = *(int8*)p; p += 1; break; - case SDT_UINT8 >> 4:v = *(byte*)p; p += 1; break; - case SDT_INT16 >> 4:v = *(int16*)p; p += 2; break; - case SDT_UINT16 >> 4:v = *(uint16*)p; p += 2; break; - case SDT_INT32 >> 4:v = *(int32*)p; p += 4; break; - case SDT_UINT32 >> 4:v = *(uint32*)p; p += 4; break; + case SDT_INT8: v = *(int8*)p; p += 1; break; + case SDT_UINT8: v = *(byte*)p; p += 1; break; + case SDT_INT16: v = *(int16*)p; p += 2; break; + case SDT_UINT16: v = *(uint16*)p; p += 2; break; + case SDT_INT32: v = *(int32*)p; p += 4; break; + case SDT_UINT32: v = *(uint32*)p; p += 4; break; default: NOT_REACHED(); } - buf += sprintf(buf, i ? ",%d" : "%d", v); + buf += sprintf(buf, (i == 0) ? "%d" : ",%d", v); } } +/* Convert a ONEofMANY structure to a string representation. + * @param buf output buffer where the string-representation will be stored + * @param many the full-domain string of possible values + * @param id the value of the variable and whose string-representation must be found */ static void make_oneofmany(char *buf, const char *many, int i) { int orig_i = i; @@ -467,6 +494,11 @@ static void make_oneofmany(char *buf, const char *many, int i) *buf = 0; } +/* Convert a MANYofMANY structure to a string representation. + * @param buf output buffer where the string-representation will be stored + * @param many the full-domain string of possible values + * @param x the value of the variable and whose string-representation must + * be found in the bitmasked many string */ static void make_manyofmany(char *buf, const char *many, uint32 x) { const char *start; @@ -491,32 +523,51 @@ static void make_manyofmany(char *buf, const char *many, uint32 x) *buf = 0; } +/* Get the GenericType of a setting. This describes the main type + * @param desc pointer to SettingDesc structure + * @return return GenericType, see SettingDescType */ +static inline int GetSettingGenericType(const SettingDesc *desc) +{ + return desc->flags & 0xFF00; // GB(desc->flags, 8, 8) << 8; +} + +/* Get the NumberType of a setting. This describes the integer type + * @param desc pointer to SettingDesc structure + * @return return NumberType, see SettingDescType */ +static inline int GetSettingNumberType(const SettingDesc *desc) +{ + return desc->flags & 0xF0; // GB(desc->flags, 4, 8); << 4 +} + +/** Convert a string representation (external) of a setting to the internal rep. + * @param desc SettingDesc struct that holds all information about the variable + * @param str input string that will be parsed based on the type of desc + * @return return the parsed value of the setting */ static const void *string_to_val(const SettingDesc *desc, const char *str) { - unsigned long val; - char *end; - - switch (desc->flags & 0xF) { - case SDT_INTX: - val = strtoul(str, &end, 0); - if (*end != 0) ShowInfoF("ini: trailing characters at end of setting '%s'", desc->name); + switch (GetSettingGenericType(desc)) { + case SDT_NUMX: { + char *end; + uint32 val = strtoul(str, &end, 0); + if (*end != '\0') ShowInfoF("ini: trailing characters at end of setting '%s'", desc->name); return (void*)val; + } case SDT_ONEOFMANY: { - long r = lookup_oneofmany((const char*)desc->b, str, -1); + long r = lookup_oneofmany(desc->many, str, -1); if (r != -1) return (void*)r; ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name); return 0; } case SDT_MANYOFMANY: { - unsigned long r = lookup_manyofmany(desc->b, str); + unsigned long r = lookup_manyofmany(desc->many, str); if (r != (unsigned long)-1) return (void*)r; ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name); return 0; } case SDT_BOOLX: - if (!strcmp(str, "true") || !strcmp(str, "on") || !strcmp(str, "1")) + if (strcmp(str, "true") == 0 || strcmp(str, "on") == 0 || strcmp(str, "1") == 0) return (void*)true; - if (!strcmp(str, "false") || !strcmp(str, "off") || !strcmp(str, "0")) + if (strcmp(str, "false") == 0 || strcmp(str, "off") == 0 || strcmp(str, "0") == 0) return (void*)false; ShowInfoF("ini: invalid setting value '%s' for '%s'", str, desc->name); break; @@ -532,17 +583,22 @@ static const void *string_to_val(const SettingDesc *desc, const char *str) return NULL; } -static void load_setting_desc(IniFile *ini, const SettingDesc *desc, const void *grpname) +/** Load values from a group of an IniFile structure into the internal representation + * @param ini pointer to IniFile structure that holds administrative information + * @param desc pointer to SettingDesc structure whose internally pointed variables will + * be given values + * @param grpname the group of the IniFile to search in for the new values */ +static void load_setting_desc(IniFile *ini, const SettingDesc *desc, const char *grpname) { IniGroup *group_def = ini_getgroup(ini, grpname, -1), *group; IniItem *item; const void *p; void *ptr; - for (;desc->name;desc++) { - // group override? + for (;desc->name != NULL; desc++) { + // XXX - wtf is this?? (group override?) const char *s = strchr(desc->name, '.'); - if (s) { + if (s != NULL) { group = ini_getgroup(ini, desc->name, s - desc->name); s++; } else { @@ -551,45 +607,37 @@ static void load_setting_desc(IniFile *ini, const SettingDesc *desc, const void } item = ini_getitem(group, s, false); - if (!item) { - p = desc->def; - } else { - p = string_to_val(desc, item->value); - } + p = (item == NULL) ? desc->def : string_to_val(desc, item->value); - // get ptr to array + /* get pointer to the variable */ ptr = desc->ptr; - switch (desc->flags & 0xF) { - // all these are stored in the same way - case SDT_INTX: + /* The main type of a variable/setting is in bytes 8-15 + * The subtype (what kind of numbers do we have there) is in 0-7 */ + switch (GetSettingGenericType(desc)) { + case SDT_BOOLX: /* All four are various types of (integer) numbers */ + case SDT_NUMX: case SDT_ONEOFMANY: case SDT_MANYOFMANY: - case SDT_BOOLX: - switch (desc->flags >> 4 & 7) { - case SDT_INT8 >> 4: - case SDT_UINT8 >> 4: - *(byte*)ptr = (byte)(unsigned long)p; - break; - case SDT_INT16 >> 4: - case SDT_UINT16 >> 4: - *(uint16*)ptr = (uint16)(unsigned long)p; - break; - case SDT_INT32 >> 4: - case SDT_UINT32 >> 4: - *(uint32*)ptr = (uint32)(unsigned long)p; - break; - default: - NOT_REACHED(); + switch (GetSettingNumberType(desc)) { + case SDT_INT8: + case SDT_UINT8: *(byte*)ptr = (byte)(unsigned long)p; break; + case SDT_INT16: + case SDT_UINT16: *(uint16*)ptr = (uint16)(unsigned long)p; break; + case SDT_INT32: + case SDT_UINT32: *(uint32*)ptr = (uint32)(unsigned long)p; break; + default: NOT_REACHED(); break; } break; - case SDT_STRING: + + case SDT_STR: free(*(char**)ptr); *(char**)ptr = strdup((const char*)p); break; - case SDT_STRINGBUF: - case SDT_STRINGQUOT: - if (p) ttd_strlcpy((char*)ptr, p, desc->flags >> 16); + + case SDT_STRB: + case SDT_STRQ: + if (p != NULL) ttd_strlcpy((char*)ptr, p, GB(desc->flags, 16, 16)); break; case SDT_CHAR: @@ -597,17 +645,24 @@ static void load_setting_desc(IniFile *ini, const SettingDesc *desc, const void break; case SDT_INTLIST: { - if (!load_intlist(p, ptr, desc->flags >> 16, desc->flags >> 4 & 7)) + if (!load_intlist(p, ptr, GB(desc->flags, 16, 16), GetSettingNumberType(desc))) ShowInfoF("ini: error in array '%s'", desc->name); break; } - default: - NOT_REACHED(); + default: NOT_REACHED(); break; } } } -static void save_setting_desc(IniFile *ini, const SettingDesc *desc, const void *grpname) +/* Save the values of settings to the inifile. + * @param ini pointer to IniFile structure + * @param desc read-only SettingDesc structure which contains the unmodified, + * loaded values of the configuration file and various information about it + * @param grpname holds the name of the group (eg. [network]) where these will be saved + * The function works as follows: for each item in the SettingDesc structure we have + * a look if the value has changed since we started the game (the original values + * are reloaded when saving). If settings indeed have changed, we get these and save them.*/ +static void save_setting_desc(IniFile *ini, const SettingDesc *desc, const char *grpname) { IniGroup *group_def = NULL, *group; IniItem *item; @@ -617,121 +672,114 @@ static void save_setting_desc(IniFile *ini, const SettingDesc *desc, const void char buf[512]; // setting buffer const char *s; - for (;desc->name;desc++) { - if (desc->flags & SDT_NOSAVE) - continue; + for (; desc->name != NULL; desc++) { + if (desc->flags & SDT_NOSAVE) continue; - // group override? + // XXX - wtf is this?? (group override?) s = strchr(desc->name, '.'); - if (s) { + if (s != NULL) { group = ini_getgroup(ini, desc->name, s - desc->name); s++; } else { - if (group_def == NULL) - group_def = ini_getgroup(ini, grpname, -1); + if (group_def == NULL) group_def = ini_getgroup(ini, grpname, -1); s = desc->name; group = group_def; } item = ini_getitem(group, s, true); - // get ptr to array + /* get pointer to the variable */ ptr = desc->ptr; if (item->value != NULL) { // check if the value is the same as the old value p = string_to_val(desc, item->value); - switch (desc->flags & 0xF) { - case SDT_INTX: + /* The main type of a variable/setting is in bytes 8-15 + * The subtype (what kind of numbers do we have there) is in 0-7 */ + switch (GetSettingGenericType(desc)) { + case SDT_BOOLX: + case SDT_NUMX: case SDT_ONEOFMANY: case SDT_MANYOFMANY: - case SDT_BOOLX: - switch (desc->flags >> 4 & 7) { - case SDT_INT8 >> 4: - case SDT_UINT8 >> 4: - if (*(byte*)ptr == (byte)(unsigned long)p) - continue; + switch (GetSettingNumberType(desc)) { + case SDT_INT8: + case SDT_UINT8: + if (*(byte*)ptr == (byte)(unsigned long)p) continue; break; - case SDT_INT16 >> 4: - case SDT_UINT16 >> 4: - if (*(uint16*)ptr == (uint16)(unsigned long)p) - continue; + case SDT_INT16: + case SDT_UINT16: + if (*(uint16*)ptr == (uint16)(unsigned long)p) continue; break; - case SDT_INT32 >> 4: - case SDT_UINT32 >> 4: - if (*(uint32*)ptr == (uint32)(unsigned long)p) - continue; + case SDT_INT32: + case SDT_UINT32: + if (*(uint32*)ptr == (uint32)(unsigned long)p) continue; break; - default: - NOT_REACHED(); + default: NOT_REACHED(); } break; - case SDT_STRING: - assert(0); - break; - case SDT_INTLIST: - // assume intlist is always changed. - break; + case SDT_STR: assert(0); break; + default: break; /* Assume the other types are always changed */ } } - switch (desc->flags & 0xF) { - case SDT_INTX: + /* Value has changed, get the new value and put it into a buffer */ + switch (GetSettingGenericType(desc)) { + case SDT_BOOLX: + case SDT_NUMX: case SDT_ONEOFMANY: case SDT_MANYOFMANY: - case SDT_BOOLX: - switch (desc->flags >> 4 & 7) { - case SDT_INT8 >> 4: i = *(int8*)ptr; break; - case SDT_UINT8 >> 4:i = *(byte*)ptr; break; - case SDT_INT16 >> 4:i = *(int16*)ptr; break; - case SDT_UINT16 >> 4:i = *(uint16*)ptr; break; - case SDT_INT32 >> 4:i = *(int32*)ptr; break; - case SDT_UINT32 >> 4:i = *(uint32*)ptr; break; - default: - NOT_REACHED(); + switch (GetSettingNumberType(desc)) { + case SDT_INT8: i = *(int8*)ptr; break; + case SDT_UINT8: i = *(byte*)ptr; break; + case SDT_INT16: i = *(int16*)ptr; break; + case SDT_UINT16: i = *(uint16*)ptr; break; + case SDT_INT32: i = *(int32*)ptr; break; + case SDT_UINT32: i = *(uint32*)ptr; break; + default: NOT_REACHED(); } - switch (desc->flags & 0xF) { - case SDT_INTX: + + switch (GetSettingGenericType(desc)) { + case SDT_BOOLX: + strcpy(buf, (i != 0) ? "true" : "false"); + break; + case SDT_NUMX: sprintf(buf, "%u", i); break; case SDT_ONEOFMANY: - make_oneofmany(buf, (const char*)desc->b, i); + make_oneofmany(buf, desc->many, i); break; case SDT_MANYOFMANY: - make_manyofmany(buf, (const char*)desc->b, i); + make_manyofmany(buf, desc->many, i); break; - case SDT_BOOLX: - strcpy(buf, i ? "true" : "false"); - break; - default: - NOT_REACHED(); + default: NOT_REACHED(); } break; - case SDT_STRINGQUOT: - sprintf(buf, "\"%s\"", (char*)ptr); - break; - case SDT_STRINGBUF: - strcpy(buf, (char*)ptr); - break; - case SDT_STRING: + + case SDT_STR: strcpy(buf, *(char**)ptr); break; - case SDT_INTLIST: - make_intlist(buf, ptr, desc->flags >> 16, desc->flags >> 4 & 7); + case SDT_STRB: + strcpy(buf, (char*)ptr); + break; + case SDT_STRQ: + sprintf(buf, "\"%s\"", (char*)ptr); break; - case SDT_CHAR: sprintf(buf, "\"%c\"", *(char*)ptr); break; + case SDT_INTLIST: + make_intlist(buf, ptr, GB(desc->flags, 16, 16), GetSettingNumberType(desc)); + break; } - // the value is different, that means we have to write it to the ini + + /* The value is different, that means we have to write it to the ini */ item->value = pool_strdup(&ini->pool, buf, strlen(buf)); } } //*************************** -// TTD specific INI stuff +// OTTD specific INI stuff //*************************** #ifndef EXTERNAL_PLAYER diff --git a/settings.h b/settings.h index 7dff53dcb4..3b588593fe 100644 --- a/settings.h +++ b/settings.h @@ -3,33 +3,46 @@ #ifndef SETTINGS_H #define SETTINGS_H +/* Convention/Type of settings. This will be merged mostly with the SaveLoad + * SLE_ enums. So it looks a bit strange. The layout is as follows: + * bits 0-7: the type (size) of the variable. Eg int8, uint8, bool, etc. Same as VarTypes + * bits 8-15: the generic variable type. Eg string, oneofmany, number, intlist + * bits 16-31: the size of a string, an intlist (which is an implicit array). */ +/* XXX - the GenericType will NOT be shifted in the final implementation, just for compatility */ enum SettingDescType { - SDT_INTX, // must be 0 - SDT_ONEOFMANY, - SDT_MANYOFMANY, - SDT_BOOLX, - SDT_STRING, - SDT_STRINGBUF, - SDT_INTLIST, - SDT_STRINGQUOT, // string with quotation marks around it - SDT_CHAR, + /* 4 bytes allocated a maximum of 16 types for GenericType */ + SDT_NUMX = 0 << 8, // value must be 0!!, refers to any number-type + SDT_BOOLX = 1 << 8, // a boolean number + SDT_ONEOFMANY = 2 << 8, // bitmasked number where only ONE bit may be set + SDT_MANYOFMANY = 3 << 8, // bitmasked number where MULTIPLE bits may be set + SDT_INTLIST = 4 << 8, // list of integers seperated by a comma ',' + SDT_STRING = 5 << 8, // string which is only a pointer, so needs dynamic allocation + SDT_STRINGBUF = 6 << 8, // string with a fixed length, preset buffer + SDT_STRINGQUOT = 7 << 8, // string with quotation marks around it (enables spaces in string) + SDT_CHAR = 8 << 8, // single character + /* 7 more possible primitives */ - SDT_INT8 = 0 << 4, - SDT_UINT8 = 1 << 4, - SDT_INT16 = 2 << 4, - SDT_UINT16 = 3 << 4, - SDT_INT32 = 4 << 4, - SDT_UINT32 = 5 << 4, - SDT_CALLBX = 6 << 4, - - SDT_UINT = SDT_UINT32, - SDT_INT = SDT_INT32, - - SDT_NOSAVE = 1 << 8, - - SDT_CALLB = SDT_INTX | SDT_CALLBX, + /* 4 bytes allocated a maximum of 16 types for NumberType */ + SDT_INT8 = 0 << 4, + SDT_UINT8 = 1 << 4, + SDT_INT16 = 2 << 4, + SDT_UINT16 = 3 << 4, + SDT_INT32 = 4 << 4, + SDT_UINT32 = 5 << 4, + SDT_INT64 = 6 << 4, + SDT_UINT64 = 7 << 4, + /* 8 more possible primitives */ + /* Shortcut values */ SDT_BOOL = SDT_BOOLX | SDT_UINT8, + SDT_UINT = SDT_UINT32, + SDT_INT = SDT_INT32, + SDT_STR = SDT_STRING, + SDT_STRB = SDT_STRINGBUF, + SDT_STRQ = SDT_STRINGQUOT, + + /* The value is read from the configuration file but not saved */ + SDT_NOSAVE = 1 << 31, }; typedef enum { @@ -42,7 +55,7 @@ typedef struct SettingDesc { int flags; const void *def; void *ptr; - const void *b; + const void *many; } SettingDesc; void IConsoleSetPatchSetting(const char *name, const char *value);