src/XMLParser.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // NOTES:
  20
  21 // This is the implementation for XMLParser
  22
  23 #include <iostream>
  24
  25 #include "XMLParser.h"
  26
  27 using namespace fragrant;
  28
  29 XMLParser* XMLParser::getXMLParser()
  30 {
  31   if (pointer)
  32     return pointer;
  33
  34   XMLParser* parser = new XMLParser();
  35
  36   if (!was_made)
  37     {
  38       delete parser;
  39       parser = 0;
  40       std::cerr << "XMLParser::getXMLParser(): Error making XMLParser"
  41                 << std::endl;
  42     }
  43
  44   was_made = false;
  45
  46   pointer = parser;
  47   return pointer;
  48 }
  49
  50 XMLParser::~XMLParser()
  51 {
  52   pointer = 0;
  53   xmlFreeParserCtxt(context_pointer);
  54   xmlCleanupParser();
  55 }
  56
  57 bool XMLParser::validateXMLData(xmlDocPtr document, std::string schema)
  58 {
  59   bool results;
  60
  61   xmlDocPtr relax_doc = 0;
  62
  63   xmlRelaxNGParserCtxtPtr relax_context = 0;
  64   xmlRelaxNGPtr relax_pointer = 0;
  65   xmlRelaxNGValidCtxtPtr relax_valid = 0;
  66
  67   std::string filename = relaxng_root + schema;
  68
  69   relax_doc = xmlCtxtReadFile(context_pointer,
  70     filename.c_str(), 0, XML_PARSE_RECOVER);
  71
  72   results = static_cast<bool>(relax_doc);
  73
  74   if (results)
  75     {
  76       relax_context = xmlRelaxNGNewDocParserCtxt(relax_doc);
  77       results = static_cast<bool>(relax_context);
  78     }
  79
  80   if (results)
  81     {
  82       relax_pointer = xmlRelaxNGParse(relax_context);
  83       results = static_cast<bool>(relax_pointer);
  84     }
  85
  86   if (results)
  87     {
  88       relax_valid = xmlRelaxNGNewValidCtxt(relax_pointer);
  89       results = static_cast<bool>(relax_valid);
  90     }
  91
  92   if (results)
  93     results = !xmlRelaxNGValidateDoc(relax_valid, document);
  94
  95   // clean up
  96
  97   if (relax_doc)
  98     xmlFreeDoc(relax_doc);
  99
 100   if (relax_context)
 101     xmlRelaxNGFreeParserCtxt(relax_context);
 102
 103   if (relax_pointer)
 104     xmlRelaxNGFree(relax_pointer);
 105
 106   if (relax_valid)
 107     xmlRelaxNGFreeValidCtxt(relax_valid);
 108
 109   return results;
 110 }
 111
 112 XMLS_Results XMLParser::parseSprite(std::string input)
 113 {
 114   // defs
 115
 116   XMLS_Results results;
 117
 118   xmlDocPtr document = 0;
 119
 120   results.error = false;
 121
 122   document = xmlCtxtReadMemory(context_pointer,
 123     input.c_str(), input.size(), 0, 0, XML_PARSE_RECOVER);
 124   results.error = !document;
 125
 126   if (!results.error)
 127     results.error = !validateXMLData(document, XMLS_RELAXNG);
 128
 129   // parse
 130
 131   xmlNode* root_node = xmlDocGetRootElement(document);
 132
 133   if (!results.error)
 134     {
 135       printDebugNode((xmlNode*)root_node);
 136
 137       xmlNode* cur_node = root_node->children;
 138       for (cur_node; cur_node; cur_node = cur_node->next)
 139         if (cur_node->type == XML_ELEMENT_NODE)
 140           {
 141             if (std::string((char*)(cur_node->name)) == XMLS_SOURCE)
 142               {
 143                 XMLS_Source source = parseSpriteSource(cur_node);
 144                 results.sources.push_back(source);
 145               }
 146             if (std::string((char*)cur_node->name) == XMLS_SECTION)
 147               {
 148                 XMLS_Section section = parseSpriteSection(cur_node);
 149                 results.sections.push_back(section);
 150               }
 151             if (std::string((char*)cur_node->name) == XMLS_SPRITE)
 152               {
 153                 XMLS_Sprite sprite = parseSpriteSprite(cur_node);
 154                 results.sprites.push_back(sprite);
 155               }
 156           }
 157     }
 158
 159   // clean up
 160
 161   if (document)
 162     xmlFreeDoc(document);
 163
 164   return results;
 165 }
 166
 167 void XMLParser::setRELAXNGRoot(std::string new_root)
 168 {
 169   relaxng_root = new_root;
 170   return;
 171 }
 172
 173 XMLS_Section XMLParser::parseSpriteSection(xmlNode *top)
 174 {
 175   XMLS_Section results;
 176   results.error = true;
 177
 178   if (std::string((char*)top->name) != XMLS_SECTION)
 179     return results;
 180   else
 181     results.error = false;
 182
 183   xmlNode* cur = 0;
 184   for (cur = top->children; cur; cur = cur->next)
 185     if (cur->type == XML_ELEMENT_NODE)
 186       {
 187         if (std::string((char*)cur->name) == XMLS_X)
 188           results.x = strtol((char*)cur->children->content, 0, 10);
 189
 190         if (std::string((char*)cur->name) == XMLS_Y)
 191           results.y = strtol((char*)cur->children->content, 0, 10);
 192
 193         if (std::string((char*)cur->name) == XMLS_WIDTH)
 194           results.width = strtol((char*)cur->children->content, 0, 10);
 195
 196         if (std::string((char*)cur->name) == XMLS_HEIGHT)
 197           results.height = strtol((char*)cur->children->content, 0, 10);
 198
 199         if (std::string((char*)cur->name) == XMLS_SOURCE)
 200           results.source = std::string((char*)cur->children->content);
 201
 202         if (std::string((char*)cur->name) == XMLS_NAME)
 203           results.name = std::string((char*)cur->children->content);
 204       }
 205
 206   return results;
 207 }
 208
 209 XMLS_Source XMLParser::parseSpriteSource(xmlNode *top)
 210 {
 211   XMLS_Source results;
 212   results.error = true;
 213
 214   if (std::string((char*)top->name) != XMLS_SOURCE)
 215     return results;
 216   else
 217     results.error = false;
 218
 219   xmlNode* cur;
 220   for (cur = top->children; cur; cur = cur->next)
 221     if (cur->type == XML_ELEMENT_NODE)
 222       {
 223         if (std::string((char*)cur->name) == XMLS_FILENAME)
 224           results.filename = std::string((char*)cur->children->content);
 225
 226         if (std::string((char*)cur->name) == XMLS_NAME)
 227           results.name = std::string((char*)cur->children->content);
 228       }
 229
 230   return results;
 231 }
 232
 233 XMLS_Sprite XMLParser::parseSpriteSprite(xmlNode *top)
 234 {
 235   XMLS_Sprite results;
 236   results.error = true;
 237
 238   if (std::string((char*)top->name) != XMLS_SPRITE)
 239     return results;
 240   else
 241     results.error = false;
 242
 243   xmlNode* cur;
 244   for (cur = top->children; cur; cur = cur->next)
 245     if (cur->type == XML_ELEMENT_NODE)
 246       {
 247         if (std::string((char*)cur->name) == XMLS_NAME)
 248           results.name = std::string((char*)cur->children->content);
 249
 250         if (std::string((char*)cur->name) == XMLS_ITEMS)
 251           results.items = parseSpriteItems(cur);
 252
 253         if (std::string((char*)cur->name) == XMLS_SEQUENCE)
 254           results.frames = parseSpriteFrames(cur);
 255       }
 256
 257   return results;
 258 }
 259
 260 std::vector<std::string> XMLParser::parseSpriteItems(xmlNode* top)
 261 {
 262   std::vector<std::string> results;
 263
 264   if (std::string((char*)top->name) != XMLS_ITEMS)
 265     return results;
 266
 267   xmlNode* cur;
 268   for (cur = top->children; cur; cur = cur->next)
 269     if (cur->type == XML_ELEMENT_NODE)
 270       {
 271         results.push_back(std::string((char*)cur->children->content));
 272       }
 273
 274   return results;
 275 }
 276
 277 std::vector<Frame> XMLParser::parseSpriteFrames(xmlNode* top)
 278 {
 279   std::vector<Frame> results;
 280
 281   if (std::string((char*)top->name) != XMLS_SEQUENCE)
 282     return results;
 283
 284   xmlNode* cur;
 285   for (cur = top->children; cur; cur = cur->next)
 286     if (cur->type == XML_ELEMENT_NODE)
 287       {
 288         xmlNode* frame_cur;
 289         Frame temp;
 290         for (frame_cur = cur->children; frame_cur; frame_cur = frame_cur->next)
 291           if (frame_cur->type = XML_ELEMENT_NODE)
 292             {
 293               if (std::string((char*)frame_cur->name) == XMLS_ITEM)
 294                 temp.frame = strtol((char*)frame_cur->children->content, 0, 10);
 295
 296               if (std::string((char*)frame_cur->name) == XMLS_DURATION)
 297                 temp.duration = strtol((char*)
 298                   frame_cur->children->content, 0, 10);
 299             }
 300
 301         results.push_back(temp);
 302       }
 303
 304   return results;
 305 }
 306
 307 XMLParser::XMLParser()
 308 {
 309   LIBXML_TEST_VERSION
 310
 311   was_made = true;
 312
 313   context_pointer = 0;
 314   context_pointer = xmlNewParserCtxt();
 315
 316   if (!context_pointer)
 317     was_made = false;
 318 }
 319
 320 bool XMLParser::was_made = false;
 321 XMLParser* XMLParser::pointer = 0;
 322
 323 void fragrant::printDebugNode(xmlNode* top)
 324 {
 325   xmlNode* cur_node = 0;
 326   for (cur_node = top; cur_node; cur_node = cur_node->next)
 327     {
 328       if (cur_node->type == XML_ELEMENT_NODE)
 329         {
 330           std::cout << "node type: Element, name: " << cur_node->name
 331                     << std::endl;
 332
 333           if (std::string((char*)cur_node->name) == "item")
 334             std::cout << "THE NODE item is " << cur_node->children->content << std::endl;
 335         }
 336
 337       if (cur_node->type == XML_TEXT_NODE)
 338         {
 339           std::cout << "node type: Text, value: " << cur_node->content
 340                     << std::endl;
 341         }
 342
 343       fragrant::printDebugNode(static_cast<xmlNode*>(cur_node->children));
 344     }
 345
 346   return;
 347 }
 348