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(std::string_view name)
  24 {
  25         this->name = StrMakeValid(name);
  26 }
  27
  28 /**
  29  * Replace the current value with another value.
  30  * @param value the value to replace with.
  31  */
  32 void IniItem::SetValue(std::string_view value)
  33 {
  34         this->value.emplace(value);
  35 }
  36
  37 /**
  38  * Construct a new in-memory group of an Ini file.
  39  * @param parent the file we belong to
  40  * @param name   the name of the group
  41  */
  42 IniGroup::IniGroup(std::string_view name, IniGroupType type) : type(type), comment("\n")
  43 {
  44         this->name = StrMakeValid(name);
  45 }
  46
  47 /**
  48  * Get the item with the given name.
  49  * @param name   name of the item to find.
  50  * @return the requested item or nullptr if not found.
  51  */
  52 const IniItem *IniGroup::GetItem(std::string_view name) const
  53 {
  54         for (const IniItem &item : this->items) {
  55                 if (item.name == name) return &item;
  56         }
  57
  58         return nullptr;
  59 }
  60
  61 /**
  62  * Get the item with the given name, and if it doesn't exist create a new item.
  63  * @param name   name of the item to find.
  64  * @return the requested item.
  65  */
  66 IniItem &IniGroup::GetOrCreateItem(std::string_view name)
  67 {
  68         for (IniItem &item : this->items) {
  69                 if (item.name == name) return item;
  70         }
  71
  72         /* Item doesn't exist, make a new one. */
  73         return this->CreateItem(name);
  74 }
  75
  76 /**
  77  * Create an item with the given name. This does not reuse an existing item of the same name.
  78  * @param name name of the item to create.
  79  * @return the created item.
  80  */
  81 IniItem &IniGroup::CreateItem(std::string_view name)
  82 {
  83         return this->items.emplace_back(name);
  84 }
  85
  86 /**
  87  * Remove the item with the given name.
  88  * @param name Name of the item to remove.
  89  */
  90 void IniGroup::RemoveItem(std::string_view name)
  91 {
  92         this->items.remove_if([&name](const IniItem &item) { return item.name == name; });
  93 }
  94
  95 /**
  96  * Clear all items in the group
  97  */
  98 void IniGroup::Clear()
  99 {
 100         this->items.clear();
 101 }
 102
 103 /**
 104  * Construct a new in-memory Ini file representation.
 105  * @param list_group_names A list with group names that should be loaded as lists instead of variables. @see IGT_LIST
 106  * @param seq_group_names  A list with group names that should be loaded as lists of names. @see IGT_SEQUENCE
 107  */
 108 IniLoadFile::IniLoadFile(const IniGroupNameList &list_group_names, const IniGroupNameList &seq_group_names) :
 109                 list_group_names(list_group_names),
 110                 seq_group_names(seq_group_names)
 111 {
 112 }
 113
 114 /**
 115  * Get the group with the given name.
 116  * @param name name of the group to find.
 117  * @return The requested group or \c nullptr if not found.
 118  */
 119 const IniGroup *IniLoadFile::GetGroup(std::string_view name) const
 120 {
 121         for (const IniGroup &group : this->groups) {
 122                 if (group.name == name) return &group;
 123         }
 124
 125         return nullptr;
 126 }
 127
 128 /**
 129  * Get the group with the given name.
 130  * @param name name of the group to find.
 131  * @return The requested group or \c nullptr if not found.
 132  */
 133 IniGroup *IniLoadFile::GetGroup(std::string_view name)
 134 {
 135         for (IniGroup &group : this->groups) {
 136                 if (group.name == name) return &group;
 137         }
 138
 139         return nullptr;
 140 }
 141
 142 /**
 143  * Get the group with the given name, and if it doesn't exist create a new group.
 144  * @param name name of the group to find.
 145  * @return the requested group.
 146  */
 147 IniGroup &IniLoadFile::GetOrCreateGroup(std::string_view name)
 148 {
 149         for (IniGroup &group : this->groups) {
 150                 if (group.name == name) return group;
 151         }
 152
 153         /* Group doesn't exist, make a new one. */
 154         return this->CreateGroup(name);
 155 }
 156
 157 /**
 158  * Create an group with the given name. This does not reuse an existing group of the same name.
 159  * @param name name of the group to create.
 160  * @return the created group.
 161  */
 162 IniGroup &IniLoadFile::CreateGroup(std::string_view name)
 163 {
 164         IniGroupType type = IGT_VARIABLES;
 165         if (std::find(this->list_group_names.begin(), this->list_group_names.end(), name) != this->list_group_names.end()) type = IGT_LIST;
 166         if (std::find(this->seq_group_names.begin(), this->seq_group_names.end(), name) != this->seq_group_names.end()) type = IGT_SEQUENCE;
 167
 168         return this->groups.emplace_back(name, type);
 169 }
 170
 171 /**
 172  * Remove the group with the given name.
 173  * @param name name of the group to remove.
 174  */
 175 void IniLoadFile::RemoveGroup(std::string_view name)
 176 {
 177         size_t len = name.length();
 178         this->groups.remove_if([&name, &len](const IniGroup &group) { return group.name.compare(0, len, name) == 0; });
 179 }
 180
 181 /**
 182  * Load the Ini file's data from the disk.
 183  * @param filename the file to load.
 184  * @param subdir the sub directory to load the file from.
 185  * @pre nothing has been loaded yet.
 186  */
 187 void IniLoadFile::LoadFromDisk(const std::string &filename, Subdirectory subdir)
 188 {
 189         assert(this->groups.empty());
 190
 191         char buffer[1024];
 192         IniGroup *group = nullptr;
 193
 194         std::string comment;
 195
 196         size_t end;
 197         auto in = this->OpenFile(filename, subdir, &end);
 198         if (!in.has_value()) return;
 199
 200         end += ftell(*in);
 201
 202         /* for each line in the file */
 203         while (static_cast<size_t>(ftell(*in)) < end && fgets(buffer, sizeof(buffer), *in)) {
 204                 char c, *s;
 205                 /* trim whitespace from the left side */
 206                 for (s = buffer; *s == ' ' || *s == '\t'; s++) {}
 207
 208                 /* trim whitespace from right side. */
 209                 char *e = s + strlen(s);
 210                 while (e > s && ((c = e[-1]) == '\n' || c == '\r' || c == ' ' || c == '\t')) e--;
 211                 *e = '\0';
 212
 213                 /* Skip comments and empty lines outside IGT_SEQUENCE groups. */
 214                 if ((group == nullptr || group->type != IGT_SEQUENCE) && (*s == '#' || *s == ';' || *s == '\0')) {
 215                         comment += std::string_view(s, e - s);
 216                         comment += '\n'; // comment newline
 217                         continue;
 218                 }
 219
 220                 /* it's a group? */
 221                 if (s[0] == '[') {
 222                         if (e[-1] != ']') {
 223                                 this->ReportFileError("ini: invalid group name '", buffer, "'");
 224                         } else {
 225                                 e--;
 226                         }
 227                         s++; // skip [
 228                         group = &this->CreateGroup(std::string_view(s, e - s));
 229                         group->comment = std::move(comment);
 230                 } else if (group != nullptr) {
 231                         if (group->type == IGT_SEQUENCE) {
 232                                 /* A sequence group, use the line as item name without further interpretation. */
 233                                 IniItem &item = group->CreateItem(std::string_view(buffer, e - buffer));
 234                                 item.comment = std::move(comment);
 235                                 continue;
 236                         }
 237                         char *t;
 238                         /* find end of keyname */
 239                         if (*s == '\"') {
 240                                 s++;
 241                                 for (t = s; *t != '\0' && *t != '\"'; t++) {}
 242                                 if (*t == '\"') *t = ' ';
 243                         } else {
 244                                 for (t = s; *t != '\0' && *t != '=' && *t != '\t' && *t != ' '; t++) {}
 245                         }
 246
 247                         /* it's an item in an existing group */
 248                         IniItem &item = group->CreateItem(std::string_view(s, t - s));
 249                         item.comment = std::move(comment);
 250
 251                         /* find start of parameter */
 252                         while (*t == '=' || *t == ' ' || *t == '\t') t++;
 253
 254                         bool quoted = (*t == '\"');
 255                         /* remove starting quotation marks */
 256                         if (*t == '\"') t++;
 257                         /* remove ending quotation marks */
 258                         e = t + strlen(t);
 259                         if (e > t && e[-1] == '\"') e--;
 260                         *e = '\0';
 261
 262                         /* If the value was not quoted and empty, it must be nullptr */
 263                         if (!quoted && e == t) {
 264                                 item.value.reset();
 265                         } else {
 266                                 item.value = StrMakeValid(std::string_view(t));
 267                         }
 268                 } else {
 269                         /* it's an orphan item */
 270                         this->ReportFileError("ini: '", buffer, "' outside of group");
 271                 }
 272         }
 273
 274         this->comment = std::move(comment);
 275 }
 276