[occt.git] / src / LDOM / LDOM_XmlReader.cxx

// Created on: 2001-07-20
// Created by: Alexander GRIGORIEV
// Copyright (c) 2001-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

//AGV 060302: Input from istream
//            AGV 130302: bug corr: was error if strlen(root_elem_name) < 7

#include <LDOM_XmlReader.hxx>
#include <Standard_Stream.hxx>
#include <LDOM_MemManager.hxx>
#include <LDOM_BasicAttribute.hxx>
#include <LDOM_CharReference.hxx>
#include <LDOM_OSStream.hxx>

#include <string.h>
#include <errno.h>
#ifdef WNT
#include <io.h>
#else
#include <unistd.h>
#endif

//#include <ctype.h>

const int XML_MIN_BUFFER = 10;
const int MAX_ATTRIBUTES = 512;
const int FILE_NONVALUE  = -1;

typedef enum {
  STATE_WAITING = 0,
  STATE_HEADER,
  STATE_DOCTYPE,
  STATE_DOCTYPE_MARKUP,
  STATE_ELEMENT,
  STATE_ELEMENT_END,
  STATE_ATTRIBUTE_NAME,
  STATE_ATTRIBUTE_EQUAL,
  STATE_ATTRIBUTE_VALUE,
  STATE_COMMENT,
  STATE_CDATA,
  STATE_TEXT
} ParserState;

#define TEXT_COMPARE(aPtr,aPattern) \
  (memcmp ((aPtr), (aPattern), sizeof(aPattern) - 1) == 0)

static Standard_Boolean isName          (const char             * aString,
                                         const char             * aStringEnd,
                                         const char             *& aNameEnd);

//=======================================================================
//function : LDOM_XmlReader()
//purpose  : Constructor (file descriptor)
//=======================================================================

LDOM_XmlReader::LDOM_XmlReader (const int                       aFileDes,
                                const Handle(LDOM_MemManager)&  aDocument,
                                TCollection_AsciiString&        anErrorString)
     : myEOF            (Standard_False),
       myFileDes        (aFileDes),
#ifdef WNT
       myIStream        (cin),  // one quirk of MSVC6.0: can't initialise by 0
#else
       myIStream        (* (istream *) UndefinedHandleAddress),
#endif
       myError          (anErrorString),
       myDocument       (aDocument),
       myPtr            (&myBuffer[0]),
       myEndPtr         (&myBuffer[0])
{}

//=======================================================================
//function : LDOM_XmlReader()
//purpose  : Constructor (istream)
//=======================================================================

LDOM_XmlReader::LDOM_XmlReader (istream&                        anInput,
                                const Handle(LDOM_MemManager)&  aDocument,
                                TCollection_AsciiString&        anErrorString)
     : myEOF            (Standard_False),
       myFileDes        (FILE_NONVALUE),
       myIStream        (anInput),
       myError          (anErrorString),
       myDocument       (aDocument),
       myPtr            (&myBuffer[0]),
       myEndPtr         (&myBuffer[0])
{}

//=======================================================================
//function : ReadRecord
//purpose  : Read a record from XML file
//=======================================================================

LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord
                                        (LDOM_OSStream& theData)
{
  theData.Clear();
  myError.Clear();
  ParserState aState = STATE_WAITING;
  const char * aStartData = NULL, * aNameEnd = NULL, * aPtr;
  LDOMBasicString anAttrName, anAttrValue;
  char anAttDelimiter = '\0';

  for(;;) {
    //  Check if the current file buffer is exhausted
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //  There should always be some bytes available in the buffer for analysis
    Standard_Integer aBytesRest = myEndPtr - myPtr;
    if (aBytesRest < XML_MIN_BUFFER) {
      if (myEOF == Standard_True) {
        if (aBytesRest <= 0)
          break;                        // END of processing
      } else {
      // If we are reading some data, save the beginning and preserve the state
        if (aStartData /* && aState != STATE_WAITING */) {
          if (myPtr > aStartData)
            theData.rdbuf()->sputn(aStartData, myPtr - aStartData);
          aStartData = &myBuffer[0];
        }
      // Copy the rest of file data to the beginning of buffer
        if (aBytesRest > 0)
          memcpy (&myBuffer[0], myPtr, aBytesRest);

      // Read the full buffer and reset start and end buffer pointers
        myPtr    = &myBuffer[0];
        Standard_Size aNBytes;
        if (myFileDes != FILE_NONVALUE)
          aNBytes = read (myFileDes, &myBuffer[aBytesRest],
                          XML_BUFFER_SIZE - aBytesRest);
        else {
          myIStream.read (&myBuffer[aBytesRest],
                          XML_BUFFER_SIZE - aBytesRest);
          aNBytes = myIStream.gcount();
        }
        if (aNBytes == 0)
          myEOF = Standard_True;                  // END-OF-FILE
        myEndPtr = &myBuffer[aBytesRest + aNBytes];
        myBuffer[aBytesRest + aNBytes] = '\0';
      }
    }

    //  Check the character data
    switch (aState) {

      // Checking the characters in STATE_WAITING (blank, TEXT or markup)
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_WAITING:
      switch (myPtr[0]) {
      case ' ':
      case '\t':
      case '\n':
      case '\r':
        ++ myPtr;
        continue;
      case '<':
        // XML markup found, then make detect the record type
        switch (myPtr[1]) {
        case '?':
          aState = STATE_HEADER;
          myPtr += 2;
          aStartData = myPtr;
          continue;
        case '/':
          aState = STATE_ELEMENT_END;
          myPtr += 2;
          aStartData = myPtr;
          continue;
        case '!':
          if (myPtr[2] == '-' && myPtr[3] == '-') {
            aState = STATE_COMMENT;
            myPtr += 4;
          } else if (TEXT_COMPARE (&myPtr[2], "DOCTYPE")) {
            char ch = myPtr[9];
            if (ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r')
              break;
            aState = STATE_DOCTYPE;
            myPtr += 10;
          } else if (TEXT_COMPARE (&myPtr[2], "[CDATA[")) {
            aState = STATE_CDATA;
            myPtr += 9;
          } else break;                   // ERROR
          aStartData = myPtr;
          continue;
        default:
          if (::isName (&myPtr[1], myEndPtr, aNameEnd)) {
            aStartData = myPtr + 1;
            myPtr = aNameEnd;
            if (myPtr < myEndPtr) {
              myElement = & LDOM_BasicElement::Create (aStartData,
                                                       myPtr - aStartData,
                                                       myDocument);
              myLastChild = NULL;
              aState = STATE_ATTRIBUTE_NAME;
              aStartData = NULL;
            }else
              aState = STATE_ELEMENT;
            continue;
          }       // otherwise ERROR
        }     // end of switch
        myError = "Unknown XML object: ";
        myError += TCollection_AsciiString ((const Standard_CString)myPtr,
                                            XML_MIN_BUFFER);
        return XML_UNKNOWN;
      case '\0':
        if (myEOF == Standard_True) continue;
      default:
        //      Limitation: we do not treat '&' as special character
        aPtr = (const char *) memchr (myPtr, '<', myEndPtr - myPtr);
        if (aPtr) {
          // The end of text field reached
          theData.rdbuf()->sputn(myPtr, aPtr - myPtr);
          myPtr = aPtr;
          return XML_TEXT;
        }
        aState = STATE_TEXT;
        aStartData = myPtr;
        myPtr = myEndPtr;
      }   // end of checking in STATE_WAITING
      continue;

      // Checking the characters in STATE_HEADER, seek for "?>" sequence
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_HEADER:
      aPtr = (const char *) memchr (aStartData, '?', (myEndPtr-1) - aStartData);
      if (aPtr) {
        // The end of XML declaration found
        if (aPtr[1] != '>') {           // ERROR
          myError = "Character \'>\' is expected in the end of XML declaration";
          return XML_UNKNOWN;
        }
        // The XML declaration is retrieved
        theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
        myPtr = aPtr + 2;
        return XML_HEADER;
      }
      myPtr = myEndPtr - 1;
      continue;

      // Checking the characters in STATE_DOCTYPE, seek for "]>" sequence
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_DOCTYPE:
      for (aPtr = aStartData; aPtr < myEndPtr-1; aPtr++) {
        const int aChar = aPtr[0];
        if (aChar == '[') {
          aState = STATE_DOCTYPE_MARKUP;
          aStartData = &aPtr[1];
          goto state_doctype_markup;
        }
        if (aChar == '>') {
          // The DOCTYPE declaration is retrieved
          theData.rdbuf()->sputn(aStartData, aPtr - aStartData - 1);
          myPtr = aPtr + 1;
          return XML_DOCTYPE;
        }
      }
      myPtr = myEndPtr - 1;
      continue;

    state_doctype_markup:
    case STATE_DOCTYPE_MARKUP:
      aPtr = (const char *) memchr (aStartData, ']', (myEndPtr-1) - aStartData);
      if (aPtr) {
        // The end of DOCTYPE declaration found
        if (aPtr[1] != '>') {           // ERROR
          myError =
            "Character \'>\' is expected in the end of DOCTYPE declaration";
          return XML_UNKNOWN;
        }
        // The DOCTYPE declaration is retrieved
        theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
        myPtr = aPtr + 2;
        return XML_DOCTYPE;
      }
      myPtr = myEndPtr - 1;
      continue;

        // Checking the characters in STATE_COMMENT, seek for "-->" sequence
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_COMMENT:
      aPtr = aStartData;
      for(;;) {
        aPtr = (const char *) memchr (aPtr, '-', (myEndPtr - 2) - aPtr);
        if (aPtr == NULL) break;
        if (aPtr[1] != '-') ++ aPtr;
        else {
          if (aPtr[2] != '>') {       // ERROR
            myError = "Character \'>\' is expected in the end of comment";
            return XML_UNKNOWN;
          }
          theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
          myPtr = aPtr + 3;
          return XML_COMMENT;
        }
      }
      myPtr = myEndPtr - 2;
      continue;

        // Checking the characters in STATE_TEXT, seek for "<"
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_TEXT:
      aPtr = (const char *) memchr (aStartData, '<', myEndPtr - aStartData);
      if (aPtr) {
        // The end of text field reached
        theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
        myPtr = aPtr;
        return XML_TEXT;
      }
      myPtr = myEndPtr;
      continue;

        // Checking the characters in STATE_CDATA, seek for "]]"
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_CDATA:
      aPtr = aStartData;
      for(;;) {
        aPtr = (const char *) memchr (aPtr, ']', (myEndPtr - 1) - aStartData);
        if (aPtr == NULL) break;
        if (aPtr[1] != ']') {           // ERROR
          myError = "Characters \']]\' are expected in the end of CDATA";
          return XML_UNKNOWN;
        }
        theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
        myPtr = aPtr + 2;
        return XML_CDATA;
      }
      myPtr = myEndPtr - 1;
      continue;

        // Checking the characters in STATE_ELEMENT, seek the end of TagName
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_ELEMENT:
      if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
        if (theData.Length() == 0 || aNameEnd != myPtr) {
          myError = "Invalid tag name";
          return XML_UNKNOWN;
        }
      {
        theData.rdbuf()->sputn(aStartData, aNameEnd - aStartData);
        char* aDataString = (char *)theData.str();
        myElement = & LDOM_BasicElement::Create (aDataString, theData.Length(),
                                                 myDocument);
        theData.Clear();
        myLastChild = NULL;
        delete [] aDataString;
        aState = STATE_ATTRIBUTE_NAME;
        aStartData = NULL;
        myPtr = aNameEnd;
        continue;
      }
        // Parsing a single attribute (STATE_ATTRIBUTE)
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_ATTRIBUTE_NAME:          // attribute name
      switch (myPtr[0]) {
      case ' ' :
      case '\t':
      case '\n':
      case '\r':
        if (aStartData) goto attr_name;
        ++ myPtr;
        continue;
      case '/' :
        if (aStartData)
          myError = "Inexpected end of attribute";
        else if (myPtr[1] != '>')
          myError = "Improper element tag termination";
        else {
          myPtr += 2;
#ifdef DEB
          theData.Clear();
          theData << myElement->GetTagName();
#endif
          return XML_FULL_ELEMENT;
        }
        return XML_UNKNOWN;
      case '>' :
        if (aStartData) {
          myError = "Inexpected end of attribute";
          return XML_UNKNOWN;
        }
        ++ myPtr;
#ifdef DEB
        theData.Clear();
        theData << myElement->GetTagName();
#endif
        return XML_START_ELEMENT;
      default  :
        if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
          if (theData.Length() == 0 || aNameEnd != myPtr) {
            myError = "Invalid attribute name";
            return XML_UNKNOWN;
          }
        if (aNameEnd >= myEndPtr)
          aStartData = myPtr;
        else {
          if (theData.Length() == 0)
            anAttrName = LDOMBasicString(myPtr, aNameEnd - myPtr, myDocument);
          else {
            theData.rdbuf()->sputn(myPtr, aNameEnd - myPtr);
attr_name:
            char* aDataString = (char *)theData.str();
            theData.Clear();
            anAttrName = LDOMBasicString (aDataString, myDocument);
            delete [] aDataString;
          }
          aStartData = NULL;
          aState = STATE_ATTRIBUTE_EQUAL;
        }
        myPtr = aNameEnd;
        continue;
      }
    case STATE_ATTRIBUTE_EQUAL:          // attribute 'equal' sign
      switch (myPtr[0]) {
      case '=' :
        aState = STATE_ATTRIBUTE_VALUE;
      case ' ' :
      case '\t':
      case '\n':
      case '\r':
        ++ myPtr;
        continue;
      default:
        myError = "Equal sign expected in attribute definition";
        return XML_UNKNOWN;
      }

    case STATE_ATTRIBUTE_VALUE:          // attribute value
      switch (myPtr[0]) {
      case ' ' :
      case '\t':
      case '\n':
      case '\r':
        if (aStartData == NULL) {
          ++ myPtr;
          continue;
      default:
          if (anAttDelimiter == '\0') {
            myError = "Expected an attribute value";
            return XML_UNKNOWN;
      case '\"':
      case '\'':
            if (aStartData == NULL) {
              aStartData     = &myPtr[1];
              anAttDelimiter = myPtr[0];
            }
          }
        }
        //      Limitation: we do not take into account that '<' and '&'
        //      are not allowed in attribute values
        aPtr = (const char *) memchr (aStartData, anAttDelimiter,
                                      myEndPtr - aStartData);
        if (aPtr) {
          (char&) aPtr[0] = '\0';
          anAttDelimiter  = '\0';
          char          * aDataString   = (char *) aStartData;
          const char    * ePtr          = aPtr;

          //    Append the end of the string to previously taken data
          if (theData.Length() > 0) {
            theData.rdbuf()->sputn(aStartData, aPtr-aStartData);
            aDataString = (char *)theData.str();
            ePtr = strchr (aDataString, '\0');
          }

          Standard_Integer aDataLen;
          aDataString = LDOM_CharReference::Decode (aDataString, aDataLen);
          if (IsDigit(aDataString[0])) {
            if (getInteger (anAttrValue, aDataString, ePtr))
              anAttrValue = LDOMBasicString (aDataString,aDataLen,myDocument);
          } else
            anAttrValue = LDOMBasicString (aDataString, aDataLen, myDocument);

          if (theData.Length() > 0) {
            theData.Clear();
            delete [] aDataString;
          }
          //    Create an attribute
          myLastChild = myElement -> AddAttribute (anAttrName, anAttrValue,
                                                   myDocument, myLastChild);
          myPtr = aPtr + 1;
          aStartData = NULL;
          aState = STATE_ATTRIBUTE_NAME;
        } else
          myPtr = myEndPtr;
        continue;
      }
        // Checking the characters in STATE_ELEMENT_END, seek for ">"
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    case STATE_ELEMENT_END:
      aPtr = (const char *) memchr (aStartData, '>', myEndPtr - aStartData);
      if (aPtr) {
        // The end of the end-element markup
        theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
        myPtr = aPtr + 1;
        return XML_END_ELEMENT;
      }
      myPtr = myEndPtr;
      continue;
    }
  }
  if (aState != STATE_WAITING) {
    myError = "Unexpected end of file";
    return XML_UNKNOWN;
  }
  return XML_EOF;
}

//=======================================================================
//function : isName
//type     : static
//purpose  : Check if aString is a valid XML Name
//=======================================================================

static Standard_Boolean isName (const char  * aString,
                                const char  * aStringEnd,
                                const char  *& aNameEnd)
{
  Standard_Boolean aResult;
  char aCh = aString[0];
  if (IsAlphabetic(aCh) || aCh == '_' || aCh == ':') {
    const char * aPtr = &aString[1];
    while (aPtr < aStringEnd) {
      aCh = * aPtr;
      switch (aCh) {
      case ' ' :
      case '\n':
      case '\r':
      case '\t':
      case '=' :
      case '\0':
      case '/' :
      case '>' :
        aNameEnd = aPtr;
        return Standard_True;
      default:
        if (IsAlphanumeric(aCh) == 0) {
          aNameEnd = aPtr;
          return Standard_False;
        }
      case '.' :
      case '-' :
      case '_' :
      case ':' :
        ++ aPtr;
      }
    }
    aNameEnd = aPtr;
    aResult = Standard_True;
  } else {
    aNameEnd = aString;
    aResult = Standard_False;
  }
  return aResult;
}

//=======================================================================
//function : getInteger
//purpose  : Try to initialize theValue as Integer; return False on success
//=======================================================================

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