src/ini_load.cpp

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