FryingPan/framework/Generic/XMLDocument.cpp

   1 /*
   2  * Amiga Generic Set - set of libraries and includes to ease sw development for all Amiga platforms
   3  * Copyright (C) 2001-2011 Tomasz Wiszkowski Tomasz.Wiszkowski at gmail.com.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #include "XMLDocument.h"
  21
  22 #include <libclass/expat.h>
  23 #include <libdata/expat.h>
  24 #include <libclass/dos.h>
  25 #include <dos/dos.h>
  26 #include <LibC/LibC.h>
  27
  28 using namespace GenNS;
  29
  30 XMLAttribute::XMLAttribute()
  31 {
  32    Initialize("", "");
  33 }
  34
  35 XMLAttribute::XMLAttribute(const char* sName, const char* sValue)
  36 {
  37    Initialize(sName, sValue);
  38 }
  39
  40 XMLAttribute::XMLAttribute(const char* sName, int64 sValue)
  41 {
  42    Initialize(sName, sValue);
  43 }
  44
  45 XMLAttribute::~XMLAttribute()
  46 {
  47 }
  48
  49 void XMLAttribute::Initialize(const char* sN, const char* sV)
  50 {
  51    sName = sN;
  52    sValue = sV;
  53 };
  54
  55 void XMLAttribute::Initialize(const char* sN, int64 sV)
  56 {
  57    sName = sN;
  58    sValue = sV;
  59 };
  60
  61 String &XMLAttribute::GetName()
  62 {
  63    return sName;
  64 }
  65
  66 String &XMLAttribute::GetValue()
  67 {
  68    return sValue;
  69 }
  70
  71 void XMLAttribute::SetName(const char* sName)
  72 {
  73    this->sName = sName;
  74 }
  75
  76 void XMLAttribute::SetValue(const char* sValue)
  77 {
  78    this->sValue = sValue;
  79 }
  80
  81 void XMLAttribute::SetValue(uint64 sValue)
  82 {
  83    this->sValue = sValue;
  84 }
  85
  86
  87 XMLElement::XMLElement()
  88 {
  89    Initialize("", "");
  90 }
  91
  92 XMLElement::XMLElement(const char* sName, const char* sValue)
  93 {
  94    Initialize(sName, sValue);
  95 }
  96
  97 XMLElement::~XMLElement()
  98 {
  99    hAttributes.ForEach(&XMLElement::freeAttr);
 100    hChildren.ForEach(&XMLElement::freeNode);
 101 }
 102
 103 bool XMLElement::freeAttr(XMLAttribute* const& attr)
 104 {
 105    delete attr;
 106    return true;
 107 }
 108
 109 bool XMLElement::freeNode(XMLElement* const& node)
 110 {
 111    delete node;
 112    return true;
 113 }
 114
 115 void XMLElement::Initialize(const char* sN, const char* sV)
 116 {
 117    XMLAttribute::Initialize(sN, sV);
 118    hChildren.Empty();   // ensure its empty
 119    hAttributes.Empty(); // !!
 120 }
 121
 122 long XMLElement::GetChildrenCount()
 123 {
 124    return hChildren.Count();
 125 }
 126
 127 XMLElement *XMLElement::GetChild(long i)
 128 {
 129    return hChildren[i];
 130 }
 131
 132 long XMLElement::GetAttributesCount()
 133 {
 134    return hAttributes.Count();
 135 }
 136
 137 XMLAttribute *XMLElement::GetAttribute(long i)
 138 {
 139    return hAttributes[i];
 140 }
 141
 142 XMLElement *XMLElement::AddChild(const char* sName, const char* sValue)
 143 {
 144    XMLElement *pNew = new XMLElement(sName, sValue);
 145    hChildren << pNew;
 146    return pNew;
 147 }
 148
 149 XMLAttribute  *XMLElement::AddAttribute(const char* sName, const char* sValue)
 150 {
 151    XMLAttribute *pNew = new XMLAttribute(sName, sValue);
 152    hAttributes << pNew;
 153    return pNew;
 154 }
 155
 156 XMLAttribute *XMLElement::AddAttribute(const char* sNm, int64 lVal)
 157 {
 158    XMLAttribute *pNew = new XMLAttribute(sNm, lVal);
 159    hAttributes << pNew;
 160    return pNew;
 161 }
 162
 163 XMLElement *XMLElement::AddChild(XMLElement* pElem)
 164 {
 165    hChildren << pElem;
 166    return pElem;
 167 }
 168
 169 XMLAttribute *XMLElement::AddAttribute(XMLAttribute *pAttr)
 170 {
 171    hAttributes << pAttr;
 172    return pAttr;
 173 }
 174
 175 void XMLElement::RemChild(XMLElement* pElem)
 176 {
 177    hChildren >> pElem;
 178 }
 179
 180 void XMLElement::RemAttribute(XMLAttribute* pAttr)
 181 {
 182    hAttributes >> pAttr;
 183 }
 184
 185 XMLElement *XMLElement::FindChild(const char* sName)
 186 {
 187    for (int i=0; i<hChildren.Count(); i++)
 188    {
 189       if (hChildren[i]->GetName().Equals(sName))
 190          return hChildren[i];
 191    }
 192    return 0;
 193 }
 194
 195 XMLAttribute *XMLElement::FindAttribute(const char* sName)
 196 {
 197    for (int i=0; i<hAttributes.Count(); i++)
 198    {
 199       if (hAttributes[i]->GetName().Equals(sName))
 200          return hAttributes[i];
 201    }
 202    return 0;
 203 }
 204
 205 String *XMLElement::GetChildValue(const char *sName)
 206 {
 207    XMLElement *pElem = FindChild(sName);
 208    if (0 == pElem)
 209       return 0;
 210    return &pElem->GetValue();
 211 }
 212
 213 String *XMLElement::GetAttributeValue(const char *sName)
 214 {
 215    XMLAttribute *pAttr = FindAttribute(sName);
 216    if (0 == pAttr)
 217       return 0;
 218    return &pAttr->GetValue();
 219 }
 220
 221
 222
 223 XMLDocument::XMLDocument()
 224 {
 225    pParser     = 0;
 226    eError      = XErr_OK;
 227    sFileName   = "";
 228    pExpat      = Expat2IFace::GetInstance(0);
 229 }
 230
 231 XMLDocument::XMLDocument(const char *sName)
 232    : XMLElement(sName, "")
 233 {
 234    pParser     = 0;
 235    eError      = XErr_OK;
 236    sFileName   = "";
 237    pExpat      = Expat2IFace::GetInstance(0);
 238 }
 239
 240 XMLDocument::~XMLDocument()
 241 {
 242    if (pExpat)
 243    {
 244       if (pParser)
 245          pExpat->XML_ParserFree(pParser);
 246       pExpat->FreeInstance();
 247    }
 248 }
 249
 250 void XMLDocument::fXMLStartHandler(void* userData, const XML_Char *name, const XML_Char **atts)
 251 {
 252    ((XMLDocument*)userData)->XMLStartHandler(name, atts);
 253 }
 254
 255 void XMLDocument::fXMLEndHandler(void* userData, const XML_Char *name)
 256 {
 257    ((XMLDocument*)userData)->XMLEndHandler(name);
 258 }
 259
 260 void XMLDocument::fXMLContentHandler(void* userData, const XML_Char *begin, int length)
 261 {
 262    ((XMLDocument*)userData)->XMLContentHandler(begin, length);
 263 }
 264
 265 void XMLDocument::XMLStartHandler(const XML_Char *name, const XML_Char **atts)
 266 {
 267    XMLElement *pLast;
 268
 269 //   MessageBox("Info", "On Start: %s", "Ok", ARRAY((int)name));
 270
 271    level = hParse.Count();
 272
 273    if (0 != level)
 274    {
 275       pLast = hParse[level-1]->AddChild((char*)name, "");
 276    }
 277    else
 278    {
 279       pLast = this;
 280       Initialize((char*)name, "");     // implies: free(!)
 281    }
 282
 283    for (int i=0; 0 != atts[i]; i+=2)
 284    {
 285       String s((char*)(atts[i+1]));
 286       pLast->AddAttribute((char*)atts[i], s.FromUTF8().Data());
 287    }
 288
 289    hParse << pLast;
 290
 291 //   MessageBox("Info", "Done Start: %s", "Ok", ARRAY((int)name));
 292 }
 293
 294 void XMLDocument::XMLEndHandler(const XML_Char *name)
 295 {
 296    XMLElement *pLast;
 297 //   MessageBox("Info", "On End: %s", "Ok", ARRAY((int)name));
 298    if (hParse.Count() == 0)
 299    {
 300       eError = XErr_CorruptedXML;
 301       return;
 302    }
 303    pLast = hParse[hParse.Count()-1];
 304
 305    String s = pLast->GetValue();
 306    s.FromUTF8();
 307    pLast->SetValue(s.Data());
 308
 309    XMLElement *pElem = hParse[(hParse.Count() - 1)];
 310    hParse >> pElem;
 311 //   MessageBox("Info", "Done End: %s", "Ok", ARRAY((int)name));
 312 }
 313
 314 void XMLDocument::XMLContentHandler(const XML_Char *begin, int length)
 315 {
 316    XMLElement *pLast;
 317
 318 //   MessageBox("Info", "On Content", "Ok", 0);
 319
 320    if (hParse.Count() == 0)
 321    {
 322       eError = XErr_CorruptedXML;
 323       return;
 324    }
 325    pLast = hParse[hParse.Count()-1];   // get last element
 326
 327    String s1;
 328
 329    // 1. get current data
 330    s1 = pLast->GetValue();
 331
 332    // 2. get new data
 333    char *pBuff = new char[length+1];
 334    pBuff[length] = 0;
 335    strncpy(pBuff, begin, length);
 336
 337    // 3. concatenate two strings
 338    s1 += pBuff;
 339    delete [] pBuff;
 340
 341    // 4. set new data
 342    pLast->SetValue(s1.Data());
 343 //   MessageBox("Info", "Done Content", "Ok", 0);
 344 }
 345
 346 bool XMLDocument::ReadXML(const char *sName)
 347 {
 348    BPTR  fh = 0;
 349    void *mem;
 350    int   len;
 351
 352    ASSERT(NULL != pExpat);
 353    if (0 == pExpat)
 354    {
 355       eError = XErr_NoExpat;
 356       return false;
 357    }
 358
 359    sFileName = sName;
 360    ASSERT(sFileName.Length() != 0);
 361    if (sFileName.Length() == 0)
 362    {
 363       eError = XErr_NoFile;
 364       return false;
 365    }
 366
 367    eError = XErr_OK;
 368    level  = 0;
 369
 370    if (pParser)
 371       pExpat->XML_ParserFree(pParser);
 372
 373    pParser = 0;
 374
 375    fh = DOS->Open(sFileName.Data(), MODE_OLDFILE);
 376    if (fh == 0)
 377    {
 378       eError = XErr_NoFile;
 379       return false;
 380    }
 381
 382    ASSERT(0 != fh);
 383    pParser = pExpat->XML_ParserCreate(0);
 384    ASSERT(0 != pParser);
 385    if (pParser == 0)
 386    {
 387       DOS->Close(fh);
 388       eError = XErr_NoParser;
 389       return false;
 390    }
 391
 392    hParse.Empty();
 393    pExpat->XML_SetUserData(pParser, this);
 394    pExpat->XML_SetElementHandler(pParser, &XMLDocument::fXMLStartHandler, &XMLDocument::fXMLEndHandler);
 395    pExpat->XML_SetCharacterDataHandler(pParser, &XMLDocument::fXMLContentHandler);
 396
 397    do
 398    {
 399       len = 0;
 400       mem = pExpat->XML_GetBuffer(pParser, 8192);
 401       if (mem)
 402       {
 403          len = DOS->Read(fh, mem, 8192);
 404          pExpat->XML_ParseBuffer(pParser, len, 0 == len);
 405       }
 406       else
 407       {
 408          eError = XErr_NoMemory;
 409          break;
 410       }
 411    }
 412    while (0 != len);
 413
 414    DOS->Close(fh);
 415    pExpat->XML_ParserFree(pParser);
 416    pParser = 0;
 417    if (eError == XErr_OK)
 418       return true;
 419    return false;
 420 }
 421
 422 bool XMLDocument::WriteXML(const char *sName)
 423 {
 424    BPTR  fh = 0;
 425
 426    sFileName = sName;
 427    if (sFileName.Length() == 0)
 428    {
 429       eError = XErr_NoFile;
 430       return false;
 431    }
 432
 433    eError = XErr_OK;
 434
 435    fh = DOS->Open(sFileName.Data(), MODE_NEWFILE);
 436    if (fh == 0)
 437    {
 438       eError = XErr_NoFile;
 439       return false;
 440    }
 441
 442    DOS->FPuts(fh, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 443    level = 0;
 444    XMLWriteElement(fh, this);
 445
 446    DOS->Close(fh);
 447    if (eError == XErr_OK)
 448       return true;
 449    return false;
 450 }
 451
 452 /* FIXME: polaczyc w jedno */
 453
 454 bool XMLDocument::ReadXML(BPTR fh)
 455 {
 456    void *mem;
 457    int   len;
 458
 459    ASSERT(NULL != pExpat);
 460    if (0 == pExpat)
 461    {
 462       eError = XErr_NoExpat;
 463       return false;
 464    }
 465
 466    eError = XErr_OK;
 467    level  = 0;
 468
 469    if (pParser)
 470       pExpat->XML_ParserFree(pParser);
 471
 472    pParser = 0;
 473
 474    if (fh == 0)
 475    {
 476       eError = XErr_NoFile;
 477       return false;
 478    }
 479
 480
 481    ASSERT(0 != fh);
 482    pParser = pExpat->XML_ParserCreate(0);
 483    ASSERT(0 != pParser);
 484    if (pParser == 0)
 485    {
 486       DOS->Close(fh);
 487       eError = XErr_NoParser;
 488       return false;
 489    }
 490
 491    hParse.Empty();
 492    pExpat->XML_SetUserData(pParser, this);
 493    pExpat->XML_SetElementHandler(pParser, &XMLDocument::fXMLStartHandler, &XMLDocument::fXMLEndHandler);
 494    pExpat->XML_SetCharacterDataHandler(pParser, &XMLDocument::fXMLContentHandler);
 495
 496    do
 497    {
 498       len = 0;
 499       mem = pExpat->XML_GetBuffer(pParser, 8192);
 500       if (mem)
 501       {
 502          len = DOS->Read(fh, mem, 8192);
 503          if (0 != pExpat->XML_ParseBuffer(pParser, len, 0 == len))
 504          {
 505             eError = XErr_CorruptedXML;
 506             break;
 507          }
 508       }
 509       else
 510       {
 511          eError = XErr_NoMemory;
 512          break;
 513       }
 514    }
 515    while (0 != len);
 516
 517    pExpat->XML_ParserFree(pParser);
 518    pParser = 0;
 519    if (eError == XErr_OK)
 520       return true;
 521    return false;
 522 }
 523
 524 bool XMLDocument::WriteXML(BPTR fh)
 525 {
 526    eError = XErr_OK;
 527
 528    if (fh == 0)
 529    {
 530       eError = XErr_NoFile;
 531       return false;
 532    }
 533
 534    DOS->FPuts(fh, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
 535    level = 0;
 536    XMLWriteElement(fh, this);
 537
 538    if (eError == XErr_OK)
 539       return true;
 540    return false;
 541 }
 542
 543 void XMLDocument::XMLWriteElement(BPTR fh, XMLElement* pElem)
 544 {
 545    for (int i=0; i<level; i++)
 546       DOS->FPuts(fh, "\t");
 547    DOS->FPuts(fh, "<");
 548    DOS->FPuts(fh, (char*)pElem->GetName());
 549    for (long i=0; i<pElem->GetAttributesCount(); i++)
 550    {
 551       XMLAttribute *pAttr = pElem->GetAttribute(i);
 552       String        val = pAttr->GetValue();
 553
 554       val.Substitute("&", "&amp;");
 555       val.Substitute("'", "&apos;");
 556       val.Substitute("\"", "&quot;");
 557       val.Substitute("<", "&lt;");
 558       val.Substitute(">", "&gt;");
 559
 560       DOS->FPuts(fh, " ");
 561       DOS->FPuts(fh, (char*)pAttr->GetName());
 562       DOS->FPuts(fh, "=\"");
 563       DOS->FPuts(fh, (char*)(val.ToUTF8()));
 564       DOS->FPuts(fh, "\"");
 565    }
 566
 567    if (0 == pElem->GetChildrenCount())
 568    {
 569       if (0 != strlen(pElem->GetValue()))
 570       {
 571          String val = pElem->GetValue();
 572          // we pust the data.
 573          val.Substitute("&", "&amp;");
 574          val.Substitute("'", "&apos;");
 575          val.Substitute("\"", "&quot;");
 576          val.Substitute("<", "&lt;");
 577          val.Substitute(">", "&gt;");
 578
 579          DOS->FPuts(fh, ">");
 580          DOS->FPuts(fh, (char*)(val.ToUTF8()));
 581       }
 582       else
 583       {
 584          // it is all clear, we just close xml tag.
 585          DOS->FPuts(fh, " />\n");
 586          return;
 587       }
 588    }
 589    else
 590    {
 591       DOS->FPuts(fh, ">\n");
 592       ++level;
 593       for (long i=0; i<pElem->GetChildrenCount(); i++)
 594       {
 595          XMLElement *pEl = pElem->GetChild(i);
 596          XMLWriteElement(fh, pEl);
 597       }
 598       --level;
 599       for (int i=0; i<level; i++)
 600          DOS->FPuts(fh, "\t");
 601    }
 602    DOS->FPuts(fh, "</");
 603    DOS->FPuts(fh, (char*)pElem->GetName());
 604    DOS->FPuts(fh, ">\n");
 605 }
 606
 607 XMLDocument::XMLError XMLDocument::GetError()
 608 {
 609    return eError;
 610 }