1 // Created on: 2001-07-20
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2001-2012 OPEN CASCADE SAS
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.
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.
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.
20 //AGV 060302: Input from istream
21 // AGV 130302: bug corr: was error if strlen(root_elem_name) < 7
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>
40 const int XML_MIN_BUFFER = 10;
41 const int FILE_NONVALUE = -1;
51 STATE_ATTRIBUTE_EQUAL,
52 STATE_ATTRIBUTE_VALUE,
58 #define TEXT_COMPARE(aPtr,aPattern) \
59 (memcmp ((aPtr), (aPattern), sizeof(aPattern) - 1) == 0)
61 static Standard_Boolean isName (const char * aString,
62 const char * aStringEnd,
63 const char *& aNameEnd);
65 //=======================================================================
66 //function : LDOM_XmlReader()
67 //purpose : Constructor (file descriptor)
68 //=======================================================================
70 LDOM_XmlReader::LDOM_XmlReader (const int aFileDes,
71 const Handle(LDOM_MemManager)& aDocument,
72 TCollection_AsciiString& anErrorString)
73 : myEOF (Standard_False),
76 myIStream (cin), // one quirk of MSVC6.0: can't initialise by 0
78 myIStream (* (istream *) UndefinedHandleAddress),
80 myError (anErrorString),
81 myDocument (aDocument),
83 myEndPtr (&myBuffer[0])
86 //=======================================================================
87 //function : LDOM_XmlReader()
88 //purpose : Constructor (istream)
89 //=======================================================================
91 LDOM_XmlReader::LDOM_XmlReader (istream& anInput,
92 const Handle(LDOM_MemManager)& aDocument,
93 TCollection_AsciiString& anErrorString)
94 : myEOF (Standard_False),
95 myFileDes (FILE_NONVALUE),
97 myError (anErrorString),
98 myDocument (aDocument),
100 myEndPtr (&myBuffer[0])
103 //=======================================================================
104 //function : ReadRecord
105 //purpose : Read a record from XML file
106 //=======================================================================
108 LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord
109 (LDOM_OSStream& theData)
113 ParserState aState = STATE_WAITING;
114 const char * aStartData = NULL, * aNameEnd = NULL, * aPtr;
115 LDOMBasicString anAttrName, anAttrValue;
116 char anAttDelimiter = '\0';
119 // Check if the current file buffer is exhausted
120 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
121 // There should always be some bytes available in the buffer for analysis
122 Standard_Integer aBytesRest = (Standard_Integer)(myEndPtr - myPtr);
123 if (aBytesRest < XML_MIN_BUFFER) {
124 if (myEOF == Standard_True) {
126 break; // END of processing
128 // If we are reading some data, save the beginning and preserve the state
129 if (aStartData /* && aState != STATE_WAITING */) {
130 if (myPtr > aStartData)
131 theData.rdbuf()->sputn(aStartData, myPtr - aStartData);
132 aStartData = &myBuffer[0];
134 // Copy the rest of file data to the beginning of buffer
136 memcpy (&myBuffer[0], myPtr, aBytesRest);
138 // Read the full buffer and reset start and end buffer pointers
139 myPtr = &myBuffer[0];
140 Standard_Size aNBytes;
141 if (myFileDes != FILE_NONVALUE)
142 aNBytes = read (myFileDes, &myBuffer[aBytesRest],
143 XML_BUFFER_SIZE - aBytesRest);
145 myIStream.read (&myBuffer[aBytesRest],
146 XML_BUFFER_SIZE - aBytesRest);
147 aNBytes = (Standard_Size)myIStream.gcount();
150 myEOF = Standard_True; // END-OF-FILE
151 myEndPtr = &myBuffer[aBytesRest + aNBytes];
152 myBuffer[aBytesRest + aNBytes] = '\0';
156 // Check the character data
159 // Checking the characters in STATE_WAITING (blank, TEXT or markup)
160 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
170 // XML markup found, then make detect the record type
173 aState = STATE_HEADER;
178 aState = STATE_ELEMENT_END;
183 if (myPtr[2] == '-' && myPtr[3] == '-') {
184 aState = STATE_COMMENT;
186 } else if (TEXT_COMPARE (&myPtr[2], "DOCTYPE")) {
188 if (ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r')
190 aState = STATE_DOCTYPE;
192 } else if (TEXT_COMPARE (&myPtr[2], "[CDATA[")) {
193 aState = STATE_CDATA;
195 } else break; // ERROR
199 if (::isName (&myPtr[1], myEndPtr, aNameEnd)) {
200 aStartData = myPtr + 1;
202 if (myPtr < myEndPtr) {
203 myElement = & LDOM_BasicElement::Create (aStartData,
204 (Standard_Integer)(myPtr - aStartData),
207 aState = STATE_ATTRIBUTE_NAME;
210 aState = STATE_ELEMENT;
214 myError = "Unknown XML object: ";
215 myError += TCollection_AsciiString ((const Standard_CString)myPtr,
219 if (myEOF == Standard_True) continue;
221 // Limitation: we do not treat '&' as special character
222 aPtr = (const char *) memchr (myPtr, '<', myEndPtr - myPtr);
224 // The end of text field reached
225 theData.rdbuf()->sputn(myPtr, aPtr - myPtr);
232 } // end of checking in STATE_WAITING
235 // Checking the characters in STATE_HEADER, seek for "?>" sequence
236 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
238 aPtr = (const char *) memchr (aStartData, '?', (myEndPtr-1) - aStartData);
240 // The end of XML declaration found
241 if (aPtr[1] != '>') { // ERROR
242 myError = "Character \'>\' is expected in the end of XML declaration";
245 // The XML declaration is retrieved
246 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
250 myPtr = myEndPtr - 1;
253 // Checking the characters in STATE_DOCTYPE, seek for "]>" sequence
254 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
256 for (aPtr = aStartData; aPtr < myEndPtr-1; aPtr++) {
257 const int aChar = aPtr[0];
259 aState = STATE_DOCTYPE_MARKUP;
260 aStartData = &aPtr[1];
261 goto state_doctype_markup;
264 // The DOCTYPE declaration is retrieved
265 theData.rdbuf()->sputn(aStartData, aPtr - aStartData - 1);
270 myPtr = myEndPtr - 1;
273 state_doctype_markup:
274 case STATE_DOCTYPE_MARKUP:
275 aPtr = (const char *) memchr (aStartData, ']', (myEndPtr-1) - aStartData);
277 // The end of DOCTYPE declaration found
278 if (aPtr[1] != '>') { // ERROR
280 "Character \'>\' is expected in the end of DOCTYPE declaration";
283 // The DOCTYPE declaration is retrieved
284 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
288 myPtr = myEndPtr - 1;
291 // Checking the characters in STATE_COMMENT, seek for "-->" sequence
292 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
296 aPtr = (const char *) memchr (aPtr, '-', (myEndPtr - 2) - aPtr);
297 if (aPtr == NULL) break;
298 if (aPtr[1] != '-') ++ aPtr;
300 if (aPtr[2] != '>') { // ERROR
301 myError = "Character \'>\' is expected in the end of comment";
304 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
309 myPtr = myEndPtr - 2;
312 // Checking the characters in STATE_TEXT, seek for "<"
313 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
315 aPtr = (const char *) memchr (aStartData, '<', myEndPtr - aStartData);
317 // The end of text field reached
318 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
325 // Checking the characters in STATE_CDATA, seek for "]]"
326 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
330 aPtr = (const char *) memchr (aPtr, ']', (myEndPtr - 1) - aStartData);
331 if (aPtr == NULL) break;
332 if (aPtr[1] != ']') { // ERROR
333 myError = "Characters \']]\' are expected in the end of CDATA";
336 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
340 myPtr = myEndPtr - 1;
343 // Checking the characters in STATE_ELEMENT, seek the end of TagName
344 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
346 if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
347 if (theData.Length() == 0 || aNameEnd != myPtr) {
348 myError = "Invalid tag name";
352 theData.rdbuf()->sputn(aStartData, aNameEnd - aStartData);
353 char* aDataString = (char *)theData.str();
354 myElement = & LDOM_BasicElement::Create (aDataString, theData.Length(),
358 delete [] aDataString;
359 aState = STATE_ATTRIBUTE_NAME;
364 // Parsing a single attribute (STATE_ATTRIBUTE)
365 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
366 case STATE_ATTRIBUTE_NAME: // attribute name
372 if (aStartData) goto attr_name;
377 myError = "Inexpected end of attribute";
378 else if (myPtr[1] != '>')
379 myError = "Improper element tag termination";
384 theData << myElement->GetTagName();
386 return XML_FULL_ELEMENT;
391 myError = "Inexpected end of attribute";
397 theData << myElement->GetTagName();
399 return XML_START_ELEMENT;
401 if (::isName (myPtr, myEndPtr, aNameEnd) == Standard_False)
402 if (theData.Length() == 0 || aNameEnd != myPtr) {
403 myError = "Invalid attribute name";
406 if (aNameEnd >= myEndPtr)
409 if (theData.Length() == 0)
410 anAttrName = LDOMBasicString(myPtr, (Standard_Integer)(aNameEnd - myPtr), myDocument);
412 theData.rdbuf()->sputn(myPtr, aNameEnd - myPtr);
414 char* aDataString = (char *)theData.str();
416 anAttrName = LDOMBasicString (aDataString, myDocument);
417 delete [] aDataString;
420 aState = STATE_ATTRIBUTE_EQUAL;
425 case STATE_ATTRIBUTE_EQUAL: // attribute 'equal' sign
428 aState = STATE_ATTRIBUTE_VALUE;
436 myError = "Equal sign expected in attribute definition";
440 case STATE_ATTRIBUTE_VALUE: // attribute value
446 if (aStartData == NULL) {
450 if (anAttDelimiter == '\0') {
451 myError = "Expected an attribute value";
455 if (aStartData == NULL) {
456 aStartData = &myPtr[1];
457 anAttDelimiter = myPtr[0];
461 // Limitation: we do not take into account that '<' and '&'
462 // are not allowed in attribute values
463 aPtr = (const char *) memchr (aStartData, anAttDelimiter,
464 myEndPtr - aStartData);
466 (char&) aPtr[0] = '\0';
467 anAttDelimiter = '\0';
468 char * aDataString = (char *) aStartData;
469 const char * ePtr = aPtr;
471 // Append the end of the string to previously taken data
472 if (theData.Length() > 0) {
473 theData.rdbuf()->sputn(aStartData, aPtr-aStartData);
474 aDataString = (char *)theData.str();
475 ePtr = strchr (aDataString, '\0');
478 Standard_Integer aDataLen;
479 aDataString = LDOM_CharReference::Decode (aDataString, aDataLen);
480 if (IsDigit(aDataString[0])) {
481 if (getInteger (anAttrValue, aDataString, ePtr))
482 anAttrValue = LDOMBasicString (aDataString,aDataLen,myDocument);
484 anAttrValue = LDOMBasicString (aDataString, aDataLen, myDocument);
486 if (theData.Length() > 0) {
488 delete [] aDataString;
490 // Create an attribute
491 myLastChild = myElement -> AddAttribute (anAttrName, anAttrValue,
492 myDocument, myLastChild);
495 aState = STATE_ATTRIBUTE_NAME;
500 // Checking the characters in STATE_ELEMENT_END, seek for ">"
501 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
502 case STATE_ELEMENT_END:
503 aPtr = (const char *) memchr (aStartData, '>', myEndPtr - aStartData);
505 // The end of the end-element markup
506 theData.rdbuf()->sputn(aStartData, aPtr - aStartData);
508 return XML_END_ELEMENT;
514 if (aState != STATE_WAITING) {
515 myError = "Unexpected end of file";
521 //=======================================================================
524 //purpose : Check if aString is a valid XML Name
525 //=======================================================================
527 static Standard_Boolean isName (const char * aString,
528 const char * aStringEnd,
529 const char *& aNameEnd)
531 Standard_Boolean aResult;
532 char aCh = aString[0];
533 if (IsAlphabetic(aCh) || aCh == '_' || aCh == ':') {
534 const char * aPtr = &aString[1];
535 while (aPtr < aStringEnd) {
547 return Standard_True;
549 if (IsAlphanumeric(aCh) == 0) {
551 return Standard_False;
561 aResult = Standard_True;
564 aResult = Standard_False;
569 //=======================================================================
570 //function : getInteger
571 //purpose : Try to initialize theValue as Integer; return False on success
572 //=======================================================================
574 Standard_Boolean LDOM_XmlReader::getInteger (LDOMBasicString& theValue,
575 const char * theStart,
580 if (theEnd - theStart == 1 || theStart[0] != '0')
582 long aResult = strtol (theStart, &ptr, 10);
583 if (ptr == theEnd && errno == 0)
585 theValue = Standard_Integer(aResult);
586 return Standard_False;
589 return Standard_True;