common/xmlparser.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  *
  24  */
  25
  26 #include "common/xmlparser.h"
  27 #include "common/util.h"
  28 #include "common/archive.h"
  29 #include "common/fs.h"
  30
  31 namespace Common {
  32
  33 bool XMLParser::loadFile(const Common::String &filename) {
  34         _stream = SearchMan.createReadStreamForMember(filename);
  35         if (!_stream)
  36                 return false;
  37
  38         _fileName = filename;
  39         return true;
  40 }
  41
  42 bool XMLParser::loadFile(const FSNode &node) {
  43         _stream = node.createReadStream();
  44         if (!_stream)
  45                 return false;
  46
  47         _fileName = node.getName();
  48         return true;
  49 }
  50
  51 bool XMLParser::loadBuffer(const byte *buffer, uint32 size, bool disposable) {
  52         _stream = new MemoryReadStream(buffer, size, disposable);
  53         _fileName = "Memory Stream";
  54         return true;
  55 }
  56
  57 bool XMLParser::loadStream(Common::SeekableReadStream *stream) {
  58         _stream = stream;
  59         _fileName = "File Stream";
  60         return true;
  61 }
  62
  63 void XMLParser::close() {
  64         delete _stream;
  65         _stream = 0;
  66 }
  67
  68 bool XMLParser::parserError(const char *errorString, ...) {
  69         _state = kParserError;
  70
  71         const int startPosition = _stream->pos();
  72         int currentPosition = startPosition;
  73         int lineCount = 1;
  74         char c = 0;
  75
  76         _stream->seek(0, SEEK_SET);
  77
  78         while (currentPosition--) {
  79                 c = _stream->readByte();
  80
  81                 if (c == '\n' || c == '\r')
  82                         lineCount++;
  83         }
  84
  85         assert(_stream->pos() == startPosition);
  86         currentPosition = startPosition;
  87
  88         int keyOpening = 0;
  89         int keyClosing = 0;
  90
  91         while (currentPosition-- && keyOpening == 0) {
  92                 _stream->seek(-2, SEEK_CUR);
  93                 c = _stream->readByte();
  94
  95                 if (c == '<')
  96                         keyOpening = currentPosition - 1;
  97                 else if (c == '>')
  98                         keyClosing = currentPosition;
  99         }
 100
 101         _stream->seek(startPosition, SEEK_SET);
 102         currentPosition = startPosition;
 103         while (keyClosing == 0 && c && currentPosition++) {
 104                 c = _stream->readByte();
 105
 106                 if (c == '>')
 107                         keyClosing = currentPosition;
 108         }
 109
 110         fprintf(stderr, "\n  File <%s>, line %d:\n", _fileName.c_str(), lineCount);
 111
 112         currentPosition = (keyClosing - keyOpening);
 113         _stream->seek(keyOpening, SEEK_SET);
 114
 115         while (currentPosition--)
 116                 fprintf(stderr, "%c", _stream->readByte());
 117
 118         fprintf(stderr, "\n\nParser error: ");
 119
 120         va_list args;
 121         va_start(args, errorString);
 122         vfprintf(stderr, errorString, args);
 123         va_end(args);
 124
 125         fprintf(stderr, "\n\n");
 126
 127         return false;
 128 }
 129
 130 bool XMLParser::parseXMLHeader(ParserNode *node) {
 131         assert(node->header);
 132
 133         if (_activeKey.size() != 1)
 134                 return parserError("XML Header is expected in the global scope.");
 135
 136         if (!node->values.contains("version"))
 137                 return parserError("Missing XML version in XML header.");
 138
 139         if (node->values["version"] != "1.0")
 140                 return parserError("Unsupported XML version.");
 141
 142         return true;
 143 }
 144
 145 bool XMLParser::parseActiveKey(bool closed) {
 146         bool ignore = false;
 147         assert(_activeKey.empty() == false);
 148
 149         ParserNode *key = _activeKey.top();
 150
 151         if (key->name == "xml" && key->header == true) {
 152                 assert(closed);
 153                 return parseXMLHeader(key) && closeKey();
 154         }
 155
 156         XMLKeyLayout *layout = (_activeKey.size() == 1) ? _XMLkeys : getParentNode(key)->layout;
 157
 158         if (layout->children.contains(key->name)) {
 159                 key->layout = layout->children[key->name];
 160
 161                 Common::StringMap localMap = key->values;
 162                 int keyCount = localMap.size();
 163
 164                 for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator i = key->layout->properties.begin(); i != key->layout->properties.end(); ++i) {
 165                         if (i->required && !localMap.contains(i->name))
 166                                 return parserError("Missing required property '%s' inside key '%s'", i->name.c_str(), key->name.c_str());
 167                         else if (localMap.contains(i->name))
 168                                 keyCount--;
 169                 }
 170
 171                 if (keyCount > 0)
 172                         return parserError("Unhandled property inside key '%s'.", key->name.c_str());
 173
 174         } else {
 175                 return parserError("Unexpected key in the active scope ('%s').", key->name.c_str());
 176         }
 177
 178         // check if any of the parents must be ignored.
 179         // if a parent is ignored, all children are too.
 180         for (int i = _activeKey.size() - 1; i >= 0; --i) {
 181                 if (_activeKey[i]->ignore)
 182                         ignore = true;
 183         }
 184
 185         if (ignore == false && keyCallback(key) == false) {
 186                 // HACK:  People may be stupid and overlook the fact that
 187                 // when keyCallback() fails, a parserError() must be set.
 188                 // We set it manually in that case.
 189                 if (_state != kParserError)
 190                         parserError("Unhandled exception when parsing '%s' key.", key->name.c_str());
 191
 192                 return false;
 193         }
 194
 195         if (closed)
 196                 return closeKey();
 197
 198         return true;
 199 }
 200
 201 bool XMLParser::parseKeyValue(Common::String keyName) {
 202         assert(_activeKey.empty() == false);
 203
 204         if (_activeKey.top()->values.contains(keyName))
 205                 return false;
 206
 207         _token.clear();
 208         char stringStart;
 209
 210         if (_char == '"' || _char == '\'') {
 211                 stringStart = _char;
 212                 _char = _stream->readByte();
 213
 214                 while (_char && _char != stringStart) {
 215                         _token += _char;
 216                         _char = _stream->readByte();
 217                 }
 218
 219                 if (_char == 0)
 220                         return false;
 221
 222                 _char = _stream->readByte();
 223
 224         } else if (!parseToken()) {
 225                 return false;
 226         }
 227
 228         _activeKey.top()->values[keyName] = _token;
 229         return true;
 230 }
 231
 232 bool XMLParser::closeKey() {
 233         bool ignore = false;
 234         bool result = true;
 235
 236         for (int i = _activeKey.size() - 1; i >= 0; --i) {
 237                 if (_activeKey[i]->ignore)
 238                         ignore = true;
 239         }
 240
 241         if (ignore == false)
 242                 result = closedKeyCallback(_activeKey.top());
 243
 244         freeNode(_activeKey.pop());
 245
 246         return result;
 247 }
 248
 249 bool XMLParser::parse() {
 250
 251         if (_stream == 0)
 252                 return parserError("XML stream not ready for reading.");
 253
 254         if (_XMLkeys == 0)
 255                 buildLayout();
 256
 257         while (!_activeKey.empty())
 258                 freeNode(_activeKey.pop());
 259
 260         cleanup();
 261
 262         bool activeClosure = false;
 263         bool activeHeader = false;
 264         bool selfClosure;
 265
 266         _state = kParserNeedHeader;
 267         _activeKey.clear();
 268
 269         _char = _stream->readByte();
 270
 271         while (_char && _state != kParserError) {
 272                 if (skipSpaces())
 273                         continue;
 274
 275                 if (skipComments())
 276                         continue;
 277
 278                 switch (_state) {
 279                 case kParserNeedHeader:
 280                 case kParserNeedKey:
 281                         if (_char != '<') {
 282                                 parserError("Parser expecting key start.");
 283                                 break;
 284                         }
 285
 286                         if ((_char = _stream->readByte()) == 0) {
 287                                 parserError("Unexpected end of file.");
 288                                 break;
 289                         }
 290
 291                         if (_state == kParserNeedHeader) {
 292                                 if (_char != '?') {
 293                                         parserError("Expecting XML header.");
 294                                         break;
 295                                 }
 296
 297                                 _char = _stream->readByte();
 298                                 activeHeader = true;
 299                         } else if (_char == '/') {
 300                                 _char = _stream->readByte();
 301                                 activeClosure = true;
 302                         } else if (_char == '?') {
 303                                 parserError("Unexpected header. There may only be one XML header per file.");
 304                                 break;
 305                         }
 306
 307                         _state = kParserNeedKeyName;
 308                         break;
 309
 310                 case kParserNeedKeyName:
 311                         if (!parseToken()) {
 312                                 parserError("Invalid key name.");
 313                                 break;
 314                         }
 315
 316                         if (activeClosure) {
 317                                 if (_activeKey.empty() || _token != _activeKey.top()->name) {
 318                                         parserError("Unexpected closure.");
 319                                         break;
 320                                 }
 321                         } else {
 322                                 ParserNode *node = allocNode(); //new ParserNode;
 323                                 node->name = _token;
 324                                 node->ignore = false;
 325                                 node->header = activeHeader;
 326                                 node->depth = _activeKey.size();
 327                                 node->layout = 0;
 328                                 _activeKey.push(node);
 329                         }
 330
 331                         _state = kParserNeedPropertyName;
 332                         break;
 333
 334                 case kParserNeedPropertyName:
 335                         if (activeClosure) {
 336                                 if (!closeKey()) {
 337                                         parserError("Missing data when closing key '%s'.", _activeKey.top()->name.c_str());
 338                                         break;
 339                                 }
 340
 341                                 activeClosure = false;
 342
 343                                 if (_char != '>')
 344                                         parserError("Invalid syntax in key closure.");
 345                                 else
 346                                         _state = kParserNeedKey;
 347
 348                                 _char = _stream->readByte();
 349                                 break;
 350                         }
 351
 352                         selfClosure = false;
 353
 354                         if (_char == '/' || (_char == '?' && activeHeader)) {
 355                                 selfClosure = true;
 356                                 _char = _stream->readByte();
 357                         }
 358
 359                         if (_char == '>') {
 360                                 if (activeHeader && !selfClosure) {
 361                                         parserError("XML Header must be self-closed.");
 362                                 } else if (parseActiveKey(selfClosure)) {
 363                                         _char = _stream->readByte();
 364                                         _state = kParserNeedKey;
 365                                 }
 366
 367                                 activeHeader = false;
 368                                 break;
 369                         }
 370
 371                         if (selfClosure)
 372                                 parserError("Expecting key closure after '/' symbol.");
 373                         else if (!parseToken())
 374                                 parserError("Error when parsing key value.");
 375                         else
 376                                 _state = kParserNeedPropertyOperator;
 377
 378                         break;
 379
 380                 case kParserNeedPropertyOperator:
 381                         if (_char != '=')
 382                                 parserError("Syntax error after key name.");
 383                         else
 384                                 _state = kParserNeedPropertyValue;
 385
 386                         _char = _stream->readByte();
 387                         break;
 388
 389                 case kParserNeedPropertyValue:
 390                         if (!parseKeyValue(_token))
 391                                 parserError("Invalid key value.");
 392                         else
 393                                 _state = kParserNeedPropertyName;
 394
 395                         break;
 396
 397                 default:
 398                         break;
 399                 }
 400         }
 401
 402         if (_state == kParserError)
 403                 return false;
 404
 405         if (_state != kParserNeedKey || !_activeKey.empty())
 406                 return parserError("Unexpected end of file.");
 407
 408         return true;
 409 }
 410
 411 }
 412