src/ini_load.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file ini_load.cpp Definition of the #IniLoadFile class, related to reading and storing '*.ini' files. */
  11
  12 #include "stdafx.h"
  13 #include "core/alloc_func.hpp"
  14 #include "core/mem_func.hpp"
  15 #include "ini_type.h"
  16 #include "string_func.h"
  17
  18 /**
  19  * Construct a new in-memory item of an Ini file.
  20  * @param parent the group we belong to
  21  * @param name   the name of the item
  22  * @param len    the length of the name of the item
  23  */
  24 IniItem::IniItem(IniGroup *parent, const char *name, size_t len) : next(NULL), value(NULL), comment(NULL)
  25 {
  26         if (len == 0) len = strlen(name);
  27
  28         this->name = strndup(name, len);
  29         if (this->name != NULL) str_validate(this->name, this->name + len);
  30
  31         *parent->last_item = this;
  32         parent->last_item = &this->next;
  33 }
  34
  35 /** Free everything we loaded. */
  36 IniItem::~IniItem()
  37 {
  38         free(this->name);
  39         free(this->value);
  40         free(this->comment);
  41
  42         delete this->next;
  43 }
  44
  45 /**
  46  * Replace the current value with another value.
  47  * @param value the value to replace with.
  48  */
  49 void IniItem::SetValue(const char *value)
  50 {
  51         free(this->value);
  52         this->value = strdup(value);
  53 }
  54
  55 /**
  56  * Construct a new in-memory group of an Ini file.
  57  * @param parent the file we belong to
  58  * @param name   the name of the group
  59  * @param len    the length of the name of the group
  60  */
  61 IniGroup::IniGroup(IniLoadFile *parent, const char *name, size_t len) : next(NULL), type(IGT_VARIABLES), item(NULL), comment(NULL)
  62 {
  63         if (len == 0) len = strlen(name);
  64
  65         this->name = strndup(name, len);
  66         if (this->name != NULL) str_validate(this->name, this->name + len);
  67
  68         this->last_item = &this->item;
  69         *parent->last_group = this;
  70         parent->last_group = &this->next;
  71
  72         if (parent->list_group_names != NULL) {
  73                 for (uint i = 0; parent->list_group_names[i] != NULL; i++) {
  74                         if (strcmp(this->name, parent->list_group_names[i]) == 0) {
  75                                 this->type = IGT_LIST;
  76                                 return;
  77                         }
  78                 }
  79         }
  80         if (parent->seq_group_names != NULL) {
  81                 for (uint i = 0; parent->seq_group_names[i] != NULL; i++) {
  82                         if (strcmp(this->name, parent->seq_group_names[i]) == 0) {
  83                                 this->type = IGT_SEQUENCE;
  84                                 return;
  85                         }
  86                 }
  87         }
  88 }
  89
  90 /** Free everything we loaded. */
  91 IniGroup::~IniGroup()
  92 {
  93         free(this->name);
  94         free(this->comment);
  95
  96         delete this->item;
  97         delete this->next;
  98 }
  99
 100 /**
 101  * Get the item with the given name, and if it doesn't exist
 102  * and create is true it creates a new item.
 103  * @param name   name of the item to find.
 104  * @param create whether to create an item when not found or not.
 105  * @return the requested item or NULL if not found.
 106  */
 107 IniItem *IniGroup::GetItem(const char *name, bool create)
 108 {
 109         for (IniItem *item = this->item; item != NULL; item = item->next) {
 110                 if (strcmp(item->name, name) == 0) return item;
 111         }
 112
 113         if (!create) return NULL;
 114
 115         /* otherwise make a new one */
 116         return new IniItem(this, name, strlen(name));
 117 }
 118
 119 /**
 120  * Clear all items in the group
 121  */
 122 void IniGroup::Clear()
 123 {
 124         delete this->item;
 125         this->item = NULL;
 126         this->last_item = &this->item;
 127 }
 128
 129 /**
 130  * Construct a new in-memory Ini file representation.
 131  * @param list_group_names A \c NULL terminated list with group names that should be loaded as lists instead of variables. @see IGT_LIST
 132  * @param seq_group_names  A \c NULL terminated list with group names that should be loaded as lists of names. @see IGT_SEQUENCE
 133  */
 134 IniLoadFile::IniLoadFile(const char * const *list_group_names, const char * const *seq_group_names) :
 135                 group(NULL),
 136                 comment(NULL),
 137                 list_group_names(list_group_names),
 138                 seq_group_names(seq_group_names)
 139 {
 140         this->last_group = &this->group;
 141 }
 142
 143 /** Free everything we loaded. */
 144 IniLoadFile::~IniLoadFile()
 145 {
 146         free(this->comment);
 147         delete this->group;
 148 }
 149
 150 /**
 151  * Get the group with the given name. If it doesn't exist
 152  * and \a create_new is \c true create a new group.
 153  * @param name name of the group to find.
 154  * @param len  the maximum length of said name (\c 0 means length of the string).
 155  * @param create_new Allow creation of group if it does not exist.
 156  * @return The requested group if it exists or was created, else \c NULL.
 157  */
 158 IniGroup *IniLoadFile::GetGroup(const char *name, size_t len, bool create_new)
 159 {
 160         if (len == 0) len = strlen(name);
 161
 162         /* does it exist already? */
 163         for (IniGroup *group = this->group; group != NULL; group = group->next) {
 164                 if (!strncmp(group->name, name, len) && group->name[len] == 0) {
 165                         return group;
 166                 }
 167         }
 168
 169         if (!create_new) return NULL;
 170
 171         /* otherwise make a new one */
 172         IniGroup *group = new IniGroup(this, name, len);
 173         group->comment = strdup("\n");
 174         return group;
 175 }
 176
 177 /**
 178  * Remove the group with the given name.
 179  * @param name name of the group to remove.
 180  */
 181 void IniLoadFile::RemoveGroup(const char *name)
 182 {
 183         size_t len = strlen(name);
 184         IniGroup *prev = NULL;
 185         IniGroup *group;
 186
 187         /* does it exist already? */
 188         for (group = this->group; group != NULL; prev = group, group = group->next) {
 189                 if (strncmp(group->name, name, len) == 0) {
 190                         break;
 191                 }
 192         }
 193
 194         if (group == NULL) return;
 195
 196         if (prev != NULL) {
 197                 prev->next = prev->next->next;
 198                 if (this->last_group == &group->next) this->last_group = &prev->next;
 199         } else {
 200                 this->group = this->group->next;
 201                 if (this->last_group == &group->next) this->last_group = &this->group;
 202         }
 203
 204         group->next = NULL;
 205         delete group;
 206 }
 207
 208 /**
 209  * Load the Ini file's data from the disk.
 210  * @param filename the file to load.
 211  * @param subdir the sub directory to load the file from.
 212  * @pre nothing has been loaded yet.
 213  */
 214 void IniLoadFile::LoadFromDisk(const char *filename, Subdirectory subdir)
 215 {
 216         assert(this->last_group == &this->group);
 217
 218         char buffer[1024];
 219         IniGroup *group = NULL;
 220
 221         char *comment = NULL;
 222         uint comment_size = 0;
 223         uint comment_alloc = 0;
 224
 225         size_t end;
 226         FILE *in = this->OpenFile(filename, subdir, &end);
 227         if (in == NULL) return;
 228
 229         end += ftell(in);
 230
 231         /* for each line in the file */
 232         while ((size_t)ftell(in) < end && fgets(buffer, sizeof(buffer), in)) {
 233                 char c, *s;
 234                 /* trim whitespace from the left side */
 235                 for (s = buffer; *s == ' ' || *s == '\t'; s++) {}
 236
 237                 /* trim whitespace from right side. */
 238                 char *e = s + strlen(s);
 239                 while (e > s && ((c = e[-1]) == '\n' || c == '\r' || c == ' ' || c == '\t')) e--;
 240                 *e = '\0';
 241
 242                 /* Skip comments and empty lines outside IGT_SEQUENCE groups. */
 243                 if ((group == NULL || group->type != IGT_SEQUENCE) && (*s == '#' || *s == ';' || *s == '\0')) {
 244                         uint ns = comment_size + (e - s + 1);
 245                         uint a = comment_alloc;
 246                         /* add to comment */
 247                         if (ns > a) {
 248                                 a = max(a, 128U);
 249                                 do a *= 2; while (a < ns);
 250                                 comment = ReallocT(comment, comment_alloc = a);
 251                         }
 252                         uint pos = comment_size;
 253                         comment_size += (e - s + 1);
 254                         comment[pos + e - s] = '\n'; // comment newline
 255                         memcpy(comment + pos, s, e - s); // copy comment contents
 256                         continue;
 257                 }
 258
 259                 /* it's a group? */
 260                 if (s[0] == '[') {
 261                         if (e[-1] != ']') {
 262                                 this->ReportFileError("ini: invalid group name '", buffer, "'");
 263                         } else {
 264                                 e--;
 265                         }
 266                         s++; // skip [
 267                         group = new IniGroup(this, s, e - s);
 268                         if (comment_size != 0) {
 269                                 group->comment = strndup(comment, comment_size);
 270                                 comment_size = 0;
 271                         }
 272                 } else if (group != NULL) {
 273                         if (group->type == IGT_SEQUENCE) {
 274                                 /* A sequence group, use the line as item name without further interpretation. */
 275                                 IniItem *item = new IniItem(group, buffer, e - buffer);
 276                                 if (comment_size) {
 277                                         item->comment = strndup(comment, comment_size);
 278                                         comment_size = 0;
 279                                 }
 280                                 continue;
 281                         }
 282                         char *t;
 283                         /* find end of keyname */
 284                         if (*s == '\"') {
 285                                 s++;
 286                                 for (t = s; *t != '\0' && *t != '\"'; t++) {}
 287                                 if (*t == '\"') *t = ' ';
 288                         } else {
 289                                 for (t = s; *t != '\0' && *t != '=' && *t != '\t' && *t != ' '; t++) {}
 290                         }
 291
 292                         /* it's an item in an existing group */
 293                         IniItem *item = new IniItem(group, s, t - s);
 294                         if (comment_size != 0) {
 295                                 item->comment = strndup(comment, comment_size);
 296                                 comment_size = 0;
 297                         }
 298
 299                         /* find start of parameter */
 300                         while (*t == '=' || *t == ' ' || *t == '\t') t++;
 301
 302                         bool quoted = (*t == '\"');
 303                         /* remove starting quotation marks */
 304                         if (*t == '\"') t++;
 305                         /* remove ending quotation marks */
 306                         e = t + strlen(t);
 307                         if (e > t && e[-1] == '\"') e--;
 308                         *e = '\0';
 309
 310                         /* If the value was not quoted and empty, it must be NULL */
 311                         item->value = (!quoted && e == t) ? NULL : strndup(t, e - t);
 312                         if (item->value != NULL) str_validate(item->value, item->value + strlen(item->value));
 313                 } else {
 314                         /* it's an orphan item */
 315                         this->ReportFileError("ini: '", buffer, "' outside of group");
 316                 }
 317         }
 318
 319         if (comment_size > 0) {
 320                 this->comment = strndup(comment, comment_size);
 321                 comment_size = 0;
 322         }
 323
 324         free(comment);
 325         fclose(in);
 326 }
 327