src/LDOM/LDOM_XmlReader.cxx

   1 // Created on: 2001-07-20
   2 // Created by: Alexander GRIGORIEV
   3 // Copyright (c) 2001-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 //AGV 060302: Input from std::istream
  17 //            AGV 130302: bug corr: was error if strlen(root_elem_name) < 7
  18
  19 #include <LDOM_XmlReader.hxx>
  20 #include <Standard_Stream.hxx>
  21 #include <LDOM_MemManager.hxx>
  22 #include <LDOM_BasicAttribute.hxx>
  23 #include <LDOM_CharReference.hxx>
  24 #include <LDOM_OSStream.hxx>
  25
  26 #include <string.h>
  27 #include <errno.h>
  28 #ifdef _MSC_VER
  29 #include <io.h>
  30 #else
  31 #include <unistd.h>
  32 #endif
  33
  34 //#include <ctype.h>
  35
  36 const int XML_MIN_BUFFER = 10;
  37
  38 typedef enum {
  39   STATE_WAITING = 0,
  40   STATE_HEADER,
  41   STATE_DOCTYPE,
  42   STATE_DOCTYPE_MARKUP,
  43   STATE_ELEMENT,
  44   STATE_ELEMENT_END,
  45   STATE_ATTRIBUTE_NAME,
  46   STATE_ATTRIBUTE_EQUAL,
  47   STATE_ATTRIBUTE_VALUE,
  48   STATE_COMMENT,
  49   STATE_CDATA,
  50   STATE_TEXT
  51 } ParserState;
  52
  53 #define TEXT_COMPARE(aPtr,aPattern) \
  54   (memcmp ((aPtr), (aPattern), sizeof(aPattern) - 1) == 0)
  55
  56 static Standard_Boolean isName          (const char             * aString,
  57                                          const char             * aStringEnd,
  58                                          const char             *& aNameEnd);
  59
  60 //=======================================================================
  61 //function : LDOM_XmlReader()
  62 //purpose  : Constructor (file descriptor)
  63 //=======================================================================
  64
  65 LDOM_XmlReader::LDOM_XmlReader (
  66                                 const Handle(LDOM_MemManager)&  theDocument,
  67                                 TCollection_AsciiString&        theErrorString,
  68                                 const Standard_Boolean theTagPerStep)
  69 : myEOF      (Standard_False),
  70   myError    (theErrorString),
  71   myDocument (theDocument),
  72   myElement  (NULL),
  73   myLastChild(NULL),
  74   myPtr      (&myBuffer[0]),
  75   myEndPtr   (&myBuffer[0]),
  76   myTagPerStep (theTagPerStep)
  77 {
  78 }
  79
  80 //=======================================================================
  81 //function : ReadRecord
  82 //purpose  : Read a record from XML file
  83 //=======================================================================
  84
  85 LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord (Standard_IStream& theIStream,
  86                                         LDOM_OSStream& theData)
  87 {
  88   theData.Clear();
  89   myError.Clear();
  90   ParserState aState = STATE_WAITING;
  91   const char * aStartData = NULL, * aNameEnd = NULL, * aPtr;
  92   LDOMBasicString anAttrName, anAttrValue;
  93   char anAttDelimiter = '\0';
  94   Standard_Boolean aHasRead = Standard_False;
  95
  96   for(;;) {
  97     //  Check if the current file buffer is exhausted
  98     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  99     //  There should always be some bytes available in the buffer for analysis
 100     Standard_Integer aBytesRest = (Standard_Integer)(myEndPtr - myPtr);
 101     if (aBytesRest < XML_MIN_BUFFER)
 102     {
 103       if (myEOF == Standard_True)
 104       {
 105         if (aBytesRest <= 0)
 106           break;                        // END of processing
 107       }
 108       else if (myTagPerStep && aHasRead)
 109       {
 110         // in myTagPerStep mode, we should parse the buffer to the end before
 111         // getting more characters from the stream.
 112       }
 113       else
 114       {
 115       // If we are reading some data, save the beginning and preserve the state
 116         if (aStartData /* && aState != STATE_WAITING */) {
 117           if (myPtr > aStartData)
 118             theData.rdbuf()->sputn(aStartData, myPtr - aStartData);
 119           aStartData = &myBuffer[0];
 120         }
 121       // Copy the rest of file data to the beginning of buffer
 122         if (aBytesRest > 0)
 123           memcpy (&myBuffer[0], myPtr, aBytesRest);
 124
 125       // Read the full buffer and reset start and end buffer pointers
 126         myPtr    = &myBuffer[0];
 127         Standard_Size aNBytes;
 128
 129         if (myTagPerStep)
 130         {
 131           theIStream.getline (&myBuffer[aBytesRest], XML_BUFFER_SIZE - aBytesRest, '>');
 132           aHasRead = Standard_True;
 133         }
 134         else
 135         {
 136           theIStream.read (&myBuffer[aBytesRest], XML_BUFFER_SIZE - aBytesRest);
 137         }
 138         aNBytes = (Standard_Size)theIStream.gcount();
 139
 140         if (aNBytes == 0)
 141         {
 142           myEOF = Standard_True;                  // END-OF-FILE
 143         }
 144         else if (myTagPerStep)
 145         {
 146           // replace \0 (being inserted by getline method) with >
 147           myBuffer[aBytesRest + aNBytes - 1] = '>';
 148         }
 149         myEndPtr = &myBuffer[aBytesRest + aNBytes];
 150         myBuffer[aBytesRest + aNBytes] = '\0';
 151       }
 152     }
 153
 154     //  Check the character data
 155     switch (aState) {
 156
 157       // Checking the characters in STATE_WAITING (blank, TEXT or markup)
 158       // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 159     case STATE_WAITING:
 160       switch (myPtr[0]) {
 161       case ' ':
 162       case '\t':
 163       case '\n':
 164       case '\r':
 165         ++ myPtr;
 166         continue;
 167       case '<':
 168         // XML markup found, then make detect the record type
 169         switch (myPtr[1]) {
 170         case '?':
 171           aState = STATE_HEADER;
 172           myPtr += 2;
 173           aStartData = myPtr;
 174           continue;
 175         case '/':
 176           aState = STATE_ELEMENT_END;
 177           myPtr += 2;
 178           aStartData = myPtr;
 179           continue;
 180         case '!':
 181           if (myPtr[2] == '-' && myPtr[3] == '-') {
 182             aState = STATE_COMMENT;
 183             myPtr += 4;
 184           } else if (TEXT_COMPARE (&myPtr[2], "DOCTYPE")) {
 185             char ch = myPtr[9];
 186             if (ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r')
 187               break;
 188             aState = STATE_DOCTYPE;
 189             myPtr += 10;
 190           } else if (TEXT_COMPARE (&myPtr[2], "[CDATA[")) {
 191             aState = STATE_CDATA;
 192             myPtr += 9;
 193           } else break;                   // ERROR
 194           aStartData = myPtr;
 195           continue;
 196         default:
 197           if (::isName (&myPtr[1], myEndPtr, aNameEnd)) {
 198             aStartData = myPtr + 1;
 199             myPtr = aNameEnd;
 200             if (myPtr < myEndPtr) {
 201               myElement = & LDOM_BasicElement::Create (aStartData,
 202                                                        (Standard_Integer)(myPtr - aStartData),
 203                                                        myDocument);
 204               myLastChild = NULL;
 205               aState = STATE_ATTRIBUTE_NAME;
 206               aStartData = NULL;
 207             }else
 208               aState = STATE_ELEMENT;
 209             continue;
 210           }       // otherwise ERROR
 211         }     // end of switch
 212         myError = "Unknown XML object: ";
 213         myError += TCollection_AsciiString (myPtr, XML_MIN_BUFFER);
 214         return XML_UNKNOWN;
 215       case '\0':
 216         if (myEOF == Standard_True) continue;
 217         Standard_FALLTHROUGH
 218       default:
 219         //      Limitation: we do not treat '&' as special character
 220         aPtr = (const char *) memchr (myPtr, '<', myEndPtr - myPtr);
 221         if (aPtr) {
 222           // The end of text field reached
 223           theData.rdbuf()->sputn(myPtr, aPtr - myPtr);
 224           myPtr = aPtr;
 225           return XML_TEXT;
 226         }
 227         aState = STATE_TEXT;
 228         aStartData = myPtr;
 229         myPtr = myEndPtr;
 230         aHasRead = Standard_False;
 231       }   // end of checking in STATE_WAITING
 232       continue;
 233
 234       // Checking the characters in STATE_HEADER, seek for "?>" sequence
 235       // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 236     case STATE_HEADER:
 237       aPtr = (const char *) memchr (aStartData, '?', (myEndPtr-1) - aStartData);
 238       if (aPtr) {
 239         // The end of XML declaration found
 240         if (aPtr[1] != '>') {           // ERROR
 241           myError = "Character \'>\' is expected in the end of XML declaration";
 242           return XML_UNKNOWN;
 243         }
 244         // The XML declaration is retrieved
 245         theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 246         myPtr = aPtr + 2;
 247         return XML_HEADER;
 248       }
 249       myPtr = myEndPtr - 1;
 250       aHasRead = Standard_False;
 251       continue;
 252
 253       // Checking the characters in STATE_DOCTYPE, seek for "]>" sequence
 254       // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 255     case STATE_DOCTYPE:
 256       for (aPtr = aStartData; aPtr < myEndPtr-1; aPtr++) {
 257         const int aChar = aPtr[0];
 258         if (aChar == '[') {
 259           aState = STATE_DOCTYPE_MARKUP;
 260           aStartData = &aPtr[1];
 261           goto state_doctype_markup;
 262         }
 263         if (aChar == '>') {
 264           // The DOCTYPE declaration is retrieved
 265           theData.rdbuf()->sputn(aStartData, aPtr - aStartData - 1);
 266           myPtr = aPtr + 1;
 267           return XML_DOCTYPE;
 268         }
 269       }
 270       myPtr = myEndPtr - 1;
 271       aHasRead = Standard_False;
 272       continue;
 273
 274     state_doctype_markup:
 275     case STATE_DOCTYPE_MARKUP:
 276       aPtr = (const char *) memchr (aStartData, ']', (myEndPtr-1) - aStartData);
 277       if (aPtr) {
 278         // The end of DOCTYPE declaration found
 279         if (aPtr[1] != '>') {           // ERROR
 280           myError =
 281             "Character \'>\' is expected in the end of DOCTYPE declaration";
 282           return XML_UNKNOWN;
 283         }
 284         // The DOCTYPE declaration is retrieved
 285         theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 286         myPtr = aPtr + 2;
 287         return XML_DOCTYPE;
 288       }
 289       myPtr = myEndPtr - 1;
 290       aHasRead = Standard_False;
 291       continue;
 292
 293         // Checking the characters in STATE_COMMENT, seek for "-->" sequence
 294         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 295     case STATE_COMMENT:
 296       aPtr = aStartData;
 297       for(;;) {
 298         aPtr = (const char *) memchr (aPtr, '-', (myEndPtr - 2) - aPtr);
 299         if (aPtr == NULL) break;
 300         if (aPtr[1] != '-') ++ aPtr;
 301         else {
 302           if (aPtr[2] != '>') {       // ERROR
 303             myError = "Character \'>\' is expected in the end of comment";
 304             return XML_UNKNOWN;
 305           }
 306           theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 307           myPtr = aPtr + 3;
 308           return XML_COMMENT;
 309         }
 310       }
 311       myPtr = myEndPtr - 2;
 312       aHasRead = Standard_False;
 313       continue;
 314
 315         // Checking the characters in STATE_TEXT, seek for "<"
 316         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 317     case STATE_TEXT:
 318       aPtr = (const char *) memchr (aStartData, '<', myEndPtr - aStartData);
 319       if (aPtr) {
 320         // The end of text field reached
 321         theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 322         myPtr = aPtr;
 323         return XML_TEXT;
 324       }
 325       myPtr = myEndPtr;
 326       aHasRead = Standard_False;
 327       continue;
 328
 329         // Checking the characters in STATE_CDATA, seek for "]]"
 330         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 331     case STATE_CDATA:
 332       aPtr = aStartData;
 333       for(;;) {
 334         aPtr = (const char *) memchr (aPtr, ']', (myEndPtr - 1) - aStartData);
 335         if (aPtr == NULL) break;
 336         if (aPtr[1] != ']') {           // ERROR
 337           myError = "Characters \']]\' are expected in the end of CDATA";
 338           return XML_UNKNOWN;
 339         }
 340         theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 341         myPtr = aPtr + 2;
 342         return XML_CDATA;
 343       }
 344       myPtr = myEndPtr - 1;
 345       aHasRead = Standard_False;
 346       continue;
 347
 348         // Checking the characters in STATE_ELEMENT, seek the end of TagName
 349         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 350     case STATE_ELEMENT:
 351       if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
 352         if (theData.Length() == 0 || aNameEnd != myPtr) {
 353           myError = "Invalid tag name";
 354           return XML_UNKNOWN;
 355         }
 356       {
 357         theData.rdbuf()->sputn(aStartData, aNameEnd - aStartData);
 358         char* aDataString = (char *)theData.str();
 359         myElement = & LDOM_BasicElement::Create (aDataString, theData.Length(),
 360                                                  myDocument);
 361         theData.Clear();
 362         myLastChild = NULL;
 363         delete [] aDataString;
 364         aState = STATE_ATTRIBUTE_NAME;
 365         aStartData = NULL;
 366         myPtr = aNameEnd;
 367         continue;
 368       }
 369         // Parsing a single attribute (STATE_ATTRIBUTE)
 370         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 371     case STATE_ATTRIBUTE_NAME:          // attribute name
 372       switch (myPtr[0]) {
 373       case ' ' :
 374       case '\t':
 375       case '\n':
 376       case '\r':
 377         if (aStartData) goto attr_name;
 378         ++ myPtr;
 379         continue;
 380       case '/' :
 381         if (aStartData)
 382           myError = "Inexpected end of attribute";
 383         else if (myPtr[1] != '>')
 384           myError = "Improper element tag termination";
 385         else {
 386           myPtr += 2;
 387 #ifdef OCCT_DEBUG
 388           theData.Clear();
 389           theData << myElement->GetTagName();
 390 #endif
 391           return XML_FULL_ELEMENT;
 392         }
 393         return XML_UNKNOWN;
 394       case '>' :
 395         if (aStartData) {
 396           myError = "Inexpected end of attribute";
 397           return XML_UNKNOWN;
 398         }
 399         ++ myPtr;
 400 #ifdef OCCT_DEBUG
 401         theData.Clear();
 402         theData << myElement->GetTagName();
 403 #endif
 404         return XML_START_ELEMENT;
 405       default  :
 406         if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
 407           if (theData.Length() == 0 || aNameEnd != myPtr) {
 408             myError = "Invalid attribute name";
 409             return XML_UNKNOWN;
 410           }
 411         if (aNameEnd >= myEndPtr)
 412           aStartData = myPtr;
 413         else {
 414           if (theData.Length() == 0)
 415             anAttrName = LDOMBasicString(myPtr, (Standard_Integer)(aNameEnd - myPtr), myDocument);
 416           else {
 417             theData.rdbuf()->sputn(myPtr, aNameEnd - myPtr);
 418 attr_name:
 419             char* aDataString = (char *)theData.str();
 420             theData.Clear();
 421             anAttrName = LDOMBasicString (aDataString, myDocument);
 422             delete [] aDataString;
 423           }
 424           aStartData = NULL;
 425           aState = STATE_ATTRIBUTE_EQUAL;
 426         }
 427         myPtr = aNameEnd;
 428         continue;
 429       }
 430     case STATE_ATTRIBUTE_EQUAL:          // attribute 'equal' sign
 431       switch (myPtr[0]) {
 432       case '=' :
 433         aState = STATE_ATTRIBUTE_VALUE;
 434         Standard_FALLTHROUGH
 435       case ' ' :
 436       case '\t':
 437       case '\n':
 438       case '\r':
 439         ++ myPtr;
 440         continue;
 441       default:
 442         myError = "Equal sign expected in attribute definition";
 443         return XML_UNKNOWN;
 444       }
 445
 446     case STATE_ATTRIBUTE_VALUE:          // attribute value
 447       switch (myPtr[0]) {
 448       case ' ' :
 449       case '\t':
 450       case '\n':
 451       case '\r':
 452         if (aStartData == NULL) {
 453           ++ myPtr;
 454           continue;
 455       default:
 456           if (anAttDelimiter == '\0') {
 457             myError = "Expected an attribute value";
 458             return XML_UNKNOWN;
 459       case '\"':
 460       case '\'':
 461             if (aStartData == NULL) {
 462               aStartData     = &myPtr[1];
 463               anAttDelimiter = myPtr[0];
 464             }
 465           }
 466         }
 467         //      Limitation: we do not take into account that '<' and '&'
 468         //      are not allowed in attribute values
 469         aPtr = (const char *) memchr (aStartData, anAttDelimiter,
 470                                       myEndPtr - aStartData);
 471         if (aPtr) {
 472           (char&) aPtr[0] = '\0';
 473           anAttDelimiter  = '\0';
 474           char          * aDataString   = (char *) aStartData;
 475           const char    * ePtr          = aPtr;
 476
 477           //    Append the end of the string to previously taken data
 478           if (theData.Length() > 0) {
 479             theData.rdbuf()->sputn(aStartData, aPtr-aStartData);
 480             aDataString = (char *)theData.str();
 481             ePtr = strchr (aDataString, '\0');
 482           }
 483
 484           Standard_Integer aDataLen;
 485           aDataString = LDOM_CharReference::Decode (aDataString, aDataLen);
 486           if (IsDigit(aDataString[0])) {
 487             if (getInteger (anAttrValue, aDataString, ePtr))
 488               anAttrValue = LDOMBasicString (aDataString,aDataLen,myDocument);
 489           } else
 490             anAttrValue = LDOMBasicString (aDataString, aDataLen, myDocument);
 491
 492           if (theData.Length() > 0) {
 493             theData.Clear();
 494             delete [] aDataString;
 495           }
 496           //    Create an attribute
 497           myLastChild = myElement -> AddAttribute (anAttrName, anAttrValue,
 498                                                    myDocument, myLastChild);
 499           myPtr = aPtr + 1;
 500           aStartData = NULL;
 501           aState = STATE_ATTRIBUTE_NAME;
 502         }
 503         else {
 504           myPtr = myEndPtr;
 505           aHasRead = Standard_False;
 506         }
 507         continue;
 508       }
 509         // Checking the characters in STATE_ELEMENT_END, seek for ">"
 510         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 511     case STATE_ELEMENT_END:
 512       aPtr = (const char *) memchr (aStartData, '>', myEndPtr - aStartData);
 513       if (aPtr) {
 514         // The end of the end-element markup
 515         theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
 516         myPtr = aPtr + 1;
 517         return XML_END_ELEMENT;
 518       }
 519       myPtr = myEndPtr;
 520       aHasRead = Standard_False;
 521       continue;
 522     }
 523   }
 524   if (aState != STATE_WAITING) {
 525     myError = "Unexpected end of file";
 526     return XML_UNKNOWN;
 527   }
 528   return XML_EOF;
 529 }
 530
 531 //=======================================================================
 532 //function : isName
 533 //type     : static
 534 //purpose  : Check if aString is a valid XML Name
 535 //=======================================================================
 536
 537 static Standard_Boolean isName (const char  * aString,
 538                                 const char  * aStringEnd,
 539                                 const char  *& aNameEnd)
 540 {
 541   Standard_Boolean aResult;
 542   char aCh = aString[0];
 543   if (IsAlphabetic(aCh) || aCh == '_' || aCh == ':') {
 544     const char * aPtr = &aString[1];
 545     while (aPtr < aStringEnd) {
 546       aCh = * aPtr;
 547       switch (aCh) {
 548       case ' ' :
 549       case '\n':
 550       case '\r':
 551       case '\t':
 552       case '=' :
 553       case '\0':
 554       case '/' :
 555       case '>' :
 556         aNameEnd = aPtr;
 557         return Standard_True;
 558       default:
 559         if (IsAlphanumeric(aCh) == 0) {
 560           aNameEnd = aPtr;
 561           return Standard_False;
 562         }
 563         Standard_FALLTHROUGH
 564       case '.' :
 565       case '-' :
 566       case '_' :
 567       case ':' :
 568         ++ aPtr;
 569       }
 570     }
 571     aNameEnd = aPtr;
 572     aResult = Standard_True;
 573   } else {
 574     aNameEnd = aString;
 575     aResult = Standard_False;
 576   }
 577   return aResult;
 578 }
 579
 580 //=======================================================================
 581 //function : CreateElement
 582 //purpose  :
 583 //=======================================================================
 584 void LDOM_XmlReader::CreateElement( const char *theName, const Standard_Integer theLen )
 585 {
 586   myElement = &LDOM_BasicElement::Create (theName, theLen, myDocument);
 587 }
 588
 589 //=======================================================================
 590 //function : getInteger
 591 //purpose  : Try to initialize theValue as Integer; return False on success
 592 //=======================================================================
 593
 594 Standard_Boolean LDOM_XmlReader::getInteger (LDOMBasicString&    theValue,
 595                                              const char          * theStart,
 596                                              const char          * theEnd)
 597 {
 598   char * ptr;
 599   errno = 0;
 600   if (theEnd - theStart == 1 || theStart[0] != '0')
 601   {
 602       long aResult = strtol (theStart, &ptr, 10);
 603       if (ptr == theEnd && errno == 0)
 604       {
 605         theValue = Standard_Integer(aResult);
 606         return Standard_False;
 607       }
 608   }
 609   return Standard_True;
 610 }