/**************************************************************************** ** ** Implementation of TQXmlSimpleReader and related classes. ** ** Created : 000518 ** ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. ** ** This file is part of the xml module of the TQt GUI Toolkit. ** ** This file may be used under the terms of the GNU General ** Public License versions 2.0 or 3.0 as published by the Free ** Software Foundation and appearing in the files LICENSE.GPL2 ** and LICENSE.GPL3 included in the packaging of this file. ** Alternatively you may (at your option) use any later version ** of the GNU General Public License if such license has been ** publicly approved by Trolltech ASA (or its successors, if any) ** and the KDE Free TQt Foundation. ** ** Please review the following information to ensure GNU General ** Public Licensing requirements will be met: ** http://trolltech.com/products/qt/licenses/licensing/opensource/. ** If you are unsure which license is appropriate for your use, please ** review the following information: ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview ** or contact the sales department at sales@trolltech.com. ** ** This file may be used under the terms of the Q Public License as ** defined by Trolltech ASA and appearing in the file LICENSE.TQPL ** included in the packaging of this file. Licensees holding valid TQt ** Commercial licenses may use this file in accordance with the TQt ** Commercial License Agreement provided with the Software. ** ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted ** herein. ** **********************************************************************/ #include "ntqxml.h" #include "ntqtextcodec.h" #include "ntqbuffer.h" #include "ntqregexp.h" #include "ntqptrstack.h" #include "ntqmap.h" #include "ntqvaluestack.h" // needed for QT_TRANSLATE_NOOP: #include "ntqobject.h" #ifndef TQT_NO_XML //#define QT_QXML_DEBUG // Error strings for the XML reader #define XMLERR_OK QT_TRANSLATE_NOOP( "TQXml", "no error occurred" ) #define XMLERR_ERRORBYCONSUMER QT_TRANSLATE_NOOP( "TQXml", "error triggered by consumer" ) #define XMLERR_UNEXPECTEDEOF QT_TRANSLATE_NOOP( "TQXml", "unexpected end of file" ) #define XMLERR_MORETHANONEDOCTYPE QT_TRANSLATE_NOOP( "TQXml", "more than one document type definition" ) #define XMLERR_ERRORPARSINGELEMENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing element" ) #define XMLERR_TAGMISMATCH QT_TRANSLATE_NOOP( "TQXml", "tag mismatch" ) #define XMLERR_ERRORPARSINGCONTENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing content" ) #define XMLERR_UNEXPECTEDCHARACTER QT_TRANSLATE_NOOP( "TQXml", "unexpected character" ) #define XMLERR_INVALIDNAMEFORPI QT_TRANSLATE_NOOP( "TQXml", "invalid name for processing instruction" ) #define XMLERR_VERSIONEXPECTED QT_TRANSLATE_NOOP( "TQXml", "version expected while reading the XML declaration" ) #define XMLERR_WRONGVALUEFORSDECL QT_TRANSLATE_NOOP( "TQXml", "wrong value for standalone declaration" ) #define XMLERR_EDECLORSDDECLEXPECTED QT_TRANSLATE_NOOP( "TQXml", "encoding declaration or standalone declaration expected while reading the XML declaration" ) #define XMLERR_SDDECLEXPECTED QT_TRANSLATE_NOOP( "TQXml", "standalone declaration expected while reading the XML declaration" ) #define XMLERR_ERRORPARSINGDOCTYPE QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing document type definition" ) #define XMLERR_LETTEREXPECTED QT_TRANSLATE_NOOP( "TQXml", "letter is expected" ) #define XMLERR_ERRORPARSINGCOMMENT QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing comment" ) #define XMLERR_ERRORPARSINGREFERENCE QT_TRANSLATE_NOOP( "TQXml", "error occurred while parsing reference" ) #define XMLERR_INTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "internal general entity reference not allowed in DTD" ) #define XMLERR_EXTERNALGENERALENTITYINAV QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in attribute value" ) #define XMLERR_EXTERNALGENERALENTITYINDTD QT_TRANSLATE_NOOP( "TQXml", "external parsed general entity reference not allowed in DTD" ) #define XMLERR_UNPARSEDENTITYREFERENCE QT_TRANSLATE_NOOP( "TQXml", "unparsed entity reference in wrong context" ) #define XMLERR_RECURSIVEENTITIES QT_TRANSLATE_NOOP( "TQXml", "recursive entities" ) #define XMLERR_ERRORINTEXTDECL QT_TRANSLATE_NOOP( "TQXml", "error in the text declaration of an external entity" ) // the constants for the lookup table static const signed char cltWS = 0; // white space static const signed char cltPer = 1; // % static const signed char cltAmp = 2; // & static const signed char cltGt = 3; // > static const signed char cltLt = 4; // < static const signed char cltSlash = 5; // / static const signed char cltQm = 6; // ? static const signed char cltEm = 7; // ! static const signed char cltDash = 8; // - static const signed char cltCB = 9; // ] static const signed char cltOB = 10; // [ static const signed char cltEq = 11; // = static const signed char cltDq = 12; // " static const signed char cltSq = 13; // ' static const signed char cltUnknown = 14; // character lookup table static const signed char charLookupTable[256]={ cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x00 - 0x07 cltUnknown, // 0x08 cltWS, // 0x09 \t cltWS, // 0x0A \n cltUnknown, // 0x0B cltUnknown, // 0x0C cltWS, // 0x0D \r cltUnknown, // 0x0E cltUnknown, // 0x0F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x17 - 0x16 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x18 - 0x1F cltWS, // 0x20 Space cltEm, // 0x21 ! cltDq, // 0x22 " cltUnknown, // 0x23 cltUnknown, // 0x24 cltPer, // 0x25 % cltAmp, // 0x26 & cltSq, // 0x27 ' cltUnknown, // 0x28 cltUnknown, // 0x29 cltUnknown, // 0x2A cltUnknown, // 0x2B cltUnknown, // 0x2C cltDash, // 0x2D - cltUnknown, // 0x2E cltSlash, // 0x2F / cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x30 - 0x37 cltUnknown, // 0x38 cltUnknown, // 0x39 cltUnknown, // 0x3A cltUnknown, // 0x3B cltLt, // 0x3C < cltEq, // 0x3D = cltGt, // 0x3E > cltQm, // 0x3F ? cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x40 - 0x47 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x48 - 0x4F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x50 - 0x57 cltUnknown, // 0x58 cltUnknown, // 0x59 cltUnknown, // 0x5A cltOB, // 0x5B [ cltUnknown, // 0x5C cltCB, // 0x5D ] cltUnknown, // 0x5E cltUnknown, // 0x5F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x60 - 0x67 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x68 - 0x6F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x70 - 0x77 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x78 - 0x7F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x80 - 0x87 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x88 - 0x8F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x90 - 0x97 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0x98 - 0x9F cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA0 - 0xA7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xA8 - 0xAF cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB0 - 0xB7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xB8 - 0xBF cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC0 - 0xC7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xC8 - 0xCF cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD0 - 0xD7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xD8 - 0xDF cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE0 - 0xE7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xE8 - 0xEF cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, // 0xF0 - 0xF7 cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown, cltUnknown // 0xF8 - 0xFF }; // // local helper functions // /* This function strips the TextDecl [77] ("") from the string \a str. The stripped version is stored in \a str. If this function finds an invalid TextDecl, it returns FALSE, otherwise TRUE. This function is used for external entities since those can include an TextDecl that must be stripped before inserting the entity. */ static bool stripTextDecl( TQString& str ) { TQString textDeclStart( "" )); TQString strTmp = str.replace( textDecl, "" ); if ( strTmp.length() != str.length() ) return FALSE; // external entity has wrong TextDecl str = strTmp; } return TRUE; } class TQXmlAttributesPrivate { }; class TQXmlInputSourcePrivate { }; class TQXmlParseExceptionPrivate { }; class TQXmlLocatorPrivate { }; class TQXmlDefaultHandlerPrivate { }; /*! \class TQXmlParseException ntqxml.h \reentrant \brief The TQXmlParseException class is used to report errors with the TQXmlErrorHandler interface. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools The XML subsystem constructs an instance of this class when it detects an error. You can retrieve the place where the error occurred using systemId(), publicId(), lineNumber() and columnNumber(), along with the error message(). \sa TQXmlErrorHandler TQXmlReader */ /*! \fn TQXmlParseException::TQXmlParseException( const TQString& name, int c, int l, const TQString& p, const TQString& s ) Constructs a parse exception with the error string \a name for column \a c and line \a l for the public identifier \a p and the system identifier \a s. */ /*! Returns the error message. */ TQString TQXmlParseException::message() const { return msg; } /*! Returns the column number where the error occurred. */ int TQXmlParseException::columnNumber() const { return column; } /*! Returns the line number where the error occurred. */ int TQXmlParseException::lineNumber() const { return line; } /*! Returns the public identifier where the error occurred. */ TQString TQXmlParseException::publicId() const { return pub; } /*! Returns the system identifier where the error occurred. */ TQString TQXmlParseException::systemId() const { return sys; } /*! \class TQXmlLocator ntqxml.h \reentrant \brief The TQXmlLocator class provides the XML handler classes with information about the parsing position within a file. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools The reader reports a TQXmlLocator to the content handler before it starts to parse the document. This is done with the TQXmlContentHandler::setDocumentLocator() function. The handler classes can now use this locator to get the position (lineNumber() and columnNumber()) that the reader has reached. */ /*! Constructor. */ TQXmlLocator::TQXmlLocator() { } /*! Destructor. */ TQXmlLocator::~TQXmlLocator() { } /*! \fn int TQXmlLocator::columnNumber() Returns the column number (starting at 1) or -1 if there is no column number available. */ /*! \fn int TQXmlLocator::lineNumber() Returns the line number (starting at 1) or -1 if there is no line number available. */ class TQXmlSimpleReaderLocator : public TQXmlLocator { public: TQXmlSimpleReaderLocator( TQXmlSimpleReader* parent ) { reader = parent; } ~TQXmlSimpleReaderLocator() { } int columnNumber() { return ( reader->columnNr == -1 ? -1 : reader->columnNr + 1 ); } int lineNumber() { return ( reader->lineNr == -1 ? -1 : reader->lineNr + 1 ); } // TQString getPublicId() // TQString getSystemId() private: TQXmlSimpleReader *reader; }; /********************************************* * * TQXmlNamespaceSupport * *********************************************/ typedef TQMap NamespaceMap; class TQXmlNamespaceSupportPrivate { public: TQXmlNamespaceSupportPrivate() { ns.insert( "xml", "http://www.w3.org/XML/1998/namespace" ); // the XML namespace } ~TQXmlNamespaceSupportPrivate() { } TQValueStack nsStack; NamespaceMap ns; }; /*! \class TQXmlNamespaceSupport ntqxml.h \reentrant \brief The TQXmlNamespaceSupport class is a helper class for XML readers which want to include namespace support. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools You can set the prefix for the current namespace with setPrefix(), and get the list of current prefixes (or those for a given URI) with prefixes(). The namespace URI is available from uri(). Use pushContext() to start a new namespace context, and popContext() to return to the previous namespace context. Use splitName() or processName() to split a name into its prefix and local name. See also the \link xml.html#sax2Namespaces namespace description\endlink. */ /*! Constructs a TQXmlNamespaceSupport. */ TQXmlNamespaceSupport::TQXmlNamespaceSupport() { d = new TQXmlNamespaceSupportPrivate; } /*! Destroys a TQXmlNamespaceSupport. */ TQXmlNamespaceSupport::~TQXmlNamespaceSupport() { delete d; } /*! This function declares a prefix \a pre in the current namespace context to be the namespace URI \a uri. The prefix remains in force until this context is popped, unless it is shadowed in a descendant context. Note that there is an asymmetry in this library. prefix() does not return the default "" prefix, even if you have declared one; to check for a default prefix, you must look it up explicitly using uri(). This asymmetry exists to make it easier to look up prefixes for attribute names, where the default prefix is not allowed. */ void TQXmlNamespaceSupport::setPrefix( const TQString& pre, const TQString& uri ) { if( pre.isNull() ) { d->ns.insert( "", uri ); } else { d->ns.insert( pre, uri ); } } /*! Returns one of the prefixes mapped to the namespace URI \a uri. If more than one prefix is currently mapped to the same URI, this function makes an arbitrary selection; if you want all of the prefixes, use prefixes() instead. Note: to check for a default prefix, use the uri() function with an argument of "". */ TQString TQXmlNamespaceSupport::prefix( const TQString& uri ) const { NamespaceMap::const_iterator itc, it = d->ns.constBegin(); while ( (itc=it) != d->ns.constEnd() ) { ++it; if ( itc.data() == uri && !itc.key().isEmpty() ) return itc.key(); } return ""; } /*! Looks up the prefix \a prefix in the current context and returns the currently-mapped namespace URI. Use the empty string ("") for the default namespace. */ TQString TQXmlNamespaceSupport::uri( const TQString& prefix ) const { return d->ns[prefix]; } /*! Splits the name \a qname at the ':' and returns the prefix in \a prefix and the local name in \a localname. \sa processName() */ void TQXmlNamespaceSupport::splitName( const TQString& qname, TQString& prefix, TQString& localname ) const { int pos = qname.find(':'); if (pos == -1) pos = qname.length(); prefix = qname.left( pos ); localname = qname.mid( pos+1 ); } /*! Processes a raw XML 1.0 name in the current context by removing the prefix and looking it up among the prefixes currently declared. \a qname is the raw XML 1.0 name to be processed. \a isAttribute is TRUE if the name is an attribute name. This function stores the namespace URI in \a nsuri (which will be set to TQString::null if the raw name has an undeclared prefix), and stores the local name (without prefix) in \a localname (which will be set to TQString::null if no namespace is in use). Note that attribute names are processed differently than element names: an unprefixed element name gets the default namespace (if any), while an unprefixed element name does not. */ void TQXmlNamespaceSupport::processName( const TQString& qname, bool isAttribute, TQString& nsuri, TQString& localname ) const { int len = qname.length(); const TQChar *data = qname.unicode(); for (int pos = 0; pos < len; ++pos) { if (data[pos].unicode() == ':') { nsuri = uri(qname.left(pos)); localname = qname.mid(pos + 1); return; } } // there was no ':' nsuri = TQString::null; // attributes don't take default namespace if (!isAttribute && !d->ns.isEmpty()) { /* We want to access d->ns.value(""), but as an optimization we use the fact that "" compares less than any other string, so it's either first in the map or not there. */ NamespaceMap::const_iterator first = d->ns.constBegin(); if (first.key().isEmpty()) nsuri = first.data(); // get default namespace } localname = qname; } /*! Returns a list of all the prefixes currently declared. If there is a default prefix, this function does not return it in the list; check for the default prefix using uri() with an argument of "". Note that if you want to iterate over the list, you should iterate over a copy, e.g. \code TQStringList list = myXmlNamespaceSupport.prefixes(); TQStringList::iterator it = list.begin(); while ( it != list.end() ) { myProcessing( *it ); ++it; } \endcode */ TQStringList TQXmlNamespaceSupport::prefixes() const { TQStringList list; NamespaceMap::const_iterator itc, it = d->ns.constBegin(); while ( (itc=it) != d->ns.constEnd() ) { ++it; if ( !itc.key().isEmpty() ) list.append( itc.key() ); } return list; } /*! \overload Returns a list of all prefixes currently declared for the namespace URI \a uri. The "xml:" prefix is included. If you only want one prefix that is mapped to the namespace URI, and you don't care which one you get, use the prefix() function instead. Note: the empty (default) prefix is never included in this list; to check for the presence of a default namespace, use uri() with an argument of "". Note that if you want to iterate over the list, you should iterate over a copy, e.g. \code TQStringList list = myXmlNamespaceSupport.prefixes( "" ); TQStringList::Iterator it = list.begin(); while( it != list.end() ) { myProcessing( *it ); ++it; } \endcode */ TQStringList TQXmlNamespaceSupport::prefixes( const TQString& uri ) const { TQStringList list; NamespaceMap::const_iterator itc, it = d->ns.constBegin(); while ( (itc=it) != d->ns.constEnd() ) { ++it; if ( itc.data() == uri && !itc.key().isEmpty() ) list.append( itc.key() ); } return list; } /*! Starts a new namespace context. Normally, you should push a new context at the beginning of each XML element: the new context automatically inherits the declarations of its parent context, and it also keeps track of which declarations were made within this context. \sa popContext() */ void TQXmlNamespaceSupport::pushContext() { d->nsStack.push(d->ns); } /*! Reverts to the previous namespace context. Normally, you should pop the context at the end of each XML element. After popping the context, all namespace prefix mappings that were previously in force are restored. \sa pushContext() */ void TQXmlNamespaceSupport::popContext() { d->ns.clear(); if( !d->nsStack.isEmpty() ) d->ns = d->nsStack.pop(); } /*! Resets this namespace support object ready for reuse. */ void TQXmlNamespaceSupport::reset() { delete d; d = new TQXmlNamespaceSupportPrivate; } /********************************************* * * TQXmlAttributes * *********************************************/ /*! \class TQXmlAttributes ntqxml.h \reentrant \brief The TQXmlAttributes class provides XML attributes. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools If attributes are reported by TQXmlContentHandler::startElement() this class is used to pass the attribute values. Use index() to locate the position of an attribute in the list, count() to retrieve the number of attributes, and clear() to remove the attributes. New attributes can be added with append(). Use type() to get an attribute's type and value() to get its value. The attribute's name is available from localName() or qName(), and its namespace URI from uri(). */ /*! \fn TQXmlAttributes::TQXmlAttributes() Constructs an empty attribute list. */ /*! \fn TQXmlAttributes::~TQXmlAttributes() Destroys the attributes object. */ /*! Looks up the index of an attribute by the qualified name \a qName. Returns the index of the attribute or -1 if it wasn't found. See also the \link xml.html#sax2Namespaces namespace description\endlink. */ int TQXmlAttributes::index( const TQString& qName ) const { return qnameList.findIndex( qName ); } /*! \overload Looks up the index of an attribute by a namespace name. \a uri specifies the namespace URI, or an empty string if the name has no namespace URI. \a localPart specifies the attribute's local name. Returns the index of the attribute, or -1 if it wasn't found. See also the \link xml.html#sax2Namespaces namespace description\endlink. */ int TQXmlAttributes::index( const TQString& uri, const TQString& localPart ) const { TQString uriTmp; if ( uri.isEmpty() ) uriTmp = TQString::null; else uriTmp = uri; uint count = (uint)uriList.count(); // ### size_t/int cast for ( uint i=0; iTQt Enterprise Edition. \endif \module XML \ingroup xml-tools All subclasses of TQXmlReader read the input XML document from this class. This class recognizes the encoding of the data by reading the encoding declaration in the XML file if it finds one, and reading the data using the corresponding encoding. If it does not find an encoding declaration, then it assumes that the data is either in UTF-8 or UTF-16, depending on whether it can find a byte-order mark. There are two ways to populate the input source with data: you can construct it with a TQIODevice* so that the input source reads the data from that device. Or you can set the data explicitly with one of the setData() functions. Usually you either construct a TQXmlInputSource that works on a TQIODevice* or you construct an empty TQXmlInputSource and set the data with setData(). There are only rare occasions where you would want to mix both methods. The TQXmlReader subclasses use the next() function to read the input character by character. If you want to start from the beginning again, use reset(). The functions data() and fetchData() are useful if you want to do something with the data other than parsing, e.g. displaying the raw XML file. The benefit of using the TQXmlInputClass in such cases is that it tries to use the correct encoding. \sa TQXmlReader TQXmlSimpleReader */ // the following two are guaranteed not to be a character const TQChar TQXmlInputSource::EndOfData = TQChar((ushort)0xfffe); const TQChar TQXmlInputSource::EndOfDocument = TQChar((ushort)0xffff); /* Common part of the constructors. */ void TQXmlInputSource::init() { inputDevice = 0; inputStream = 0; setData( TQString::null ); encMapper = 0; } /*! Constructs an input source which contains no data. \sa setData() */ TQXmlInputSource::TQXmlInputSource() { init(); } /*! Constructs an input source and gets the data from device \a dev. If \a dev is not open, it is opened in read-only mode. If \a dev is 0 or it is not possible to read from the device, the input source will contain no data. \sa setData() fetchData() TQIODevice */ TQXmlInputSource::TQXmlInputSource( TQIODevice *dev ) { init(); inputDevice = dev; fetchData(); } /*! \obsolete Constructs an input source and gets the data from the text stream \a stream. */ TQXmlInputSource::TQXmlInputSource( TQTextStream& stream ) { init(); inputStream = &stream; fetchData(); } /*! \obsolete Constructs an input source and gets the data from the file \a file. If the file cannot be read the input source is empty. */ TQXmlInputSource::TQXmlInputSource( TQFile& file ) { init(); inputDevice = &file; fetchData(); } /*! Destructor. */ TQXmlInputSource::~TQXmlInputSource() { delete encMapper; } /*! Returns the next character of the input source. If this function reaches the end of available data, it returns TQXmlInputSource::EndOfData. If you call next() after that, it tries to fetch more data by calling fetchData(). If the fetchData() call results in new data, this function returns the first character of that data; otherwise it returns TQXmlInputSource::EndOfDocument. \sa reset() fetchData() TQXmlSimpleReader::parse() TQXmlSimpleReader::parseContinue() */ TQChar TQXmlInputSource::next() { if ( pos >= length ) { if ( nextReturnedEndOfData ) { nextReturnedEndOfData = FALSE; fetchData(); if ( pos >= length ) { return EndOfDocument; } return next(); } nextReturnedEndOfData = TRUE; return EndOfData; } return unicode[pos++]; } /*! This function sets the position used by next() to the beginning of the data returned by data(). This is useful if you want to use the input source for more than one parse. \sa next() */ void TQXmlInputSource::reset() { nextReturnedEndOfData = FALSE; pos = 0; } /*! Returns the data the input source contains or TQString::null if the input source does not contain any data. \sa setData() TQXmlInputSource() fetchData() */ TQString TQXmlInputSource::data() { return str; } /*! Sets the data of the input source to \a dat. If the input source already contains data, this function deletes that data first. \sa data() */ void TQXmlInputSource::setData( const TQString& dat ) { str = dat; unicode = str.unicode(); pos = 0; length = str.length(); nextReturnedEndOfData = FALSE; } /*! \overload The data \a dat is passed through the correct text-codec, before it is set. */ void TQXmlInputSource::setData( const TQByteArray& dat ) { setData( fromRawData( dat ) ); } /*! This function reads more data from the device that was set during construction. If the input source already contained data, this function deletes that data first. This object contains no data after a call to this function if the object was constructed without a device to read data from or if this function was not able to get more data from the device. There are two occasions where a fetch is done implicitly by another function call: during construction (so that the object starts out with some initial data where available), and during a call to next() (if the data had run out). You don't normally need to use this function if you use next(). \sa data() next() TQXmlInputSource() */ void TQXmlInputSource::fetchData() { TQByteArray rawData; if ( inputDevice != 0 ) { if ( inputDevice->isOpen() || inputDevice->open( IO_ReadOnly ) ) rawData = inputDevice->readAll(); } else if ( inputStream != 0 ) { if ( inputStream->device()->isDirectAccess() ) { rawData = inputStream->device()->readAll(); } else { int nread = 0; const int bufsize = 512; while ( !inputStream->device()->atEnd() ) { rawData.resize( nread + bufsize ); nread += inputStream->device()->readBlock( rawData.data()+nread, bufsize ); } rawData.resize( nread ); } } setData( fromRawData( rawData ) ); } /*! This function reads the XML file from \a data and tries to recognize the encoding. It converts the raw data \a data into a TQString and returns it. It tries its best to get the correct encoding for the XML file. If \a beginning is TRUE, this function assumes that the data starts at the beginning of a new XML document and looks for an encoding declaration. If \a beginning is FALSE, it converts the raw data using the encoding determined from prior calls. */ TQString TQXmlInputSource::fromRawData( const TQByteArray &data, bool beginning ) { if ( data.size() == 0 ) return TQString::null; if ( beginning ) { delete encMapper; encMapper = 0; } if ( encMapper == 0 ) { TQTextCodec *codec = 0; // look for byte order mark and read the first 5 characters if ( data.size() >= 2 && ( ((uchar)data.at(0)==(uchar)0xfe && (uchar)data.at(1)==(uchar)0xff ) || ((uchar)data.at(0)==(uchar)0xff && (uchar)data.at(1)==(uchar)0xfe ) )) { codec = TQTextCodec::codecForMib( 1000 ); // UTF-16 } else { codec = TQTextCodec::codecForMib( 106 ); // UTF-8 } if ( !codec ) return TQString::null; encMapper = codec->makeDecoder(); TQString input = encMapper->toUnicode( data.data(), data.size() ); // ### unexpected EOF? (for incremental parsing) // starts the document with an XML declaration? if ( input.find("" ); int pos = input.find( "encoding" ); if ( pos < endPos && pos != -1 ) { TQString encoding; do { pos++; if ( pos > endPos ) { return input; } } while( input[pos] != '"' && input[pos] != '\'' ); pos++; while( input[pos] != '"' && input[pos] != '\'' ) { encoding += input[pos]; pos++; if ( pos > endPos ) { return input; } } codec = TQTextCodec::codecForName( encoding ); if ( codec == 0 ) { return input; } delete encMapper; encMapper = codec->makeDecoder(); return encMapper->toUnicode( data.data(), data.size() ); } } return input; } return encMapper->toUnicode( data.data(), data.size() ); } /********************************************* * * TQXmlDefaultHandler * *********************************************/ /*! \class TQXmlContentHandler ntqxml.h \reentrant \brief The TQXmlContentHandler class provides an interface to report the logical content of XML data. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools If the application needs to be informed of basic parsing events, it can implement this interface and activate it using TQXmlReader::setContentHandler(). The reader can then report basic document-related events like the start and end of elements and character data through this interface. The order of events in this interface is very important, and mirrors the order of information in the document itself. For example, all of an element's content (character data, processing instructions, and sub-elements) appears, in order, between the startElement() event and the corresponding endElement() event. The class TQXmlDefaultHandler provides a default implementation for this interface; subclassing from the TQXmlDefaultHandler class is very convenient if you only want to be informed of some parsing events. The startDocument() function is called at the start of the document, and endDocument() is called at the end. Before parsing begins setDocumentLocator() is called. For each element startElement() is called, with endElement() being called at the end of each element. The characters() function is called with chunks of character data; ignorableWhitespace() is called with chunks of whitespace and processingInstruction() is called with processing instructions. If an entity is skipped skippedEntity() is called. At the beginning of prefix-URI scopes startPrefixMapping() is called. See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlEntityResolver TQXmlErrorHandler TQXmlLexicalHandler */ /*! \fn void TQXmlContentHandler::setDocumentLocator( TQXmlLocator* locator ) The reader calls this function before it starts parsing the document. The argument \a locator is a pointer to a TQXmlLocator which allows the application to get the parsing position within the document. Do not destroy the \a locator; it is destroyed when the reader is destroyed. (Do not use the \a locator after the reader is destroyed). */ /*! \fn bool TQXmlContentHandler::startDocument() The reader calls this function when it starts parsing the document. The reader calls this function just once, after the call to setDocumentLocator(), and before any other functions in this class or in the TQXmlDTDHandler class are called. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa endDocument() */ /*! \fn bool TQXmlContentHandler::endDocument() The reader calls this function after it has finished parsing. It is called just once, and is the last handler function called. It is called after the reader has read all input or has abandoned parsing because of a fatal error. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa startDocument() */ /*! \fn bool TQXmlContentHandler::startPrefixMapping( const TQString& prefix, const TQString& uri ) The reader calls this function to signal the begin of a prefix-URI namespace mapping scope. This information is not necessary for normal namespace processing since the reader automatically replaces prefixes for element and attribute names. Note that startPrefixMapping() and endPrefixMapping() calls are not guaranteed to be properly nested relative to each other: all startPrefixMapping() events occur before the corresponding startElement() event, and all endPrefixMapping() events occur after the corresponding endElement() event, but their order is not otherwise guaranteed. The argument \a prefix is the namespace prefix being declared and the argument \a uri is the namespace URI the prefix is mapped to. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. See also the \link xml.html#sax2Namespaces namespace description\endlink. \sa endPrefixMapping() */ /*! \fn bool TQXmlContentHandler::endPrefixMapping( const TQString& prefix ) The reader calls this function to signal the end of a prefix mapping for the prefix \a prefix. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. See also the \link xml.html#sax2Namespaces namespace description\endlink. \sa startPrefixMapping() */ /*! \fn bool TQXmlContentHandler::startElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName, const TQXmlAttributes& atts ) The reader calls this function when it has parsed a start element tag. There is a corresponding endElement() call when the corresponding end element tag is read. The startElement() and endElement() calls are always nested correctly. Empty element tags (e.g. \c{}) cause a startElement() call to be immediately followed by an endElement() call. The attribute list provided only contains attributes with explicit values. The attribute list contains attributes used for namespace declaration (i.e. attributes starting with xmlns) only if the namespace-prefix property of the reader is TRUE. The argument \a namespaceURI is the namespace URI, or TQString::null if the element has no namespace URI or if no namespace processing is done. \a localName is the local name (without prefix), or TQString::null if no namespace processing is done, \a qName is the qualified name (with prefix) and \a atts are the attributes attached to the element. If there are no attributes, \a atts is an empty attributes object. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. See also the \link xml.html#sax2Namespaces namespace description\endlink. \sa endElement() */ /*! \fn bool TQXmlContentHandler::endElement( const TQString& namespaceURI, const TQString& localName, const TQString& qName ) The reader calls this function when it has parsed an end element tag with the qualified name \a qName, the local name \a localName and the namespace URI \a namespaceURI. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. See also the \link xml.html#sax2Namespaces namespace description\endlink. \sa startElement() */ /*! \fn bool TQXmlContentHandler::characters( const TQString& ch ) The reader calls this function when it has parsed a chunk of character data (either normal character data or character data inside a CDATA section; if you need to distinguish between those two types you must use TQXmlLexicalHandler::startCDATA() and TQXmlLexicalHandler::endCDATA()). The character data is reported in \a ch. Some readers report whitespace in element content using the ignorableWhitespace() function rather than using this one. A reader may report the character data of an element in more than one chunk; e.g. a reader might want to report "a\TQt Enterprise Edition. \endif \module XML \ingroup xml-tools If you want your application to report errors to the user or to perform customized error handling, you should subclass this class. You can set the error handler with TQXmlReader::setErrorHandler(). Errors can be reported using warning(), error() and fatalError(), with the error text being reported with errorString(). See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver TQXmlLexicalHandler */ /*! \fn bool TQXmlErrorHandler::warning( const TQXmlParseException& exception ) A reader might use this function to report a warning. Warnings are conditions that are not errors or fatal errors as defined by the XML 1.0 specification. Details of the warning are stored in \a exception. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn bool TQXmlErrorHandler::error( const TQXmlParseException& exception ) A reader might use this function to report a recoverable error. A recoverable error corresponds to the definiton of "error" in section 1.2 of the XML 1.0 specification. Details of the error are stored in \a exception. The reader must continue to provide normal parsing events after invoking this function. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn bool TQXmlErrorHandler::fatalError( const TQXmlParseException& exception ) A reader must use this function to report a non-recoverable error. Details of the error are stored in \a exception. If this function returns TRUE the reader might try to go on parsing and reporting further errors; but no regular parsing events are reported. */ /*! \fn TQString TQXmlErrorHandler::errorString() The reader calls this function to get an error string if any of the handler functions returns FALSE. */ /*! \class TQXmlDTDHandler ntqxml.h \reentrant \brief The TQXmlDTDHandler class provides an interface to report DTD content of XML data. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools If an application needs information about notations and unparsed entities, it can implement this interface and register an instance with TQXmlReader::setDTDHandler(). Note that this interface includes only those DTD events that the XML recommendation requires processors to report, i.e. notation and unparsed entity declarations using notationDecl() and unparsedEntityDecl() respectively. See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler TQXmlLexicalHandler */ /*! \fn bool TQXmlDTDHandler::notationDecl( const TQString& name, const TQString& publicId, const TQString& systemId ) The reader calls this function when it has parsed a notation declaration. The argument \a name is the notation name, \a publicId is the notation's public identifier and \a systemId is the notation's system identifier. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn bool TQXmlDTDHandler::unparsedEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId, const TQString& notationName ) The reader calls this function when it finds an unparsed entity declaration. The argument \a name is the unparsed entity's name, \a publicId is the entity's public identifier, \a systemId is the entity's system identifier and \a notationName is the name of the associated notation. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn TQString TQXmlDTDHandler::errorString() The reader calls this function to get an error string if any of the handler functions returns FALSE. */ /*! \class TQXmlEntityResolver ntqxml.h \reentrant \brief The TQXmlEntityResolver class provides an interface to resolve external entities contained in XML data. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools If an application needs to implement customized handling for external entities, it must implement this interface, i.e. resolveEntity(), and register it with TQXmlReader::setEntityResolver(). See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlErrorHandler TQXmlLexicalHandler */ /*! \fn bool TQXmlEntityResolver::resolveEntity( const TQString& publicId, const TQString& systemId, TQXmlInputSource*& ret ) The reader calls this function before it opens any external entity, except the top-level document entity. The application may request the reader to resolve the entity itself (\a ret is 0) or to use an entirely different input source (\a ret points to the input source). The reader deletes the input source \a ret when it no longer needs it, so you should allocate it on the heap with \c new. The argument \a publicId is the public identifier of the external entity, \a systemId is the system identifier of the external entity and \a ret is the return value of this function. If \a ret is 0 the reader should resolve the entity itself, if it is non-zero it must point to an input source which the reader uses instead. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn TQString TQXmlEntityResolver::errorString() The reader calls this function to get an error string if any of the handler functions returns FALSE. */ /*! \class TQXmlLexicalHandler ntqxml.h \reentrant \brief The TQXmlLexicalHandler class provides an interface to report the lexical content of XML data. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools The events in the lexical handler apply to the entire document, not just to the document element, and all lexical handler events appear between the content handler's startDocument and endDocument events. You can set the lexical handler with TQXmlReader::setLexicalHandler(). This interface's design is based on the the SAX2 extension LexicalHandler. The interface provides the startDTD(), endDTD(), startEntity(), endEntity(), startCDATA(), endCDATA() and comment() functions. See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler */ /*! \fn bool TQXmlLexicalHandler::startDTD( const TQString& name, const TQString& publicId, const TQString& systemId ) The reader calls this function to report the start of a DTD declaration, if any. It reports the name of the document type in \a name, the public identifier in \a publicId and the system identifier in \a systemId. If the public identifier is missing, \a publicId is set to TQString::null. If the system identifier is missing, \a systemId is set to TQString::null. Note that it is not valid XML to have a public identifier but no system identifier; in such cases a parse error will occur. All declarations reported through TQXmlDTDHandler or TQXmlDeclHandler appear between the startDTD() and endDTD() calls. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa endDTD() */ /*! \fn bool TQXmlLexicalHandler::endDTD() The reader calls this function to report the end of a DTD declaration, if any. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa startDTD() */ /*! \fn bool TQXmlLexicalHandler::startEntity( const TQString& name ) The reader calls this function to report the start of an entity called \a name. Note that if the entity is unknown, the reader reports it through TQXmlContentHandler::skippedEntity() and not through this function. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa endEntity() TQXmlSimpleReader::setFeature() */ /*! \fn bool TQXmlLexicalHandler::endEntity( const TQString& name ) The reader calls this function to report the end of an entity called \a name. For every startEntity() call, there is a corresponding endEntity() call. The calls to startEntity() and endEntity() are properly nested. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa startEntity() TQXmlContentHandler::skippedEntity() TQXmlSimpleReader::setFeature() */ /*! \fn bool TQXmlLexicalHandler::startCDATA() The reader calls this function to report the start of a CDATA section. The content of the CDATA section is reported through the TQXmlContentHandler::characters() function. This function is intended only to report the boundary. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa endCDATA() */ /*! \fn bool TQXmlLexicalHandler::endCDATA() The reader calls this function to report the end of a CDATA section. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. \sa startCDATA() TQXmlContentHandler::characters() */ /*! \fn bool TQXmlLexicalHandler::comment( const TQString& ch ) The reader calls this function to report an XML comment anywhere in the document. It reports the text of the comment in \a ch. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn TQString TQXmlLexicalHandler::errorString() The reader calls this function to get an error string if any of the handler functions returns FALSE. */ /*! \class TQXmlDeclHandler ntqxml.h \reentrant \brief The TQXmlDeclHandler class provides an interface to report declaration content of XML data. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools You can set the declaration handler with TQXmlReader::setDeclHandler(). This interface is based on the SAX2 extension DeclHandler. The interface provides attributeDecl(), internalEntityDecl() and externalEntityDecl() functions. See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler TQXmlLexicalHandler */ /*! \fn bool TQXmlDeclHandler::attributeDecl( const TQString& eName, const TQString& aName, const TQString& type, const TQString& valueDefault, const TQString& value ) The reader calls this function to report an attribute type declaration. Only the effective (first) declaration for an attribute is reported. The reader passes the name of the associated element in \a eName and the name of the attribute in \a aName. It passes a string that represents the attribute type in \a type and a string that represents the attribute default in \a valueDefault. This string is one of "#IMPLIED", "#REQUIRED", "#FIXED" or TQString::null (if none of the others applies). The reader passes the attribute's default value in \a value. If no default value is specified in the XML file, \a value is TQString::null. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn bool TQXmlDeclHandler::internalEntityDecl( const TQString& name, const TQString& value ) The reader calls this function to report an internal entity declaration. Only the effective (first) declaration is reported. The reader passes the name of the entity in \a name and the value of the entity in \a value. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn bool TQXmlDeclHandler::externalEntityDecl( const TQString& name, const TQString& publicId, const TQString& systemId ) The reader calls this function to report a parsed external entity declaration. Only the effective (first) declaration for each entity is reported. The reader passes the name of the entity in \a name, the public identifier in \a publicId and the system identifier in \a systemId. If there is no public identifier specified, it passes TQString::null in \a publicId. If this function returns FALSE the reader stops parsing and reports an error. The reader uses the function errorString() to get the error message. */ /*! \fn TQString TQXmlDeclHandler::errorString() The reader calls this function to get an error string if any of the handler functions returns FALSE. */ /*! \class TQXmlDefaultHandler ntqxml.h \reentrant \brief The TQXmlDefaultHandler class provides a default implementation of all the XML handler classes. \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools Very often we are only interested in parts of the things that the reader reports. This class implements a default behaviour for the handler classes (i.e. most of the time do nothing). Usually this is the class you subclass for implementing your own customized handler. See also the \link xml.html#sax2Intro Introduction to SAX2\endlink. \sa TQXmlDTDHandler TQXmlDeclHandler TQXmlContentHandler TQXmlEntityResolver TQXmlErrorHandler TQXmlLexicalHandler */ /*! \fn TQXmlDefaultHandler::TQXmlDefaultHandler() Constructor. */ /*! \fn TQXmlDefaultHandler::~TQXmlDefaultHandler() Destructor. */ /*! \reimp Does nothing. */ void TQXmlDefaultHandler::setDocumentLocator( TQXmlLocator* ) { } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startDocument() { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endDocument() { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startPrefixMapping( const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endPrefixMapping( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startElement( const TQString&, const TQString&, const TQString&, const TQXmlAttributes& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endElement( const TQString&, const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::characters( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::ignorableWhitespace( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::processingInstruction( const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::skippedEntity( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::warning( const TQXmlParseException& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::error( const TQXmlParseException& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::fatalError( const TQXmlParseException& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::notationDecl( const TQString&, const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::unparsedEntityDecl( const TQString&, const TQString&, const TQString&, const TQString& ) { return TRUE; } /*! \reimp Sets \a ret to 0, so that the reader uses the system identifier provided in the XML document. */ bool TQXmlDefaultHandler::resolveEntity( const TQString&, const TQString&, TQXmlInputSource*& ret ) { ret = 0; return TRUE; } /*! \reimp Returns the default error string. */ TQString TQXmlDefaultHandler::errorString() { return TQString( XMLERR_ERRORBYCONSUMER ); } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startDTD( const TQString&, const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endDTD() { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startEntity( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endEntity( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::startCDATA() { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::endCDATA() { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::comment( const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::attributeDecl( const TQString&, const TQString&, const TQString&, const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::internalEntityDecl( const TQString&, const TQString& ) { return TRUE; } /*! \reimp Does nothing. */ bool TQXmlDefaultHandler::externalEntityDecl( const TQString&, const TQString&, const TQString& ) { return TRUE; } /********************************************* * * TQXmlSimpleReaderPrivate * *********************************************/ class TQXmlSimpleReaderPrivate { private: // functions inline TQXmlSimpleReaderPrivate() { parseStack = 0; undefEntityInAttrHack = FALSE; } inline ~TQXmlSimpleReaderPrivate() { delete parseStack; } inline void initIncrementalParsing() { delete parseStack; parseStack = new TQValueStack; } // used to determine if elements are correctly nested TQValueStack tags; // used for entity declarations struct ExternParameterEntity { ExternParameterEntity( ) {} ExternParameterEntity( const TQString &p, const TQString &s ) : publicId(p), systemId(s) {} TQString publicId; TQString systemId; Q_DUMMY_COMPARISON_OPERATOR(ExternParameterEntity) }; struct ExternEntity { ExternEntity( ) {} ExternEntity( const TQString &p, const TQString &s, const TQString &n ) : publicId(p), systemId(s), notation(n) {} TQString publicId; TQString systemId; TQString notation; Q_DUMMY_COMPARISON_OPERATOR(ExternEntity) }; TQMap externParameterEntities; TQMap parameterEntities; TQMap externEntities; TQMap entities; // used for parsing of entity references TQValueStack xmlRef; TQValueStack xmlRefName; // used for standalone declaration enum Standalone { Yes, No, Unknown }; TQString doctype; // only used for the doctype TQString xmlVersion; // only used to store the version information TQString encoding; // only used to store the encoding Standalone standalone; // used to store the value of the standalone declaration TQString publicId; // used by parseExternalID() to store the public ID TQString systemId; // used by parseExternalID() to store the system ID TQString attDeclEName; // use by parseAttlistDecl() TQString attDeclAName; // use by parseAttlistDecl() // flags for some features support bool useNamespaces; bool useNamespacePrefixes; bool reportWhitespaceCharData; bool reportEntities; // used to build the attribute list TQXmlAttributes attList; // used in TQXmlSimpleReader::parseContent() to decide whether character // data was read bool contentCharDataRead; // helper classes TQXmlLocator *locator; TQXmlNamespaceSupport namespaceSupport; // error string TQString error; // arguments for parse functions (this is needed to allow incremental // parsing) bool parsePI_xmldecl; bool parseName_useRef; bool parseReference_charDataRead; TQXmlSimpleReader::EntityRecognitionContext parseReference_context; bool parseExternalID_allowPublicID; TQXmlSimpleReader::EntityRecognitionContext parsePEReference_context; TQString parseString_s; // for incremental parsing struct ParseState { typedef bool (TQXmlSimpleReader::*ParseFunction) (); ParseFunction function; int state; }; TQValueStack *parseStack; // used in parseProlog() bool xmldecl_possible; bool doctype_read; // used in parseDoctype() bool startDTDwasReported; // used in parseString() signed char Done; bool undefEntityInAttrHack; int nameValueLen; int refValueLen; int stringValueLen; // friend declarations friend class TQXmlSimpleReader; }; /********************************************* * * TQXmlSimpleReader * *********************************************/ /*! \class TQXmlReader ntqxml.h \reentrant \brief The TQXmlReader class provides an interface for XML readers (i.e. parsers). \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools This abstract class provides an interface for all of TQt's XML readers. Currently there is only one implementation of a reader included in TQt's XML module: TQXmlSimpleReader. In future releases there might be more readers with different properties available (e.g. a validating parser). The design of the XML classes follows the \link http://www.saxproject.org/ SAX2 Java interface\endlink, with the names adapted to fit TQt naming conventions. It should be very easy for anybody who has worked with SAX2 to get started with the TQt XML classes. All readers use the class TQXmlInputSource to read the input document. Since you are normally interested in particular content in the XML document, the reader reports the content through special handler classes (TQXmlDTDHandler, TQXmlDeclHandler, TQXmlContentHandler, TQXmlEntityResolver, TQXmlErrorHandler and TQXmlLexicalHandler), which you must subclass, if you want to process the contents. Since the handler classes only describe interfaces you must implement all the functions. We provide the TQXmlDefaultHandler class to make this easier: it implements a default behaviour (do nothing) for all functions, so you can subclass it and just implement the functions you are interested in. Features and properties of the reader can be set with setFeature() and setProperty() respectively. You can set the reader to use your own subclasses with setEntityResolver(), setDTDHandler(), setContentHandler(), setErrorHandler(), setLexicalHandler() and setDeclHandler(). The parse itself is started with a call to parse(). \sa TQXmlSimpleReader */ /*! \fn bool TQXmlReader::feature( const TQString& name, bool *ok ) const If the reader has the feature called \a name, the feature's value is returned. If no such feature exists the return value is undefined. If \a ok is not 0: \a *ok is set to TRUE if the reader has the feature called \a name; otherwise \a *ok is set to FALSE. \sa setFeature() hasFeature() */ /*! \fn void TQXmlReader::setFeature( const TQString& name, bool value ) Sets the feature called \a name to the given \a value. If the reader doesn't have the feature nothing happens. \sa feature() hasFeature() */ /*! \fn bool TQXmlReader::hasFeature( const TQString& name ) const Returns \c TRUE if the reader has the feature called \a name; otherwise returns FALSE. \sa feature() setFeature() */ /*! \fn void* TQXmlReader::property( const TQString& name, bool *ok ) const If the reader has the property \a name, this function returns the value of the property; otherwise the return value is undefined. If \a ok is not 0: if the reader has the \a name property \a *ok is set to TRUE; otherwise \a *ok is set to FALSE. \sa setProperty() hasProperty() */ /*! \fn void TQXmlReader::setProperty( const TQString& name, void* value ) Sets the property \a name to \a value. If the reader doesn't have the property nothing happens. \sa property() hasProperty() */ /*! \fn bool TQXmlReader::hasProperty( const TQString& name ) const Returns TRUE if the reader has the property \a name; otherwise returns FALSE. \sa property() setProperty() */ /*! \fn void TQXmlReader::setEntityResolver( TQXmlEntityResolver* handler ) Sets the entity resolver to \a handler. \sa entityResolver() */ /*! \fn TQXmlEntityResolver* TQXmlReader::entityResolver() const Returns the entity resolver or 0 if none was set. \sa setEntityResolver() */ /*! \fn void TQXmlReader::setDTDHandler( TQXmlDTDHandler* handler ) Sets the DTD handler to \a handler. \sa DTDHandler() */ /*! \fn TQXmlDTDHandler* TQXmlReader::DTDHandler() const Returns the DTD handler or 0 if none was set. \sa setDTDHandler() */ /*! \fn void TQXmlReader::setContentHandler( TQXmlContentHandler* handler ) Sets the content handler to \a handler. \sa contentHandler() */ /*! \fn TQXmlContentHandler* TQXmlReader::contentHandler() const Returns the content handler or 0 if none was set. \sa setContentHandler() */ /*! \fn void TQXmlReader::setErrorHandler( TQXmlErrorHandler* handler ) Sets the error handler to \a handler. Clears the error handler if \a handler is 0. \sa errorHandler() */ /*! \fn TQXmlErrorHandler* TQXmlReader::errorHandler() const Returns the error handler or 0 if none is set. \sa setErrorHandler() */ /*! \fn void TQXmlReader::setLexicalHandler( TQXmlLexicalHandler* handler ) Sets the lexical handler to \a handler. \sa lexicalHandler() */ /*! \fn TQXmlLexicalHandler* TQXmlReader::lexicalHandler() const Returns the lexical handler or 0 if none was set. \sa setLexicalHandler() */ /*! \fn void TQXmlReader::setDeclHandler( TQXmlDeclHandler* handler ) Sets the declaration handler to \a handler. \sa declHandler() */ /*! \fn TQXmlDeclHandler* TQXmlReader::declHandler() const Returns the declaration handler or 0 if none was set. \sa setDeclHandler() */ /*! \fn bool TQXmlReader::parse( const TQXmlInputSource& input ) \obsolete */ /*! \fn bool TQXmlReader::parse( const TQXmlInputSource* input ) Reads an XML document from \a input and parses it. Returns TRUE if the parsing was successful; otherwise returns FALSE. */ /*! \class TQXmlSimpleReader ntqxml.h \reentrant \brief The TQXmlSimpleReader class provides an implementation of a simple XML reader (parser). \if defined(commercial) It is part of the TQt Enterprise Edition. \endif \module XML \ingroup xml-tools \mainclass This XML reader is sufficient for simple parsing tasks. The reader: \list \i provides a well-formed parser; \i does not parse any external entities; \i can do namespace processing. \endlist Documents are parsed with a call to parse(). */ static inline bool is_S(TQChar ch) { ushort uc = ch.unicode(); return (uc == ' ' || uc == '\t' || uc == '\n' || uc == '\r'); } enum NameChar { NameBeginning, NameNotBeginning, NotName }; static const char Begi = (char)NameBeginning; static const char NtBg = (char)NameNotBeginning; static const char NotN = (char)NotName; static const char nameCharTable[128] = { // 0x00 NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, // 0x10 NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, // 0x20 (0x2D is '-', 0x2E is '.') NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NotN, NtBg, NtBg, NotN, // 0x30 (0x30..0x39 are '0'..'9', 0x3A is ':') NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, NtBg, Begi, NotN, NotN, NotN, NotN, NotN, // 0x40 (0x41..0x5A are 'A'..'Z') NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, // 0x50 (0x5F is '_') Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, NotN, NotN, NotN, NotN, Begi, // 0x60 (0x61..0x7A are 'a'..'z') NotN, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, // 0x70 Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, Begi, NotN, NotN, NotN, NotN, NotN }; static inline NameChar fastDetermineNameChar(TQChar ch) { ushort uc = ch.unicode(); if (!(uc & ~0x7f)) // uc < 128 return (NameChar)nameCharTable[uc]; TQChar::Category cat = ch.category(); // ### some these categories might be slightly wrong if ((cat >= TQChar::Letter_Uppercase && cat <= TQChar::Letter_Other) || cat == TQChar::Number_Letter) return NameBeginning; if ((cat >= TQChar::Number_DecimalDigit && cat <= TQChar::Number_Other) || (cat >= TQChar::Mark_NonSpacing && cat <= TQChar::Mark_Enclosing)) return NameNotBeginning; return NotName; } static NameChar determineNameChar(TQChar ch) { return fastDetermineNameChar(ch); } inline void TQXmlSimpleReader::nameClear() { d->nameValueLen = 0; nameArrayPos = 0; } inline void TQXmlSimpleReader::refClear() { d->refValueLen = 0; refArrayPos = 0; } /*! Constructs a simple XML reader with the following feature settings: \table \header \i Feature \i Setting \row \i \e http://xml.org/sax/features/namespaces \i TRUE \row \i \e http://xml.org/sax/features/namespace-prefixes \i FALSE \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData \i TRUE \row \i \e http://trolltech.com/xml/features/report-start-end-entity \i FALSE \endtable More information about features can be found in the \link xml.html#sax2Features TQt SAX2 overview. \endlink \sa setFeature() */ TQXmlSimpleReader::TQXmlSimpleReader() { d = new TQXmlSimpleReaderPrivate(); d->locator = new TQXmlSimpleReaderLocator( this ); entityRes = 0; dtdHnd = 0; contentHnd = 0; errorHnd = 0; lexicalHnd = 0; declHnd = 0; // default feature settings d->useNamespaces = TRUE; d->useNamespacePrefixes = FALSE; d->reportWhitespaceCharData = TRUE; d->reportEntities = FALSE; } /*! Destroys the simple XML reader. */ TQXmlSimpleReader::~TQXmlSimpleReader() { delete d->locator; delete d; } /*! \reimp */ bool TQXmlSimpleReader::feature( const TQString& name, bool *ok ) const { if ( ok != 0 ) *ok = TRUE; if ( name == "http://xml.org/sax/features/namespaces" ) { return d->useNamespaces; } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) { return d->useNamespacePrefixes; } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) { return d->reportWhitespaceCharData; } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) { return d->reportEntities; } else { tqWarning( "Unknown feature %s", name.latin1() ); if ( ok != 0 ) *ok = FALSE; } return FALSE; } /*! Sets the state of the feature \a name to \a value: If the feature is not recognized, it is ignored. The following features are supported: \table \header \i Feature \i Notes \row \i \e http://xml.org/sax/features/namespaces \i If this feature is TRUE, namespace processing is performed. \row \i \e http://xml.org/sax/features/namespace-prefixes \i If this feature is TRUE, the the original prefixed names and attributes used for namespace declarations are reported. \row \i \e http://trolltech.com/xml/features/report-whitespace-only-CharData \i If this feature is TRUE, CharData that only contain whitespace are not ignored, but are reported via TQXmlContentHandler::characters(). \row \i \e http://trolltech.com/xml/features/report-start-end-entity \i If this feature is TRUE, the parser reports TQXmlContentHandler::startEntity() and TQXmlContentHandler::endEntity() events. So character data might be reported in chunks. If this feature is FALSE, the parser does not report those events, but rather silently substitutes the entities and reports the character data in one chunk. \endtable \quotefile xml/tagreader-with-features/tagreader.cpp \skipto reader \printline reader \skipto setFeature \printline setFeature \printline TRUE (Code taken from xml/tagreader-with-features/tagreader.cpp) \sa feature() hasFeature() */ void TQXmlSimpleReader::setFeature( const TQString& name, bool value ) { if ( name == "http://xml.org/sax/features/namespaces" ) { d->useNamespaces = value; } else if ( name == "http://xml.org/sax/features/namespace-prefixes" ) { d->useNamespacePrefixes = value; } else if ( name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" ) { d->reportWhitespaceCharData = value; } else if ( name == "http://trolltech.com/xml/features/report-start-end-entity" ) { d->reportEntities = value; } else { tqWarning( "Unknown feature %s", name.latin1() ); } } /*! \reimp */ bool TQXmlSimpleReader::hasFeature( const TQString& name ) const { if ( name == "http://xml.org/sax/features/namespaces" || name == "http://xml.org/sax/features/namespace-prefixes" || name == "http://trolltech.com/xml/features/report-whitespace-only-CharData" || name == "http://trolltech.com/xml/features/report-start-end-entity" ) { return TRUE; } else { return FALSE; } } /*! \reimp */ void* TQXmlSimpleReader::property( const TQString&, bool *ok ) const { if ( ok != 0 ) *ok = FALSE; return 0; } /*! \reimp */ void TQXmlSimpleReader::setProperty( const TQString&, void* ) { } /*! \reimp */ bool TQXmlSimpleReader::hasProperty( const TQString& ) const { return FALSE; } /*! \reimp */ void TQXmlSimpleReader::setEntityResolver( TQXmlEntityResolver* handler ) { entityRes = handler; } /*! \reimp */ TQXmlEntityResolver* TQXmlSimpleReader::entityResolver() const { return entityRes; } /*! \reimp */ void TQXmlSimpleReader::setDTDHandler( TQXmlDTDHandler* handler ) { dtdHnd = handler; } /*! \reimp */ TQXmlDTDHandler* TQXmlSimpleReader::DTDHandler() const { return dtdHnd; } /*! \reimp */ void TQXmlSimpleReader::setContentHandler( TQXmlContentHandler* handler ) { contentHnd = handler; } /*! \reimp */ TQXmlContentHandler* TQXmlSimpleReader::contentHandler() const { return contentHnd; } /*! \reimp */ void TQXmlSimpleReader::setErrorHandler( TQXmlErrorHandler* handler ) { errorHnd = handler; } /*! \reimp */ TQXmlErrorHandler* TQXmlSimpleReader::errorHandler() const { return errorHnd; } /*! \reimp */ void TQXmlSimpleReader::setLexicalHandler( TQXmlLexicalHandler* handler ) { lexicalHnd = handler; } /*! \reimp */ TQXmlLexicalHandler* TQXmlSimpleReader::lexicalHandler() const { return lexicalHnd; } /*! \reimp */ void TQXmlSimpleReader::setDeclHandler( TQXmlDeclHandler* handler ) { declHnd = handler; } /*! \reimp */ TQXmlDeclHandler* TQXmlSimpleReader::declHandler() const { return declHnd; } /*! \reimp */ bool TQXmlSimpleReader::parse( const TQXmlInputSource& input ) { return parse( &input, FALSE ); } /*! \reimp */ bool TQXmlSimpleReader::parse( const TQXmlInputSource* input ) { return parse( input, FALSE ); } /*! Reads an XML document from \a input and parses it. Returns FALSE if the parsing detects an error; otherwise returns TRUE. If \a incremental is TRUE, the parser does not return FALSE when it reaches the end of the \a input without reaching the end of the XML file. Instead it stores the state of the parser so that parsing can be continued at a later stage when more data is available. You can use the function parseContinue() to continue with parsing. This class stores a pointer to the input source \a input and the parseContinue() function tries to read from that input souce. This means that you should not delete the input source \a input until you've finished your calls to parseContinue(). If you call this function with \a incremental TRUE whilst an incremental parse is in progress a new parsing session will be started and the previous session lost. If \a incremental is FALSE, this function behaves like the normal parse function, i.e. it returns FALSE when the end of input is reached without reaching the end of the XML file and the parsing cannot be continued. \sa parseContinue() TQSocket */ bool TQXmlSimpleReader::parse( const TQXmlInputSource *input, bool incremental ) { init( input ); if ( incremental ) { d->initIncrementalParsing(); } else { delete d->parseStack; d->parseStack = 0; } // call the handler if ( contentHnd ) { contentHnd->setDocumentLocator( d->locator ); if ( !contentHnd->startDocument() ) { reportParseError( contentHnd->errorString() ); d->tags.clear(); return FALSE; } } return parseBeginOrContinue( 0, incremental ); } /*! Continues incremental parsing; this function reads the input from the TQXmlInputSource that was specified with the last parse() command. To use this function, you \e must have called parse() with the incremental argument set to TRUE. Returns FALSE if a parsing error occurs; otherwise returns TRUE. If the input source returns an empty string for the function TQXmlInputSource::data(), then this means that the end of the XML file has been reached; this is quite important, especially if you want to use the reader to parse more than one XML file. The case of the end of the XML file being reached without having finished parsing is not considered to be an error: you can continue parsing at a later stage by calling this function again when there is more data available to parse. This function assumes that the end of the XML document is reached if the TQXmlInputSource::next() function returns TQXmlInputSource::EndOfDocument. If the parser has not finished parsing when it encounters this symbol, it is an error and FALSE is returned. \sa parse() TQXmlInputSource::next() */ bool TQXmlSimpleReader::parseContinue() { if ( d->parseStack == 0 || d->parseStack->isEmpty() ) return FALSE; initData(); int state = d->parseStack->pop().state; return parseBeginOrContinue( state, TRUE ); } /* Common part of parse() and parseContinue() */ bool TQXmlSimpleReader::parseBeginOrContinue( int state, bool incremental ) { bool atEndOrig = atEnd(); if ( state==0 ) { if ( !parseProlog() ) { if ( incremental && d->error.isNull() ) { pushParseState( 0, 0 ); return TRUE; } else { d->tags.clear(); return FALSE; } } state = 1; } if ( state==1 ) { if ( !parseElement() ) { if ( incremental && d->error.isNull() ) { pushParseState( 0, 1 ); return TRUE; } else { d->tags.clear(); return FALSE; } } state = 2; } // parse Misc* while ( !atEnd() ) { if ( !parseMisc() ) { if ( incremental && d->error.isNull() ) { pushParseState( 0, 2 ); return TRUE; } else { d->tags.clear(); return FALSE; } } } if ( !atEndOrig && incremental ) { // we parsed something at all, so be prepared to come back later pushParseState( 0, 2 ); return TRUE; } // is stack empty? if ( !d->tags.isEmpty() && !d->error.isNull() ) { reportParseError( XMLERR_UNEXPECTEDEOF ); d->tags.clear(); return FALSE; } // call the handler if ( contentHnd ) { delete d->parseStack; d->parseStack = 0; if ( !contentHnd->endDocument() ) { reportParseError( contentHnd->errorString() ); return FALSE; } } return TRUE; } // // The following private parse functions have another semantics for the return // value: They return TRUE iff parsing has finished successfully (i.e. the end // of the XML file must be reached!). If one of these functions return FALSE, // there is only an error when d->error.isNULL() is also FALSE. // /* For the incremental parsing, it is very important that the parse...() functions have a certain structure. Since it might be hard to understand how they work, here is a description of the layout of these functions: bool TQXmlSimpleReader::parse...() { (1) const signed char Init = 0; ... (2) const signed char Inp... = 0; ... (3) static signed char table[3][2] = { ... }; signed char state; signed char input; (4) if (d->parseStack == 0 || d->parseStack->isEmpty()) { (4a) ... } else { (4b) ... } for ( ; ; ) { (5) switch ( state ) { ... } (6) (6a) if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseNmtoken, state ); return FALSE; } (6b) if (determineNameChar(c) != NotName) { ... } (7) state = table[state][input]; (8) switch ( state ) { ... } } } Explanation: ad 1: constants for the states (used in the transition table) ad 2: constants for the input (used in the transition table) ad 3: the transition table for the state machine ad 4: test if we are in a parseContinue() step a) if no, do inititalizations b) if yes, restore the state and call parse functions recursively ad 5: Do some actions according to the state; from the logical execution order, this code belongs after 8 (see there for an explanation) ad 6: Check the character that is at the actual "cursor" position: a) If we reached the EOF, report either error or push the state (in the case of incremental parsing). b) Otherwise, set the input character constant for the transition table. ad 7: Get the new state according to the input that was read. ad 8: Do some actions according to the state. The last line in every case statement reads new data (i.e. it move the cursor). This can also be done by calling another parse...() funtion. If you need processing for this state after that, you have to put it into the switch statement 5. This ensures that you have a well defined re-entry point, when you ran out of data. */ /* Parses the prolog [22]. */ bool TQXmlSimpleReader::parseProlog() { const signed char Init = 0; const signed char EatWS = 1; // eat white spaces const signed char Lt = 2; // '<' read const signed char Em = 3; // '!' read const signed char DocType = 4; // read doctype const signed char Comment = 5; // read comment const signed char CommentR = 6; // same as Comment, but already reported const signed char PInstr = 7; // read PI const signed char PInstrR = 8; // same as PInstr, but already reported const signed char Done = 9; const signed char InpWs = 0; const signed char InpLt = 1; // < const signed char InpQm = 2; // ? const signed char InpEm = 3; // ! const signed char InpD = 4; // D const signed char InpDash = 5; // - const signed char InpUnknown = 6; static const signed char table[9][7] = { /* InpWs InpLt InpQm InpEm InpD InpDash InpUnknown */ { EatWS, Lt, -1, -1, -1, -1, -1 }, // Init { -1, Lt, -1, -1, -1, -1, -1 }, // EatWS { -1, -1, PInstr,Em, Done, -1, Done }, // Lt { -1, -1, -1, -1, DocType, Comment, -1 }, // Em { EatWS, Lt, -1, -1, -1, -1, -1 }, // DocType { EatWS, Lt, -1, -1, -1, -1, -1 }, // Comment { EatWS, Lt, -1, -1, -1, -1, -1 }, // CommentR { EatWS, Lt, -1, -1, -1, -1, -1 }, // PInstr { EatWS, Lt, -1, -1, -1, -1, -1 } // PInstrR }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->xmldecl_possible = TRUE; d->doctype_read = FALSE; state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseProlog (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } } } for (;;) { switch ( state ) { case DocType: if ( d->doctype_read ) { reportParseError( XMLERR_MORETHANONEDOCTYPE ); return FALSE; } else { d->doctype_read = FALSE; } break; case Comment: if ( lexicalHnd ) { if ( !lexicalHnd->comment( string() ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } state = CommentR; break; case PInstr: // call the handler if ( contentHnd ) { if ( d->xmldecl_possible && !d->xmlVersion.isEmpty() ) { TQString value( "version = '" ); value += d->xmlVersion; value += "'"; if ( !d->encoding.isEmpty() ) { value += " encoding = '"; value += d->encoding; value += "'"; } if ( d->standalone == TQXmlSimpleReaderPrivate::Yes ) { value += " standalone = 'yes'"; } else if ( d->standalone == TQXmlSimpleReaderPrivate::No ) { value += " standalone = 'no'"; } if ( !contentHnd->processingInstruction( "xml", value ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } else { if ( !contentHnd->processingInstruction( name(), string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } // XML declaration only on first position possible d->xmldecl_possible = FALSE; state = PInstrR; break; case Done: return TRUE; case -1: reportParseError( XMLERR_ERRORPARSINGELEMENT ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '<' ) { input = InpLt; } else if ( c.unicode() == '?' ) { input = InpQm; } else if ( c.unicode() == '!' ) { input = InpEm; } else if ( c.unicode() == 'D' ) { input = InpD; } else if ( c.unicode() == '-' ) { input = InpDash; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case EatWS: // XML declaration only on first position possible d->xmldecl_possible = FALSE; if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } break; case Lt: next(); break; case Em: // XML declaration only on first position possible d->xmldecl_possible = FALSE; next(); break; case DocType: if ( !parseDoctype() ) { parseFailed( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } break; case Comment: case CommentR: if ( !parseComment() ) { parseFailed( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } break; case PInstr: case PInstrR: d->parsePI_xmldecl = d->xmldecl_possible; if ( !parsePI() ) { parseFailed( &TQXmlSimpleReader::parseProlog, state ); return FALSE; } break; } } } /* Parse an element [39]. Precondition: the opening '<' is already read. */ bool TQXmlSimpleReader::parseElement() { const int Init = 0; const int ReadName = 1; const int Ws1 = 2; const int STagEnd = 3; const int STagEnd2 = 4; const int ETagBegin = 5; const int ETagBegin2 = 6; const int Ws2 = 7; const int EmptyTag = 8; const int Attrib = 9; const int AttribPro = 10; // like Attrib, but processAttribute was already called const int Ws3 = 11; const int Done = 12; const int InpWs = 0; // whitespace const int InpNameBe = 1; // is_NameBeginning() const int InpGt = 2; // > const int InpSlash = 3; // / const int InpUnknown = 4; static const int table[12][5] = { /* InpWs InpNameBe InpGt InpSlash InpUnknown */ { -1, ReadName, -1, -1, -1 }, // Init { Ws1, Attrib, STagEnd, EmptyTag, -1 }, // ReadName { -1, Attrib, STagEnd, EmptyTag, -1 }, // Ws1 { STagEnd2, STagEnd2, STagEnd2, STagEnd2, STagEnd2 }, // STagEnd { -1, -1, -1, ETagBegin, -1 }, // STagEnd2 { -1, ETagBegin2, -1, -1, -1 }, // ETagBegin { Ws2, -1, Done, -1, -1 }, // ETagBegin2 { -1, -1, Done, -1, -1 }, // Ws2 { -1, -1, Done, -1, -1 }, // EmptyTag { Ws3, Attrib, STagEnd, EmptyTag, -1 }, // Attrib { Ws3, Attrib, STagEnd, EmptyTag, -1 }, // AttribPro { -1, Attrib, STagEnd, EmptyTag, -1 } // Ws3 }; int state; int input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseElement (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } } } for (;;) { switch ( state ) { case ReadName: // store it on the stack d->tags.push( name() ); // empty the attributes d->attList.clear(); if ( d->useNamespaces ) d->namespaceSupport.pushContext(); break; case ETagBegin2: if ( !processElementETagBegin2() ) return FALSE; break; case Attrib: if ( !processElementAttribute() ) return FALSE; state = AttribPro; break; case Done: return TRUE; case -1: reportParseError( XMLERR_ERRORPARSINGELEMENT ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseElement, state ); return FALSE; } if (fastDetermineNameChar(c) == NameBeginning) { input = InpNameBe; } else if ( c.unicode() == '>' ) { input = InpGt; } else if (is_S(c)) { input = InpWs; } else if (c.unicode() == '/') { input = InpSlash; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case ReadName: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } break; case Ws1: case Ws2: case Ws3: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } break; case STagEnd: // call the handler if ( contentHnd ) { const TQString &tagsTop = d->tags.top(); if ( d->useNamespaces ) { TQString uri, lname; d->namespaceSupport.processName(tagsTop, FALSE, uri, lname); if (!contentHnd->startElement(uri, lname, tagsTop, d->attList)) { reportParseError( contentHnd->errorString() ); return FALSE; } } else { if (!contentHnd->startElement(TQString::null, TQString::null, tagsTop, d->attList)) { reportParseError( contentHnd->errorString() ); return FALSE; } } } next(); break; case STagEnd2: if ( !parseContent() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } break; case ETagBegin: next(); break; case ETagBegin2: // get the name of the tag d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } break; case EmptyTag: if ( d->tags.isEmpty() ) { reportParseError( XMLERR_TAGMISMATCH ); return FALSE; } if ( !processElementEmptyTag() ) return FALSE; next(); break; case Attrib: case AttribPro: // get name and value of attribute if ( !parseAttribute() ) { parseFailed( &TQXmlSimpleReader::parseElement, state ); return FALSE; } break; case Done: next(); break; } } } /* Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE. */ bool TQXmlSimpleReader::processElementEmptyTag() { TQString uri, lname; // pop the stack and call the handler if ( contentHnd ) { if ( d->useNamespaces ) { // report startElement first... d->namespaceSupport.processName( d->tags.top(), FALSE, uri, lname ); if ( !contentHnd->startElement( uri, lname, d->tags.top(), d->attList ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } // ... followed by endElement... if ( !contentHnd->endElement( uri, lname, d->tags.pop() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } // ... followed by endPrefixMapping TQStringList prefixesBefore, prefixesAfter; if ( contentHnd ) { prefixesBefore = d->namespaceSupport.prefixes(); } d->namespaceSupport.popContext(); // call the handler for prefix mapping prefixesAfter = d->namespaceSupport.prefixes(); for ( TQStringList::Iterator it = prefixesBefore.begin(); it != prefixesBefore.end(); ++it ) { if ( prefixesAfter.contains(*it) == 0 ) { if ( !contentHnd->endPrefixMapping( *it ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } } else { // report startElement first... if ( !contentHnd->startElement( TQString::null, TQString::null, d->tags.top(), d->attList ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } // ... followed by endElement if ( !contentHnd->endElement( TQString::null, TQString::null, d->tags.pop() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } else { d->tags.pop_back(); d->namespaceSupport.popContext(); } return TRUE; } /* Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE. */ bool TQXmlSimpleReader::processElementETagBegin2() { const TQString &name = TQXmlSimpleReader::name(); // pop the stack and compare it with the name if ( d->tags.pop() != name ) { reportParseError( XMLERR_TAGMISMATCH ); return FALSE; } // call the handler if ( contentHnd ) { TQString uri, lname; if (d->useNamespaces) d->namespaceSupport.processName(name, FALSE, uri, lname); if (!contentHnd->endElement(uri, lname, name)) { reportParseError(contentHnd->errorString()); return FALSE; } } if ( d->useNamespaces ) { NamespaceMap prefixesBefore, prefixesAfter; if (contentHnd) prefixesBefore = d->namespaceSupport.d->ns; d->namespaceSupport.popContext(); // call the handler for prefix mapping if ( contentHnd ) { prefixesAfter = d->namespaceSupport.d->ns; if (prefixesBefore.size() != prefixesAfter.size()) { for (NamespaceMap::const_iterator it = prefixesBefore.constBegin(); it != prefixesBefore.constEnd(); ++it) { if (!it.key().isEmpty() && !prefixesAfter.contains(it.key())) { if (!contentHnd->endPrefixMapping(it.key())) { reportParseError(contentHnd->errorString()); return FALSE; } } } } } } return TRUE; } /* Helper to break down the size of the code in the case statement. Return FALSE on error, otherwise TRUE. */ bool TQXmlSimpleReader::processElementAttribute() { TQString uri, lname, prefix; const TQString &name = TQXmlSimpleReader::name(); const TQString &string = TQXmlSimpleReader::string(); // add the attribute to the list if ( d->useNamespaces ) { // is it a namespace declaration? d->namespaceSupport.splitName(name, prefix, lname); if (prefix == "xmlns") { // namespace declaration d->namespaceSupport.setPrefix( lname, string ); if ( d->useNamespacePrefixes ) { // according to http://www.w3.org/2000/xmlns/, the "prefix" // xmlns maps to the namespace name // http://www.w3.org/2000/xmlns/ d->attList.append( name, "http://www.w3.org/2000/xmlns/", lname, string ); } // call the handler for prefix mapping if ( contentHnd ) { if ( !contentHnd->startPrefixMapping( lname, string ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } else { // no namespace delcaration d->namespaceSupport.processName( name, TRUE, uri, lname ); d->attList.append( name, uri, lname, string ); } } else { // no namespace support d->attList.append( name, TQString::null, TQString::null, string ); } return TRUE; } /* Parse a content [43]. A content is only used between tags. If a end tag is found the < is already read and the head stand on the '/' of the end tag ''. */ bool TQXmlSimpleReader::parseContent() { const signed char Init = 0; const signed char ChD = 1; // CharData const signed char ChD1 = 2; // CharData help state const signed char ChD2 = 3; // CharData help state const signed char Ref = 4; // Reference const signed char Lt = 5; // '<' read const signed char PInstr = 6; // PI const signed char PInstrR = 7; // same as PInstr, but already reported const signed char Elem = 8; // Element const signed char Em = 9; // '!' read const signed char Com = 10; // Comment const signed char ComR = 11; // same as Com, but already reported const signed char CDS = 12; // CDSect const signed char CDS1 = 13; // read a CDSect const signed char CDS2 = 14; // read a CDSect (help state) const signed char CDS3 = 15; // read a CDSect (help state) const signed char Done = 16; // finished reading content const signed char InpLt = 0; // < const signed char InpGt = 1; // > const signed char InpSlash = 2; // / const signed char InpTQMark = 3; // ? const signed char InpEMark = 4; // ! const signed char InpAmp = 5; // & const signed char InpDash = 6; // - const signed char InpOpenB = 7; // [ const signed char InpCloseB = 8; // ] const signed char InpUnknown = 9; static const signed char mapCLT2FSMChar[] = { InpUnknown, // white space InpUnknown, // % InpAmp, // & InpGt, // > InpLt, // < InpSlash, // / InpTQMark, // ? InpEMark, // ! InpDash, // - InpCloseB, // ] InpOpenB, // [ InpUnknown, // = InpUnknown, // " InpUnknown, // ' InpUnknown // unknown }; static const signed char table[16][10] = { /* InpLt InpGt InpSlash InpTQMark InpEMark InpAmp InpDash InpOpenB InpCloseB InpUnknown */ { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD1, ChD }, // Init { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD1, ChD }, // ChD { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD2, ChD }, // ChD1 { Lt, -1, ChD, ChD, ChD, Ref, ChD, ChD, ChD2, ChD }, // ChD2 { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Ref (same as Init) { -1, -1, Done, PInstr, Em, -1, -1, -1, -1, Elem }, // Lt { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // PInstr (same as Init) { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // PInstrR { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Elem (same as Init) { -1, -1, -1, -1, -1, -1, Com, CDS, -1, -1 }, // Em { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // Com (same as Init) { Lt, ChD, ChD, ChD, ChD, Ref, ChD, ChD, ChD, ChD }, // ComR { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS2, CDS1 }, // CDS { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS2, CDS1 }, // CDS1 { CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS3, CDS1 }, // CDS2 { CDS1, Init, CDS1, CDS1, CDS1, CDS1, CDS1, CDS1, CDS3, CDS1 } // CDS3 }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->contentCharDataRead = FALSE; state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseContent (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } } } for (;;) { switch ( state ) { case Ref: if ( !d->contentCharDataRead) d->contentCharDataRead = d->parseReference_charDataRead; break; case PInstr: if ( contentHnd ) { if ( !contentHnd->processingInstruction(name(),string()) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } state = PInstrR; break; case Com: if ( lexicalHnd ) { if ( !lexicalHnd->comment( string() ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } state = ComR; break; case CDS: stringClear(); break; case CDS2: if ( !atEnd() && c.unicode() != ']' ) stringAddC( ']' ); break; case CDS3: // test if this skipping was legal if ( !atEnd() ) { if ( c.unicode() == '>' ) { // the end of the CDSect if ( lexicalHnd ) { if ( !lexicalHnd->startCDATA() ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } if ( contentHnd ) { if ( !contentHnd->characters( string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } if ( lexicalHnd ) { if ( !lexicalHnd->endCDATA() ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } } else if (c.unicode() == ']') { // three or more ']' stringAddC( ']' ); } else { // after ']]' comes another character stringAddC( ']' ); stringAddC( ']' ); } } break; case Done: // call the handler for CharData if ( contentHnd ) { if ( d->contentCharDataRead ) { if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) { if ( !contentHnd->characters( string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } } // Done return TRUE; case -1: // Error reportParseError( XMLERR_ERRORPARSINGCONTENT ); return FALSE; } // get input (use lookup-table instead of nested ifs for performance // reasons) if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseContent, state ); return FALSE; } if ( c.row() ) { input = InpUnknown; } else { input = mapCLT2FSMChar[ charLookupTable[ c.cell() ] ]; } state = table[state][input]; switch ( state ) { case Init: // skip the ending '>' of a CDATASection next(); break; case ChD: // on first call: clear string if ( !d->contentCharDataRead ) { d->contentCharDataRead = TRUE; stringClear(); } stringAddC(); if ( d->reportEntities ) { if ( !reportEndEntities() ) return FALSE; } next(); break; case ChD1: // on first call: clear string if ( !d->contentCharDataRead ) { d->contentCharDataRead = TRUE; stringClear(); } stringAddC(); if ( d->reportEntities ) { if ( !reportEndEntities() ) return FALSE; } next(); break; case ChD2: stringAddC(); if ( d->reportEntities ) { if ( !reportEndEntities() ) return FALSE; } next(); break; case Ref: if ( !d->contentCharDataRead) { // reference may be CharData; so clear string to be safe stringClear(); d->parseReference_context = InContent; if ( !parseReference() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } } else { if ( d->reportEntities ) { // report character data in chunks if ( contentHnd ) { if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) { if ( !contentHnd->characters( string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } stringClear(); } d->parseReference_context = InContent; if ( !parseReference() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } } break; case Lt: // call the handler for CharData if ( contentHnd ) { if ( d->contentCharDataRead ) { if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) { if ( !contentHnd->characters( string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } } d->contentCharDataRead = FALSE; next(); break; case PInstr: case PInstrR: d->parsePI_xmldecl = FALSE; if ( !parsePI() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } break; case Elem: if ( !parseElement() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } break; case Em: next(); break; case Com: case ComR: if ( !parseComment() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } break; case CDS: d->parseString_s = "[CDATA["; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseContent, state ); return FALSE; } break; case CDS1: stringAddC(); next(); break; case CDS2: // skip ']' next(); break; case CDS3: // skip ']'... next(); break; } } } bool TQXmlSimpleReader::reportEndEntities() { int count = (int)d->xmlRef.count(); while ( count != 0 && d->xmlRef.top().isEmpty() ) { if ( contentHnd ) { if ( d->reportWhitespaceCharData || !string().simplifyWhiteSpace().isEmpty() ) { if ( !contentHnd->characters( string() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } stringClear(); if ( lexicalHnd ) { if ( !lexicalHnd->endEntity(d->xmlRefName.top()) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } d->xmlRef.pop_back(); d->xmlRefName.pop_back(); count--; } return TRUE; } /* Parse Misc [27]. */ bool TQXmlSimpleReader::parseMisc() { const signed char Init = 0; const signed char Lt = 1; // '<' was read const signed char Comment = 2; // read comment const signed char eatWS = 3; // eat whitespaces const signed char PInstr = 4; // read PI const signed char Comment2 = 5; // read comment const signed char InpWs = 0; // S const signed char InpLt = 1; // < const signed char InpQm = 2; // ? const signed char InpEm = 3; // ! const signed char InpUnknown = 4; static const signed char table[3][5] = { /* InpWs InpLt InpQm InpEm InpUnknown */ { eatWS, Lt, -1, -1, -1 }, // Init { -1, -1, PInstr,Comment, -1 }, // Lt { -1, -1, -1, -1, Comment2 } // Comment }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseMisc (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseMisc, state ); return FALSE; } } } for (;;) { switch ( state ) { case eatWS: return TRUE; case PInstr: if ( contentHnd ) { if ( !contentHnd->processingInstruction(name(),string()) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } return TRUE; case Comment2: if ( lexicalHnd ) { if ( !lexicalHnd->comment( string() ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseMisc, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '<' ) { input = InpLt; } else if ( c.unicode() == '?' ) { input = InpQm; } else if ( c.unicode() == '!' ) { input = InpEm; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case eatWS: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseMisc, state ); return FALSE; } break; case Lt: next(); break; case PInstr: d->parsePI_xmldecl = FALSE; if ( !parsePI() ) { parseFailed( &TQXmlSimpleReader::parseMisc, state ); return FALSE; } break; case Comment: next(); break; case Comment2: if ( !parseComment() ) { parseFailed( &TQXmlSimpleReader::parseMisc, state ); return FALSE; } break; } } } /* Parse a processing instruction [16]. If xmldec is TRUE, it tries to parse a PI or a XML declaration [23]. Precondition: the beginning '<' of the PI is already read and the head stand on the '?' of ' const signed char InpQm = 3; // ? const signed char InpUnknown = 4; static const signed char table[16][5] = { /* InpWs, InpNameBe InpGt InpQm InpUnknown */ { -1, -1, -1, QmI, -1 }, // Init { -1, Name, -1, -1, -1 }, // QmI { -1, -1, -1, -1, -1 }, // Name (this state is left not through input) { Ws1, -1, -1, -1, -1 }, // XMLDecl { -1, Version, -1, -1, -1 }, // Ws1 { Ws2, -1, -1, Qm, -1 }, // PInstr { Char, Char, Char, Qm, Char }, // Ws2 { Ws3, -1, -1, ADone, -1 }, // Version { -1, EorSD, -1, ADone, -1 }, // Ws3 { Ws4, -1, -1, ADone, -1 }, // EorSD { -1, SD, -1, ADone, -1 }, // Ws4 { Ws5, -1, -1, ADone, -1 }, // SD { -1, -1, -1, ADone, -1 }, // Ws5 { -1, -1, Done, -1, -1 }, // ADone { Char, Char, Char, Qm, Char }, // Char { Char, Char, Done, Qm, Char }, // Qm }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parsePI (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } } } for (;;) { switch ( state ) { case Name: // test what name was read and determine the next state // (not very beautiful, I admit) if ( name().lower() == "xml" ) { if ( d->parsePI_xmldecl && name()=="xml" ) { state = XMLDecl; } else { reportParseError( XMLERR_INVALIDNAMEFORPI ); return FALSE; } } else { state = PInstr; stringClear(); } break; case Version: // get version (syntax like an attribute) if ( name() != "version" ) { reportParseError( XMLERR_VERSIONEXPECTED ); return FALSE; } d->xmlVersion = string(); break; case EorSD: // get the EDecl or SDDecl (syntax like an attribute) if ( name() == "standalone" ) { if ( string()=="yes" ) { d->standalone = TQXmlSimpleReaderPrivate::Yes; } else if ( string()=="no" ) { d->standalone = TQXmlSimpleReaderPrivate::No; } else { reportParseError( XMLERR_WRONGVALUEFORSDECL ); return FALSE; } } else if ( name() == "encoding" ) { d->encoding = string(); } else { reportParseError( XMLERR_EDECLORSDDECLEXPECTED ); return FALSE; } break; case SD: if ( name() != "standalone" ) { reportParseError( XMLERR_SDDECLEXPECTED ); return FALSE; } if ( string()=="yes" ) { d->standalone = TQXmlSimpleReaderPrivate::Yes; } else if ( string()=="no" ) { d->standalone = TQXmlSimpleReaderPrivate::No; } else { reportParseError( XMLERR_WRONGVALUEFORSDECL ); return FALSE; } break; case Qm: // test if the skipping was legal if ( !atEnd() && c.unicode() != '>' ) stringAddC( '?' ); break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parsePI, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if (determineNameChar(c) == NameBeginning) { input = InpNameBe; } else if ( c.unicode() == '>' ) { input = InpGt; } else if ( c.unicode() == '?' ) { input = InpQm; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case QmI: next(); break; case Name: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } break; case Ws1: case Ws2: case Ws3: case Ws4: case Ws5: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } break; case Version: if ( !parseAttribute() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } break; case EorSD: if ( !parseAttribute() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } break; case SD: // get the SDDecl (syntax like an attribute) if ( d->standalone != TQXmlSimpleReaderPrivate::Unknown ) { // already parsed the standalone declaration reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( !parseAttribute() ) { parseFailed( &TQXmlSimpleReader::parsePI, state ); return FALSE; } break; case ADone: next(); break; case Char: stringAddC(); next(); break; case Qm: // skip the '?' next(); break; case Done: next(); break; } } } /* Parse a document type definition (doctypedecl [28]). Precondition: the beginning ' const signed char InpUnknown = 7; static const signed char table[13][8] = { /* InpWs, InpD InpS InpOB InpCB InpPer InpGt InpUnknown */ { -1, Doctype, -1, -1, -1, -1, -1, -1 }, // Init { Ws1, -1, -1, -1, -1, -1, -1, -1 }, // Doctype { -1, Doctype2, Doctype2, -1, -1, -1, -1, Doctype2 }, // Ws1 { Ws2, -1, Sys, MP, -1, -1, Done, -1 }, // Doctype2 { -1, -1, Sys, MP, -1, -1, Done, -1 }, // Ws2 { Ws3, -1, -1, MP, -1, -1, Done, -1 }, // Sys { -1, -1, -1, MP, -1, -1, Done, -1 }, // Ws3 { -1, -1, -1, -1, MPE, PER, -1, Mup }, // MP { -1, -1, -1, -1, MPE, PER, -1, Mup }, // MPR { Ws4, -1, -1, -1, MPE, PER, -1, Mup }, // PER { Ws4, -1, -1, -1, MPE, PER, -1, Mup }, // Mup { -1, -1, -1, -1, MPE, PER, -1, Mup }, // Ws4 { -1, -1, -1, -1, -1, -1, Done, -1 } // MPE }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->startDTDwasReported = FALSE; d->systemId = TQString::null; d->publicId = TQString::null; state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseDoctype (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } } } for (;;) { switch ( state ) { case Doctype2: d->doctype = name(); break; case MP: if ( !d->startDTDwasReported && lexicalHnd ) { d->startDTDwasReported = TRUE; if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } state = MPR; break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_ERRORPARSINGDOCTYPE ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == 'D' ) { input = InpD; } else if ( c.unicode() == 'S' ) { input = InpS; } else if ( c.unicode() == 'P' ) { input = InpS; } else if ( c.unicode() == '[' ) { input = InpOB; } else if ( c.unicode() == ']' ) { input = InpCB; } else if ( c.unicode() == '%' ) { input = InpPer; } else if ( c.unicode() == '>' ) { input = InpGt; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Doctype: d->parseString_s = "DOCTYPE"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case Ws1: case Ws2: case Ws3: case Ws4: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case Doctype2: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case Sys: d->parseExternalID_allowPublicID = FALSE; if ( !parseExternalID() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case MP: case MPR: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case PER: d->parsePEReference_context = InDTD; if ( !parsePEReference() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case Mup: if (dtdRecursionLimit > 0U && d->parameterEntities.size() > dtdRecursionLimit) { reportParseError(TQString::fromLatin1( "DTD parsing exceeded recursion limit of %1.").arg(dtdRecursionLimit)); return FALSE; } if ( !parseMarkupdecl() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case MPE: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseDoctype, state ); return FALSE; } break; case Done: if ( lexicalHnd ) { if ( !d->startDTDwasReported ) { d->startDTDwasReported = TRUE; if ( !lexicalHnd->startDTD( d->doctype, d->publicId, d->systemId ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } if ( !lexicalHnd->endDTD() ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } next(); break; } } } /* Parse a ExternalID [75]. If allowPublicID is TRUE parse ExternalID [75] or PublicID [83]. */ bool TQXmlSimpleReader::parseExternalID() { const signed char Init = 0; const signed char Sys = 1; // parse 'SYSTEM' const signed char SysWS = 2; // parse the whitespace after 'SYSTEM' const signed char SysSQ = 3; // parse SystemLiteral with ' const signed char SysSQ2 = 4; // parse SystemLiteral with ' const signed char SysDQ = 5; // parse SystemLiteral with " const signed char SysDQ2 = 6; // parse SystemLiteral with " const signed char Pub = 7; // parse 'PUBLIC' const signed char PubWS = 8; // parse the whitespace after 'PUBLIC' const signed char PubSQ = 9; // parse PubidLiteral with ' const signed char PubSQ2 = 10; // parse PubidLiteral with ' const signed char PubDQ = 11; // parse PubidLiteral with " const signed char PubDQ2 = 12; // parse PubidLiteral with " const signed char PubE = 13; // finished parsing the PubidLiteral const signed char PubWS2 = 14; // parse the whitespace after the PubidLiteral const signed char PDone = 15; // done if allowPublicID is TRUE const signed char Done = 16; const signed char InpSQ = 0; // ' const signed char InpDQ = 1; // " const signed char InpS = 2; // S const signed char InpP = 3; // P const signed char InpWs = 4; // white space const signed char InpUnknown = 5; static const signed char table[15][6] = { /* InpSQ InpDQ InpS InpP InpWs InpUnknown */ { -1, -1, Sys, Pub, -1, -1 }, // Init { -1, -1, -1, -1, SysWS, -1 }, // Sys { SysSQ, SysDQ, -1, -1, -1, -1 }, // SysWS { Done, SysSQ2, SysSQ2, SysSQ2, SysSQ2, SysSQ2 }, // SysSQ { Done, SysSQ2, SysSQ2, SysSQ2, SysSQ2, SysSQ2 }, // SysSQ2 { SysDQ2, Done, SysDQ2, SysDQ2, SysDQ2, SysDQ2 }, // SysDQ { SysDQ2, Done, SysDQ2, SysDQ2, SysDQ2, SysDQ2 }, // SysDQ2 { -1, -1, -1, -1, PubWS, -1 }, // Pub { PubSQ, PubDQ, -1, -1, -1, -1 }, // PubWS { PubE, -1, PubSQ2, PubSQ2, PubSQ2, PubSQ2 }, // PubSQ { PubE, -1, PubSQ2, PubSQ2, PubSQ2, PubSQ2 }, // PubSQ2 { -1, PubE, PubDQ2, PubDQ2, PubDQ2, PubDQ2 }, // PubDQ { -1, PubE, PubDQ2, PubDQ2, PubDQ2, PubDQ2 }, // PubDQ2 { PDone, PDone, PDone, PDone, PubWS2, PDone }, // PubE { SysSQ, SysDQ, PDone, PDone, PDone, PDone } // PubWS2 }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->systemId = TQString::null; d->publicId = TQString::null; state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseExternalID (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } } } for (;;) { switch ( state ) { case PDone: if ( d->parseExternalID_allowPublicID ) { d->publicId = string(); return TRUE; } else { reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } case Done: return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '\'' ) { input = InpSQ; } else if ( c.unicode() == '"' ) { input = InpDQ; } else if ( c.unicode() == 'S' ) { input = InpS; } else if ( c.unicode() == 'P' ) { input = InpP; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Sys: d->parseString_s = "SYSTEM"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } break; case SysWS: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } break; case SysSQ: case SysDQ: stringClear(); next(); break; case SysSQ2: case SysDQ2: stringAddC(); next(); break; case Pub: d->parseString_s = "PUBLIC"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } break; case PubWS: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } break; case PubSQ: case PubDQ: stringClear(); next(); break; case PubSQ2: case PubDQ2: stringAddC(); next(); break; case PubE: next(); break; case PubWS2: d->publicId = string(); if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseExternalID, state ); return FALSE; } break; case Done: d->systemId = string(); next(); break; } } } /* Parse a markupdecl [29]. */ bool TQXmlSimpleReader::parseMarkupdecl() { const signed char Init = 0; const signed char Lt = 1; // < was read const signed char Em = 2; // ! was read const signed char CE = 3; // E was read const signed char Qm = 4; // ? was read const signed char Dash = 5; // - was read const signed char CA = 6; // A was read const signed char CEL = 7; // EL was read const signed char CEN = 8; // EN was read const signed char CN = 9; // N was read const signed char Done = 10; const signed char InpLt = 0; // < const signed char InpQm = 1; // ? const signed char InpEm = 2; // ! const signed char InpDash = 3; // - const signed char InpA = 4; // A const signed char InpE = 5; // E const signed char InpL = 6; // L const signed char InpN = 7; // N const signed char InpUnknown = 8; static const signed char table[4][9] = { /* InpLt InpQm InpEm InpDash InpA InpE InpL InpN InpUnknown */ { Lt, -1, -1, -1, -1, -1, -1, -1, -1 }, // Init { -1, Qm, Em, -1, -1, -1, -1, -1, -1 }, // Lt { -1, -1, -1, Dash, CA, CE, -1, CN, -1 }, // Em { -1, -1, -1, -1, -1, -1, CEL, CEN, -1 } // CE }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseMarkupdecl (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } } } for (;;) { switch ( state ) { case Qm: if ( contentHnd ) { if ( !contentHnd->processingInstruction(name(),string()) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } return TRUE; case Dash: if ( lexicalHnd ) { if ( !lexicalHnd->comment( string() ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } return TRUE; case CA: return TRUE; case CEL: return TRUE; case CEN: return TRUE; case CN: return TRUE; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } if ( c.unicode() == '<' ) { input = InpLt; } else if ( c.unicode() == '?' ) { input = InpQm; } else if ( c.unicode() == '!' ) { input = InpEm; } else if ( c.unicode() == '-' ) { input = InpDash; } else if ( c.unicode() == 'A' ) { input = InpA; } else if ( c.unicode() == 'E' ) { input = InpE; } else if ( c.unicode() == 'L' ) { input = InpL; } else if ( c.unicode() == 'N' ) { input = InpN; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Lt: next(); break; case Em: next(); break; case CE: next(); break; case Qm: d->parsePI_xmldecl = FALSE; if ( !parsePI() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; case Dash: if ( !parseComment() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; case CA: if ( !parseAttlistDecl() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; case CEL: if ( !parseElementDecl() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; case CEN: if ( !parseEntityDecl() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; case CN: if ( !parseNotationDecl() ) { parseFailed( &TQXmlSimpleReader::parseMarkupdecl, state ); return FALSE; } break; } } } /* Parse a PEReference [69] */ bool TQXmlSimpleReader::parsePEReference() { const signed char Init = 0; const signed char Next = 1; const signed char Name = 2; const signed char NameR = 3; // same as Name, but already reported const signed char Done = 4; const signed char InpSemi = 0; // ; const signed char InpPer = 1; // % const signed char InpUnknown = 2; static const signed char table[4][3] = { /* InpSemi InpPer InpUnknown */ { -1, Next, -1 }, // Init { -1, -1, Name }, // Next { Done, -1, -1 }, // Name { Done, -1, -1 } // NameR }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parsePEReference (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parsePEReference, state ); return FALSE; } } } for (;;) { switch ( state ) { case Name: { bool skipIt = TRUE; TQString xmlRefString; TQMap::Iterator it; it = d->parameterEntities.find( ref() ); if ( it != d->parameterEntities.end() ) { skipIt = FALSE; xmlRefString = it.data(); } else if ( entityRes ) { TQMap::Iterator it2; it2 = d->externParameterEntities.find( ref() ); TQXmlInputSource *ret = 0; if ( it2 != d->externParameterEntities.end() ) { if ( !entityRes->resolveEntity( it2.data().publicId, it2.data().systemId, ret ) ) { delete ret; reportParseError( entityRes->errorString() ); return FALSE; } if ( ret ) { xmlRefString = ret->data(); delete ret; if ( !stripTextDecl( xmlRefString ) ) { reportParseError( XMLERR_ERRORINTEXTDECL ); return FALSE; } skipIt = FALSE; } } } if ( skipIt ) { if ( contentHnd ) { if ( !contentHnd->skippedEntity( TQString("%") + ref() ) ) { reportParseError( contentHnd->errorString() ); return FALSE; } } } else { if ( d->parsePEReference_context == InEntityValue ) { // Included in literal if ( !insertXmlRef( xmlRefString, ref(), TRUE ) ) return FALSE; } else if ( d->parsePEReference_context == InDTD ) { // Included as PE if ( !insertXmlRef( TQString(" ")+xmlRefString+TQString(" "), ref(), FALSE ) ) return FALSE; } } } state = NameR; break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parsePEReference, state ); return FALSE; } if ( c.unicode() == ';' ) { input = InpSemi; } else if ( c.unicode() == '%' ) { input = InpPer; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Next: next(); break; case Name: case NameR: d->parseName_useRef = TRUE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parsePEReference, state ); return FALSE; } break; case Done: next(); break; } } } /* Parse a AttlistDecl [52]. Precondition: the beginning ' const signed char InpHash = 2; // # const signed char InpA = 3; // A const signed char InpI = 4; // I const signed char InpF = 5; // F const signed char InpR = 6; // R const signed char InpUnknown = 7; static const signed char table[15][8] = { /* InpWs InpGt InpHash InpA InpI InpF InpR InpUnknown */ { -1, -1, -1, Attlist, -1, -1, -1, -1 }, // Init { Ws, -1, -1, -1, -1, -1, -1, -1 }, // Attlist { -1, -1, -1, Name, Name, Name, Name, Name }, // Ws { Ws1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef }, // Name { -1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef }, // Ws1 { Ws2, -1, -1, -1, -1, -1, -1, -1 }, // Attdef { -1, Atttype, Atttype, Atttype, Atttype, Atttype, Atttype, Atttype }, // Ws2 { Ws3, -1, -1, -1, -1, -1, -1, -1 }, // Attype { -1, Attval, DDecH, Attval, Attval, Attval, Attval, Attval }, // Ws3 { -1, -1, -1, -1, DefImp, DefFix, DefReq, -1 }, // DDecH { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // DefReq { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // DefImp { Ws3, -1, -1, -1, -1, -1, -1, -1 }, // DefFix { Ws4, Ws4, -1, -1, -1, -1, -1, -1 }, // Attval { -1, Done, Attdef, Attdef, Attdef, Attdef, Attdef, Attdef } // Ws4 }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseAttlistDecl (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } } } for (;;) { switch ( state ) { case Name: d->attDeclEName = name(); break; case Attdef: d->attDeclAName = name(); break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '>' ) { input = InpGt; } else if ( c.unicode() == '#' ) { input = InpHash; } else if ( c.unicode() == 'A' ) { input = InpA; } else if ( c.unicode() == 'I' ) { input = InpI; } else if ( c.unicode() == 'F' ) { input = InpF; } else if ( c.unicode() == 'R' ) { input = InpR; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Attlist: d->parseString_s = "ATTLIST"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Ws: case Ws1: case Ws2: case Ws3: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Name: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Attdef: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Atttype: if ( !parseAttType() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case DDecH: next(); break; case DefReq: d->parseString_s = "REQUIRED"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case DefImp: d->parseString_s = "IMPLIED"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case DefFix: d->parseString_s = "FIXED"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Attval: if ( !parseAttValue() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Ws4: if ( declHnd ) { // ### not all values are computed yet... if ( !declHnd->attributeDecl( d->attDeclEName, d->attDeclAName, "", "", "" ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttlistDecl, state ); return FALSE; } break; case Done: next(); break; } } } /* Parse a AttType [54] */ bool TQXmlSimpleReader::parseAttType() { const signed char Init = 0; const signed char ST = 1; // StringType const signed char TTI = 2; // TokenizedType starting with 'I' const signed char TTI2 = 3; // TokenizedType helpstate const signed char TTI3 = 4; // TokenizedType helpstate const signed char TTE = 5; // TokenizedType starting with 'E' const signed char TTEY = 6; // TokenizedType starting with 'ENTITY' const signed char TTEI = 7; // TokenizedType starting with 'ENTITI' const signed char N = 8; // N read (TokenizedType or Notation) const signed char TTNM = 9; // TokenizedType starting with 'NM' const signed char TTNM2 = 10; // TokenizedType helpstate const signed char NO = 11; // Notation const signed char NO2 = 12; // Notation helpstate const signed char NO3 = 13; // Notation helpstate const signed char NOName = 14; // Notation, read name const signed char NO4 = 15; // Notation helpstate const signed char EN = 16; // Enumeration const signed char ENNmt = 17; // Enumeration, read Nmtoken const signed char EN2 = 18; // Enumeration helpstate const signed char ADone = 19; // almost done (make next and accept) const signed char Done = 20; const signed char InpWs = 0; // whitespace const signed char InpOp = 1; // ( const signed char InpCp = 2; // ) const signed char InpPipe = 3; // | const signed char InpC = 4; // C const signed char InpE = 5; // E const signed char InpI = 6; // I const signed char InpM = 7; // M const signed char InpN = 8; // N const signed char InpO = 9; // O const signed char InpR = 10; // R const signed char InpS = 11; // S const signed char InpY = 12; // Y const signed char InpUnknown = 13; static const signed char table[19][14] = { /* InpWs InpOp InpCp InpPipe InpC InpE InpI InpM InpN InpO InpR InpS InpY InpUnknown */ { -1, EN, -1, -1, ST, TTE, TTI, -1, N, -1, -1, -1, -1, -1 }, // Init { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // ST { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTI2, Done, Done, Done }, // TTI { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTI3, Done, Done }, // TTI2 { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTI3 { -1, -1, -1, -1, -1, -1, TTEI, -1, -1, -1, -1, -1, TTEY, -1 }, // TTE { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTEY { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTEI { -1, -1, -1, -1, -1, -1, -1, TTNM, -1, NO, -1, -1, -1, -1 }, // N { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, TTNM2, Done, Done }, // TTNM { Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done, Done }, // TTNM2 { NO2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO { -1, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO2 { NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName, NOName }, // NO3 { NO4, -1, ADone, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NOName { -1, -1, ADone, NO3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // NO4 { -1, -1, ENNmt, -1, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt, ENNmt }, // EN { EN2, -1, ADone, EN, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // ENNmt { -1, -1, ADone, EN, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } // EN2 }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseAttType (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } } } for (;;) { switch ( state ) { case ADone: return TRUE; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '(' ) { input = InpOp; } else if ( c.unicode() == ')' ) { input = InpCp; } else if ( c.unicode() == '|' ) { input = InpPipe; } else if ( c.unicode() == 'C' ) { input = InpC; } else if ( c.unicode() == 'E' ) { input = InpE; } else if ( c.unicode() == 'I' ) { input = InpI; } else if ( c.unicode() == 'M' ) { input = InpM; } else if ( c.unicode() == 'N' ) { input = InpN; } else if ( c.unicode() == 'O' ) { input = InpO; } else if ( c.unicode() == 'R' ) { input = InpR; } else if ( c.unicode() == 'S' ) { input = InpS; } else if ( c.unicode() == 'Y' ) { input = InpY; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case ST: d->parseString_s = "CDATA"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case TTI: d->parseString_s = "ID"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case TTI2: d->parseString_s = "REF"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case TTI3: next(); // S break; case TTE: d->parseString_s = "ENTIT"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case TTEY: next(); // Y break; case TTEI: d->parseString_s = "IES"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case N: next(); // N break; case TTNM: d->parseString_s = "MTOKEN"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case TTNM2: next(); // S break; case NO: d->parseString_s = "OTATION"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case NO2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case NO3: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case NOName: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case NO4: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case EN: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case ENNmt: if ( !parseNmtoken() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case EN2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttType, state ); return FALSE; } break; case ADone: next(); break; } } } /* Parse a AttValue [10] Precondition: the head stands on the beginning " or ' If this function was successful, the head stands on the first character after the closing " or ' and the value of the attribute is in string(). */ bool TQXmlSimpleReader::parseAttValue() { const signed char Init = 0; const signed char Dq = 1; // double quotes were read const signed char DqRef = 2; // read references in double quotes const signed char DqC = 3; // signed character read in double quotes const signed char Sq = 4; // single quotes were read const signed char SqRef = 5; // read references in single quotes const signed char SqC = 6; // signed character read in single quotes const signed char Done = 7; const signed char InpDq = 0; // " const signed char InpSq = 1; // ' const signed char InpAmp = 2; // & const signed char InpLt = 3; // < const signed char InpUnknown = 4; static const signed char table[7][5] = { /* InpDq InpSq InpAmp InpLt InpUnknown */ { Dq, Sq, -1, -1, -1 }, // Init { Done, DqC, DqRef, -1, DqC }, // Dq { Done, DqC, DqRef, -1, DqC }, // DqRef { Done, DqC, DqRef, -1, DqC }, // DqC { SqC, Done, SqRef, -1, SqC }, // Sq { SqC, Done, SqRef, -1, SqC }, // SqRef { SqC, Done, SqRef, -1, SqC } // SqRef }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseAttValue (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseAttValue, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseAttValue, state ); return FALSE; } if ( c.unicode() == '"' ) { input = InpDq; } else if ( c.unicode() == '\'' ) { input = InpSq; } else if ( c.unicode() == '&' ) { input = InpAmp; } else if ( c.unicode() == '<' ) { input = InpLt; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Dq: case Sq: stringClear(); next(); break; case DqRef: case SqRef: d->parseReference_context = InAttributeValue; if ( !parseReference() ) { parseFailed( &TQXmlSimpleReader::parseAttValue, state ); return FALSE; } break; case DqC: case SqC: stringAddC(); next(); break; case Done: next(); break; } } } /* Parse a elementdecl [45]. Precondition: the beginning ' const signed char InpPipe = 2; // | const signed char InpOp = 3; // ( const signed char InpCp = 4; // ) const signed char InpHash = 5; // # const signed char InpQm = 6; // ? const signed char InpAst = 7; // * const signed char InpPlus = 8; // + const signed char InpA = 9; // A const signed char InpE = 10; // E const signed char InpL = 11; // L const signed char InpUnknown = 12; static const signed char table[18][13] = { /* InpWs InpGt InpPipe InpOp InpCp InpHash InpQm InpAst InpPlus InpA InpE InpL InpUnknown */ { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, Elem, -1 }, // Init { Ws1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Elem { -1, -1, -1, -1, -1, -1, -1, -1, -1, Nam, Nam, Nam, Nam }, // Ws1 { Ws2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Nam { -1, -1, -1, Cont, -1, -1, -1, -1, -1, Any, Empty, -1, -1 }, // Ws2 { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Empty { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Any { -1, -1, -1, Cp, Cp, Mix, -1, -1, -1, Cp, Cp, Cp, Cp }, // Cont { Mix2, -1, MixN1, -1, Mix3, -1, -1, -1, -1, -1, -1, -1, -1 }, // Mix { -1, -1, MixN1, -1, Mix3, -1, -1, -1, -1, -1, -1, -1, -1 }, // Mix2 { WsD, Done, -1, -1, -1, -1, -1, WsD, -1, -1, -1, -1, -1 }, // Mix3 { -1, -1, -1, -1, -1, -1, -1, -1, -1, MixN2, MixN2, MixN2, MixN2 }, // MixN1 { MixN3, -1, MixN1, -1, MixN4, -1, -1, -1, -1, -1, -1, -1, -1 }, // MixN2 { -1, -1, MixN1, -1, MixN4, -1, -1, -1, -1, -1, -1, -1, -1 }, // MixN3 { -1, -1, -1, -1, -1, -1, -1, WsD, -1, -1, -1, -1, -1 }, // MixN4 { WsD, Done, -1, -1, -1, -1, Cp2, Cp2, Cp2, -1, -1, -1, -1 }, // Cp { WsD, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }, // Cp2 { -1, Done, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } // WsD }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseElementDecl (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '>' ) { input = InpGt; } else if ( c.unicode() == '|' ) { input = InpPipe; } else if ( c.unicode() == '(' ) { input = InpOp; } else if ( c.unicode() == ')' ) { input = InpCp; } else if ( c.unicode() == '#' ) { input = InpHash; } else if ( c.unicode() == '?' ) { input = InpQm; } else if ( c.unicode() == '*' ) { input = InpAst; } else if ( c.unicode() == '+' ) { input = InpPlus; } else if ( c.unicode() == 'A' ) { input = InpA; } else if ( c.unicode() == 'E' ) { input = InpE; } else if ( c.unicode() == 'L' ) { input = InpL; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Elem: d->parseString_s = "LEMENT"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Ws1: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Nam: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Ws2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Empty: d->parseString_s = "EMPTY"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Any: d->parseString_s = "ANY"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Cont: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Mix: d->parseString_s = "#PCDATA"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Mix2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Mix3: next(); break; case MixN1: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case MixN2: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case MixN3: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case MixN4: next(); break; case Cp: if ( !parseChoiceSeq() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Cp2: next(); break; case WsD: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseElementDecl, state ); return FALSE; } break; case Done: next(); break; } } } /* Parse a NotationDecl [82]. Precondition: the beginning ' const signed char InpN = 2; // N const signed char InpUnknown = 3; static const signed char table[8][4] = { /* InpWs InpGt InpN InpUnknown */ { -1, -1, Not, -1 }, // Init { Ws1, -1, -1, -1 }, // Not { -1, -1, Nam, Nam }, // Ws1 { Ws2, Done, -1, -1 }, // Nam { -1, Done, ExtID, ExtID }, // Ws2 { Ws3, Done, -1, -1 }, // ExtID { Ws3, Done, -1, -1 }, // ExtIDR { -1, Done, -1, -1 } // Ws3 }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseNotationDecl (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } } } for (;;) { switch ( state ) { case ExtID: // call the handler if ( dtdHnd ) { if ( !dtdHnd->notationDecl( name(), d->publicId, d->systemId ) ) { reportParseError( dtdHnd->errorString() ); return FALSE; } } state = ExtIDR; break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '>' ) { input = InpGt; } else if ( c.unicode() == 'N' ) { input = InpN; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Not: d->parseString_s = "NOTATION"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case Ws1: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case Nam: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case Ws2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case ExtID: case ExtIDR: d->parseExternalID_allowPublicID = TRUE; if ( !parseExternalID() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case Ws3: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseNotationDecl, state ); return FALSE; } break; case Done: next(); break; } } } /* Parse choice [49] or seq [50]. Precondition: the beginning '('S? is already read and the head stands on the first non-whitespace character after it. */ bool TQXmlSimpleReader::parseChoiceSeq() { const signed char Init = 0; const signed char Ws1 = 1; // eat whitespace const signed char CorS = 2; // choice or set const signed char Ws2 = 3; // eat whitespace const signed char More = 4; // more cp to read const signed char Name = 5; // read name const signed char Done = 6; // const signed char InpWs = 0; // S const signed char InpOp = 1; // ( const signed char InpCp = 2; // ) const signed char InpQm = 3; // ? const signed char InpAst = 4; // * const signed char InpPlus = 5; // + const signed char InpPipe = 6; // | const signed char InpComm = 7; // , const signed char InpUnknown = 8; static const signed char table[6][9] = { /* InpWs InpOp InpCp InpQm InpAst InpPlus InpPipe InpComm InpUnknown */ { -1, Ws1, -1, -1, -1, -1, -1, -1, Name }, // Init { -1, CorS, -1, -1, -1, -1, -1, -1, CorS }, // Ws1 { Ws2, -1, Done, Ws2, Ws2, Ws2, More, More, -1 }, // CorS { -1, -1, Done, -1, -1, -1, More, More, -1 }, // Ws2 { -1, Ws1, -1, -1, -1, -1, -1, -1, Name }, // More (same as Init) { Ws2, -1, Done, Ws2, Ws2, Ws2, More, More, -1 } // Name (same as CorS) }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseChoiceSeq (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '(' ) { input = InpOp; } else if ( c.unicode() == ')' ) { input = InpCp; } else if ( c.unicode() == '?' ) { input = InpQm; } else if ( c.unicode() == '*' ) { input = InpAst; } else if ( c.unicode() == '+' ) { input = InpPlus; } else if ( c.unicode() == '|' ) { input = InpPipe; } else if ( c.unicode() == ',' ) { input = InpComm; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Ws1: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } break; case CorS: if ( !parseChoiceSeq() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } break; case Ws2: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } break; case More: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } break; case Name: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseChoiceSeq, state ); return FALSE; } break; case Done: next(); break; } } } bool TQXmlSimpleReader::isExpandedEntityValueTooLarge(TQString *errorMessage) { TQMap literalEntitySizes; // The entity at (TQMap) times. TQMap > referencesToOtherEntities; TQMap expandedSizes; // For every entity, check how many times all entity names were referenced in its value. TQMap::ConstIterator toSearchIterator; for (toSearchIterator = d->entities.begin(); toSearchIterator != d->entities.end(); ++toSearchIterator) { TQString toSearch = toSearchIterator.key(); // The amount of characters that weren't entity names, but literals, like 'X'. TQString leftOvers = toSearchIterator.data(); TQMap::ConstIterator entityNameIterator; // How many times was entityName referenced by toSearch? for (entityNameIterator = d->entities.begin(); entityNameIterator != d->entities.end(); ++entityNameIterator) { TQString entityName = entityNameIterator.key(); for (int i = 0; i >= 0 && (uint) i < leftOvers.length(); ) { i = leftOvers.find(TQString::fromLatin1("&%1;").arg(entityName), i); if (i != -1) { leftOvers.remove(i, entityName.length() + 2U); // The entityName we're currently trying to find was matched in this string; increase our count. ++referencesToOtherEntities[toSearch][entityName]; } } } literalEntitySizes[toSearch] = leftOvers.length(); } TQMap >::ConstIterator entityIterator; for (entityIterator = referencesToOtherEntities.begin(); entityIterator != referencesToOtherEntities.end(); ++entityIterator) { TQString entity = entityIterator.key(); expandedSizes[entity] = literalEntitySizes[entity]; TQMap::ConstIterator referenceToIterator; for (referenceToIterator = entityIterator.data().begin(); referenceToIterator != entityIterator.data().end(); ++referenceToIterator) { TQString referenceTo = referenceToIterator.key(); const uint references = referenceToIterator.data(); // The total size of an entity's value is the expanded size of all of its referenced entities, plus its literal size. expandedSizes[entity] += expandedSizes[referenceTo] * references + literalEntitySizes[referenceTo] * references; } if (expandedSizes[entity] > entityCharacterLimit) { if (errorMessage) { *errorMessage = TQString::fromLatin1("The XML entity \"%1\" expands to a string that is too large to process (%2 characters > %3)."); *errorMessage = (*errorMessage).arg(entity).arg(expandedSizes[entity]).arg(entityCharacterLimit); } return TRUE; } } return FALSE; } /* Parse a EntityDecl [70]. Precondition: the beginning ' const signed char InpN = 4; // N const signed char InpUnknown = 5; static const signed char table[22][6] = { /* InpWs InpPer InpQuot InpGt InpN InpUnknown */ { -1, -1, -1, -1, Ent, -1 }, // Init { Ws1, -1, -1, -1, -1, -1 }, // Ent { -1, PEDec, -1, -1, Name, Name }, // Ws1 { Ws2, -1, -1, -1, -1, -1 }, // Name { -1, -1, EValue, -1, -1, ExtID }, // Ws2 { WsE, -1, -1, Done, -1, -1 }, // EValue { WsE, -1, -1, Done, -1, -1 }, // EValueR { Ws3, -1, -1, EDDone,-1, -1 }, // ExtID { -1, -1, -1, EDDone,Ndata, -1 }, // Ws3 { Ws4, -1, -1, -1, -1, -1 }, // Ndata { -1, -1, -1, -1, NNam, NNam }, // Ws4 { WsE, -1, -1, Done, -1, -1 }, // NNam { WsE, -1, -1, Done, -1, -1 }, // NNamR { Ws6, -1, -1, -1, -1, -1 }, // PEDec { -1, -1, -1, -1, PENam, PENam }, // Ws6 { Ws7, -1, -1, -1, -1, -1 }, // PENam { -1, -1, PEVal, -1, -1, PEEID }, // Ws7 { WsE, -1, -1, Done, -1, -1 }, // PEVal { WsE, -1, -1, Done, -1, -1 }, // PEValR { WsE, -1, -1, Done, -1, -1 }, // PEEID { WsE, -1, -1, Done, -1, -1 }, // PEEIDR { -1, -1, -1, Done, -1, -1 } // WsE }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseEntityDecl (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } } } for (;;) { switch ( state ) { case EValue: if ( !entityExist( name() ) ) { TQString errorMessage; if (isExpandedEntityValueTooLarge(&errorMessage)) { reportParseError(errorMessage); return FALSE; } d->entities.insert( name(), string() ); if ( declHnd ) { if ( !declHnd->internalEntityDecl( name(), string() ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } } state = EValueR; break; case NNam: if ( !entityExist( name() ) ) { d->externEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, ref() ) ); if ( dtdHnd ) { if ( !dtdHnd->unparsedEntityDecl( name(), d->publicId, d->systemId, ref() ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } } state = NNamR; break; case PEVal: if ( !entityExist( name() ) ) { d->parameterEntities.insert( name(), string() ); if ( declHnd ) { if ( !declHnd->internalEntityDecl( TQString("%")+name(), string() ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } } state = PEValR; break; case PEEID: if ( !entityExist( name() ) ) { d->externParameterEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternParameterEntity( d->publicId, d->systemId ) ); if ( declHnd ) { if ( !declHnd->externalEntityDecl( TQString("%")+name(), d->publicId, d->systemId ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } } state = PEEIDR; break; case EDDone: if ( !entityExist( name() ) ) { d->externEntities.insert( name(), TQXmlSimpleReaderPrivate::ExternEntity( d->publicId, d->systemId, TQString::null ) ); if ( declHnd ) { if ( !declHnd->externalEntityDecl( name(), d->publicId, d->systemId ) ) { reportParseError( declHnd->errorString() ); return FALSE; } } } return TRUE; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } if ( is_S(c) ) { input = InpWs; } else if ( c.unicode() == '%' ) { input = InpPer; } else if ( c.unicode() == '"' || c.unicode() == '\'' ) { input = InpQuot; } else if ( c.unicode() == '>' ) { input = InpGt; } else if ( c.unicode() == 'N' ) { input = InpN; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Ent: d->parseString_s = "NTITY"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ws1: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Name: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ws2: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case EValue: case EValueR: if ( !parseEntityValue() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case ExtID: d->parseExternalID_allowPublicID = FALSE; if ( !parseExternalID() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ws3: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ndata: d->parseString_s = "NDATA"; if ( !parseString() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ws4: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case NNam: case NNamR: d->parseName_useRef = TRUE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case PEDec: next(); break; case Ws6: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case PENam: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case Ws7: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case PEVal: case PEValR: if ( !parseEntityValue() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case PEEID: case PEEIDR: d->parseExternalID_allowPublicID = FALSE; if ( !parseExternalID() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case WsE: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseEntityDecl, state ); return FALSE; } break; case EDDone: next(); break; case Done: next(); break; } } } /* Parse a EntityValue [9] */ bool TQXmlSimpleReader::parseEntityValue() { const signed char Init = 0; const signed char Dq = 1; // EntityValue is double quoted const signed char DqC = 2; // signed character const signed char DqPER = 3; // PERefence const signed char DqRef = 4; // Reference const signed char Sq = 5; // EntityValue is double quoted const signed char SqC = 6; // signed character const signed char SqPER = 7; // PERefence const signed char SqRef = 8; // Reference const signed char Done = 9; const signed char InpDq = 0; // " const signed char InpSq = 1; // ' const signed char InpAmp = 2; // & const signed char InpPer = 3; // % const signed char InpUnknown = 4; static const signed char table[9][5] = { /* InpDq InpSq InpAmp InpPer InpUnknown */ { Dq, Sq, -1, -1, -1 }, // Init { Done, DqC, DqRef, DqPER, DqC }, // Dq { Done, DqC, DqRef, DqPER, DqC }, // DqC { Done, DqC, DqRef, DqPER, DqC }, // DqPER { Done, DqC, DqRef, DqPER, DqC }, // DqRef { SqC, Done, SqRef, SqPER, SqC }, // Sq { SqC, Done, SqRef, SqPER, SqC }, // SqC { SqC, Done, SqRef, SqPER, SqC }, // SqPER { SqC, Done, SqRef, SqPER, SqC } // SqRef }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseEntityValue (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseEntityValue, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseEntityValue, state ); return FALSE; } if ( c.unicode() == '"' ) { input = InpDq; } else if ( c.unicode() == '\'' ) { input = InpSq; } else if ( c.unicode() == '&' ) { input = InpAmp; } else if ( c.unicode() == '%' ) { input = InpPer; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Dq: case Sq: stringClear(); next(); break; case DqC: case SqC: stringAddC(); next(); break; case DqPER: case SqPER: d->parsePEReference_context = InEntityValue; if ( !parsePEReference() ) { parseFailed( &TQXmlSimpleReader::parseEntityValue, state ); return FALSE; } break; case DqRef: case SqRef: d->parseReference_context = InEntityValue; if ( !parseReference() ) { parseFailed( &TQXmlSimpleReader::parseEntityValue, state ); return FALSE; } break; case Done: next(); break; } } } /* Parse a comment [15]. Precondition: the beginning ' const signed char InpUnknown = 2; static const signed char table[6][3] = { /* InpDash InpGt InpUnknown */ { Dash1, -1, -1 }, // Init { Dash2, -1, -1 }, // Dash1 { Com2, Com, Com }, // Dash2 { Com2, Com, Com }, // Com { ComE, Com, Com }, // Com2 { -1, Done, -1 } // ComE }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseComment (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseComment, state ); return FALSE; } } } for (;;) { switch ( state ) { case Dash2: stringClear(); break; case Com2: // if next character is not a dash than don't skip it if ( !atEnd() && c.unicode() != '-' ) stringAddC( '-' ); break; case Done: return TRUE; case -1: // Error reportParseError( XMLERR_ERRORPARSINGCOMMENT ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseComment, state ); return FALSE; } if ( c.unicode() == '-' ) { input = InpDash; } else if ( c.unicode() == '>' ) { input = InpGt; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case Dash1: next(); break; case Dash2: next(); break; case Com: stringAddC(); next(); break; case Com2: next(); break; case ComE: next(); break; case Done: next(); break; } } } /* Parse an Attribute [41]. Precondition: the head stands on the first character of the name of the attribute (i.e. all whitespaces are already parsed). The head stand on the next character after the end quotes. The variable name contains the name of the attribute and the variable string contains the value of the attribute. */ bool TQXmlSimpleReader::parseAttribute() { const int Init = 0; const int PName = 1; // parse name const int Ws = 2; // eat ws const int Eq = 3; // the '=' was read const int Quotes = 4; // " or ' were read const int InpNameBe = 0; const int InpEq = 1; // = const int InpDq = 2; // " const int InpSq = 3; // ' const int InpUnknown = 4; static const int table[4][5] = { /* InpNameBe InpEq InpDq InpSq InpUnknown */ { PName, -1, -1, -1, -1 }, // Init { -1, Eq, -1, -1, Ws }, // PName { -1, Eq, -1, -1, -1 }, // Ws { -1, -1, Quotes, Quotes, -1 } // Eq }; int state; int input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseAttribute (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } } } for (;;) { switch ( state ) { case Quotes: // Done return TRUE; case -1: // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } if ( determineNameChar(c) == NameBeginning ) { input = InpNameBe; } else if ( c.unicode() == '=' ) { input = InpEq; } else if ( c.unicode() == '"' ) { input = InpDq; } else if ( c.unicode() == '\'' ) { input = InpSq; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case PName: d->parseName_useRef = FALSE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } break; case Ws: if ( !eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } break; case Eq: if ( !next_eat_ws() ) { parseFailed( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } break; case Quotes: if ( !parseAttValue() ) { parseFailed( &TQXmlSimpleReader::parseAttribute, state ); return FALSE; } break; } } } /* Parse a Name [5] and store the name in name or ref (if useRef is TRUE). */ bool TQXmlSimpleReader::parseName() { const int Init = 0; const int Name1 = 1; // parse first signed character of the name const int Name = 2; // parse name const int Done = 3; const int InpNameBe = 0; // name beginning signed characters const int InpNameCh = 1; // NameChar without InpNameBe const int InpUnknown = 2; Q_ASSERT(InpNameBe == (int)NameBeginning); Q_ASSERT(InpNameCh == (int)NameNotBeginning); Q_ASSERT(InpUnknown == (int)NotName); static const int table[3][3] = { /* InpNameBe InpNameCh InpUnknown */ { Name1, -1, -1 }, // Init { Name, Name, Done }, // Name1 { Name, Name, Done } // Name }; int state; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseName (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseName, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseName, state ); return FALSE; } // we can safely do the (int) cast thanks to the Q_ASSERTs earlier in this function state = table[state][(int)fastDetermineNameChar(c)]; switch ( state ) { case Name1: if ( d->parseName_useRef ) { refClear(); refAddC(); } else { nameClear(); nameAddC(); } next(); break; case Name: if ( d->parseName_useRef ) { refAddC(); } else { nameAddC(); } next(); break; } } } /* Parse a Nmtoken [7] and store the name in name. */ bool TQXmlSimpleReader::parseNmtoken() { const signed char Init = 0; const signed char NameF = 1; const signed char Name = 2; const signed char Done = 3; const signed char InpNameCh = 0; // NameChar without InpNameBe const signed char InpUnknown = 1; static const signed char table[3][2] = { /* InpNameCh InpUnknown */ { NameF, -1 }, // Init { Name, Done }, // NameF { Name, Done } // Name }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseNmtoken (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseNmtoken, state ); return FALSE; } } } for (;;) { switch ( state ) { case Done: return TRUE; case -1: // Error reportParseError( XMLERR_LETTEREXPECTED ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseNmtoken, state ); return FALSE; } if (determineNameChar(c) == NotName) { input = InpUnknown; } else { input = InpNameCh; } state = table[state][input]; switch ( state ) { case NameF: nameClear(); nameAddC(); next(); break; case Name: nameAddC(); next(); break; } } } /* Parse a Reference [67]. parseReference_charDataRead is set to TRUE if the reference must not be parsed. The character(s) which the reference mapped to are appended to string. The head stands on the first character after the reference. parseReference_charDataRead is set to FALSE if the reference must be parsed. The charachter(s) which the reference mapped to are inserted at the reference position. The head stands on the first character of the replacement). */ bool TQXmlSimpleReader::parseReference() { // temporary variables (only used in very local context, so they don't // interfere with incremental parsing) uint tmp; bool ok; const signed char Init = 0; const signed char SRef = 1; // start of a reference const signed char ChRef = 2; // parse CharRef const signed char ChDec = 3; // parse CharRef decimal const signed char ChHexS = 4; // start CharRef hexadecimal const signed char ChHex = 5; // parse CharRef hexadecimal const signed char Name = 6; // parse name const signed char DoneD = 7; // done CharRef decimal const signed char DoneH = 8; // done CharRef hexadecimal const signed char DoneN = 9; // done EntityRef const signed char InpAmp = 0; // & const signed char InpSemi = 1; // ; const signed char InpHash = 2; // # const signed char InpX = 3; // x const signed char InpNum = 4; // 0-9 const signed char InpHex = 5; // a-f A-F const signed char InpUnknown = 6; static const signed char table[8][7] = { /* InpAmp InpSemi InpHash InpX InpNum InpHex InpUnknown */ { SRef, -1, -1, -1, -1, -1, -1 }, // Init { -1, -1, ChRef, Name, Name, Name, Name }, // SRef { -1, -1, -1, ChHexS, ChDec, -1, -1 }, // ChRef { -1, DoneD, -1, -1, ChDec, -1, -1 }, // ChDec { -1, -1, -1, -1, ChHex, ChHex, -1 }, // ChHexS { -1, DoneH, -1, -1, ChHex, ChHex, -1 }, // ChHex { -1, DoneN, -1, -1, -1, -1, -1 } // Name }; signed char state; signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->parseReference_charDataRead = FALSE; state = Init; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseReference (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseReference, state ); return FALSE; } } } for (;;) { switch ( state ) { case DoneD: return TRUE; case DoneH: return TRUE; case DoneN: return TRUE; case -1: // Error reportParseError( XMLERR_ERRORPARSINGREFERENCE ); return FALSE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseReference, state ); return FALSE; } if ( c.row() ) { input = InpUnknown; } else if ( c.cell() == '&' ) { input = InpAmp; } else if ( c.cell() == ';' ) { input = InpSemi; } else if ( c.cell() == '#' ) { input = InpHash; } else if ( c.cell() == 'x' ) { input = InpX; } else if ( '0' <= c.cell() && c.cell() <= '9' ) { input = InpNum; } else if ( 'a' <= c.cell() && c.cell() <= 'f' ) { input = InpHex; } else if ( 'A' <= c.cell() && c.cell() <= 'F' ) { input = InpHex; } else { input = InpUnknown; } state = table[state][input]; switch ( state ) { case SRef: refClear(); next(); break; case ChRef: next(); break; case ChDec: refAddC(); next(); break; case ChHexS: next(); break; case ChHex: refAddC(); next(); break; case Name: // read the name into the ref d->parseName_useRef = TRUE; if ( !parseName() ) { parseFailed( &TQXmlSimpleReader::parseReference, state ); return FALSE; } break; case DoneD: tmp = ref().toUInt( &ok, 10 ); if ( ok ) { stringAddC( TQChar(tmp) ); } else { reportParseError( XMLERR_ERRORPARSINGREFERENCE ); return FALSE; } d->parseReference_charDataRead = TRUE; next(); break; case DoneH: tmp = ref().toUInt( &ok, 16 ); if ( ok ) { stringAddC( TQChar(tmp) ); } else { reportParseError( XMLERR_ERRORPARSINGREFERENCE ); return FALSE; } d->parseReference_charDataRead = TRUE; next(); break; case DoneN: if ( !processReference() ) return FALSE; next(); break; } } } /* This private function is only called by TQDom. It avoids a data corruption bug whereby undefined entities in attribute values would be appended after the element that contained them. The solution is not perfect - the undefined entity reference is replaced by an empty string. The propper fix will come in TQt4, when SAX will be extended so that attribute values can be made up of multiple children, rather than just a single string value. */ void TQXmlSimpleReader::setUndefEntityInAttrHack(bool b) { d->undefEntityInAttrHack = b; } /* Helper function for parseReference() */ bool TQXmlSimpleReader::processReference() { TQString reference = ref(); if ( reference == "amp" ) { if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'm' ); stringAddC( 'p' ); stringAddC( ';' ); } else { // Included or Included in literal stringAddC( '&' ); } d->parseReference_charDataRead = TRUE; } else if ( reference == "lt" ) { if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); stringAddC( 'l' ); stringAddC( 't' ); stringAddC( ';' ); } else { // Included or Included in literal stringAddC( '<' ); } d->parseReference_charDataRead = TRUE; } else if ( reference == "gt" ) { if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); stringAddC( 'g' ); stringAddC( 't' ); stringAddC( ';' ); } else { // Included or Included in literal stringAddC( '>' ); } d->parseReference_charDataRead = TRUE; } else if ( reference == "apos" ) { if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); stringAddC( 'a' ); stringAddC( 'p' ); stringAddC( 'o' ); stringAddC( 's' ); stringAddC( ';' ); } else { // Included or Included in literal stringAddC( '\'' ); } d->parseReference_charDataRead = TRUE; } else if ( reference == "quot" ) { if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); stringAddC( 'q' ); stringAddC( 'u' ); stringAddC( 'o' ); stringAddC( 't' ); stringAddC( ';' ); } else { // Included or Included in literal stringAddC( '"' ); } d->parseReference_charDataRead = TRUE; } else { TQMap::Iterator it; it = d->entities.find( reference ); if ( it != d->entities.end() ) { // "Internal General" switch ( d->parseReference_context ) { case InContent: // Included if ( !insertXmlRef( it.data(), reference, FALSE ) ) return FALSE; d->parseReference_charDataRead = FALSE; break; case InAttributeValue: // Included in literal if ( !insertXmlRef( it.data(), reference, TRUE ) ) return FALSE; d->parseReference_charDataRead = FALSE; break; case InEntityValue: { // Bypassed stringAddC( '&' ); for ( int i=0; i<(int)reference.length(); i++ ) { stringAddC( reference[i] ); } stringAddC( ';'); d->parseReference_charDataRead = TRUE; } break; case InDTD: // Forbidden d->parseReference_charDataRead = FALSE; reportParseError( XMLERR_INTERNALGENERALENTITYINDTD ); return FALSE; } } else { TQMap::Iterator itExtern; itExtern = d->externEntities.find( reference ); if ( itExtern == d->externEntities.end() ) { // entity not declared // ### check this case for conformance if ( d->parseReference_context == InEntityValue ) { // Bypassed stringAddC( '&' ); for ( int i=0; i<(int)reference.length(); i++ ) { stringAddC( reference[i] ); } stringAddC( ';'); d->parseReference_charDataRead = TRUE; } else { if ( contentHnd && !(d->parseReference_context == InAttributeValue && d->undefEntityInAttrHack)) { if ( !contentHnd->skippedEntity( reference ) ) { reportParseError( contentHnd->errorString() ); return FALSE; // error } } } } else if ( (*itExtern).notation.isNull() ) { // "External Parsed General" switch ( d->parseReference_context ) { case InContent: { // Included if validating bool skipIt = TRUE; if ( entityRes ) { TQXmlInputSource *ret = 0; if ( !entityRes->resolveEntity( itExtern.data().publicId, itExtern.data().systemId, ret ) ) { delete ret; reportParseError( entityRes->errorString() ); return FALSE; } if ( ret ) { TQString xmlRefString = ret->data(); delete ret; if ( !stripTextDecl( xmlRefString ) ) { reportParseError( XMLERR_ERRORINTEXTDECL ); return FALSE; } if ( !insertXmlRef( xmlRefString, reference, FALSE ) ) return FALSE; skipIt = FALSE; } } if ( skipIt && contentHnd ) { if ( !contentHnd->skippedEntity( reference ) ) { reportParseError( contentHnd->errorString() ); return FALSE; // error } } d->parseReference_charDataRead = FALSE; } break; case InAttributeValue: // Forbidden d->parseReference_charDataRead = FALSE; reportParseError( XMLERR_EXTERNALGENERALENTITYINAV ); return FALSE; case InEntityValue: { // Bypassed stringAddC( '&' ); for ( int i=0; i<(int)reference.length(); i++ ) { stringAddC( reference[i] ); } stringAddC( ';'); d->parseReference_charDataRead = TRUE; } break; case InDTD: // Forbidden d->parseReference_charDataRead = FALSE; reportParseError( XMLERR_EXTERNALGENERALENTITYINDTD ); return FALSE; } } else { // "Unparsed" // ### notify for "Occurs as Attribute Value" missing (but this is no refence, anyway) // Forbidden d->parseReference_charDataRead = FALSE; reportParseError( XMLERR_UNPARSEDENTITYREFERENCE ); return FALSE; // error } } } return TRUE; // no error } /* Parses over a simple string. After the string was successfully parsed, the head is on the first character after the string. */ bool TQXmlSimpleReader::parseString() { const signed char InpCharExpected = 0; // the character that was expected const signed char InpUnknown = 1; signed char state; // state in this function is the position in the string s signed char input; if ( d->parseStack==0 || d->parseStack->isEmpty() ) { d->Done = d->parseString_s.length(); state = 0; } else { state = d->parseStack->pop().state; #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: parseString (cont) in state %d", state ); #endif if ( !d->parseStack->isEmpty() ) { ParseFunction function = d->parseStack->top().function; if ( function == &TQXmlSimpleReader::eat_ws ) { d->parseStack->pop(); #if defined(QT_QXML_DEBUG) tqDebug( "TQXmlSimpleReader: eat_ws (cont)" ); #endif } if ( !(this->*function)() ) { parseFailed( &TQXmlSimpleReader::parseString, state ); return FALSE; } } } for (;;) { if ( state == d->Done ) { return TRUE; } if ( atEnd() ) { unexpectedEof( &TQXmlSimpleReader::parseString, state ); return FALSE; } if ( c == d->parseString_s[(int)state] ) { input = InpCharExpected; } else { input = InpUnknown; } if ( input == InpCharExpected ) { state++; } else { // Error reportParseError( XMLERR_UNEXPECTEDCHARACTER ); return FALSE; } next(); } } /* This private function inserts and reports an entity substitution. The substituted string is \a data and the name of the entity reference is \a name. If \a inLiteral is TRUE, the entity is IncludedInLiteral (i.e., " and ' must be quoted. Otherwise they are not quoted. This function returns FALSE on error. */ bool TQXmlSimpleReader::insertXmlRef( const TQString &data, const TQString &name, bool inLiteral ) { if ( inLiteral ) { TQString tmp = data; d->xmlRef.push( tmp.replace( "\"", """ ).replace( "'", "'" ) ); } else { d->xmlRef.push( data ); } d->xmlRefName.push( name ); uint n = (uint)TQMAX( d->parameterEntities.count(), d->entities.count() ); if ( d->xmlRefName.count() > n+1 ) { // recursive entities reportParseError( XMLERR_RECURSIVEENTITIES ); return FALSE; } if ( d->reportEntities && lexicalHnd ) { if ( !lexicalHnd->startEntity( name ) ) { reportParseError( lexicalHnd->errorString() ); return FALSE; } } return TRUE; } /* This private function moves the cursor to the next character. */ void TQXmlSimpleReader::next() { int count = (int)d->xmlRef.count(); while ( count != 0 ) { if ( d->xmlRef.top().isEmpty() ) { d->xmlRef.pop_back(); d->xmlRefName.pop_back(); count--; } else { c = d->xmlRef.top().constref( 0 ); d->xmlRef.top().remove( (uint)0, 1 ); return; } } // the following could be written nicer, but since it is a time-critical // function, rather optimize for speed ushort uc = c.unicode(); if (uc == '\n') { c = inputSource->next(); lineNr++; columnNr = -1; } else if ( uc == '\r' ) { c = inputSource->next(); if ( c.unicode() != '\n' ) { lineNr++; columnNr = -1; } } else { c = inputSource->next(); } ++columnNr; } /* This private function moves the cursor to the next non-whitespace character. This function does not move the cursor if the actual cursor position is a non-whitespace charcter. Returns FALSE when you use incremental parsing and this function reaches EOF with reading only whitespace characters. In this case it also poplulates the parseStack with useful information. In all other cases, this function returns TRUE. */ bool TQXmlSimpleReader::eat_ws() { while ( !atEnd() ) { if ( !is_S(c) ) { return TRUE; } next(); } if ( d->parseStack != 0 ) { unexpectedEof( &TQXmlSimpleReader::eat_ws, 0 ); return FALSE; } return TRUE; } bool TQXmlSimpleReader::next_eat_ws() { next(); return eat_ws(); } /* This private function initializes the reader. \a i is the input source to read the data from. */ void TQXmlSimpleReader::init( const TQXmlInputSource *i ) { lineNr = 0; columnNr = -1; inputSource = (TQXmlInputSource *)i; initData(); d->externParameterEntities.clear(); d->parameterEntities.clear(); d->externEntities.clear(); d->entities.clear(); d->tags.clear(); d->doctype = ""; d->xmlVersion = ""; d->encoding = ""; d->standalone = TQXmlSimpleReaderPrivate::Unknown; d->error = TQString::null; } /* This private function initializes the XML data related variables. Especially, it reads the data from the input source. */ void TQXmlSimpleReader::initData() { c = TQXmlInputSource::EndOfData; d->xmlRef.clear(); next(); } /* Returns TRUE if a entity with the name \a e exists, otherwise returns FALSE. */ bool TQXmlSimpleReader::entityExist( const TQString& e ) const { if ( d->parameterEntities.find(e) == d->parameterEntities.end() && d->externParameterEntities.find(e) == d->externParameterEntities.end() && d->externEntities.find(e) == d->externEntities.end() && d->entities.find(e) == d->entities.end() ) { return FALSE; } else { return TRUE; } } void TQXmlSimpleReader::reportParseError( const TQString& error ) { d->error = error; if ( errorHnd ) { if ( d->error.isNull() ) { errorHnd->fatalError( TQXmlParseException( XMLERR_OK, columnNr+1, lineNr+1 ) ); } else { errorHnd->fatalError( TQXmlParseException( d->error, columnNr+1, lineNr+1 ) ); } } } /* This private function is called when a parsing function encounters an unexpected EOF. It decides what to do (depending on incremental parsing or not). \a where is a pointer to the function where the error occurred and \a state is the parsing state in this function. */ void TQXmlSimpleReader::unexpectedEof( ParseFunction where, int state ) { if ( d->parseStack == 0 ) { reportParseError( XMLERR_UNEXPECTEDEOF ); } else { if ( c == TQXmlInputSource::EndOfDocument ) { reportParseError( XMLERR_UNEXPECTEDEOF ); } else { pushParseState( where, state ); } } } /* This private function is called when a parse...() function returned FALSE. It determines if there was an error or if incremental parsing simply went out of data and does the right thing for the case. \a where is a pointer to the function where the error occurred and \a state is the parsing state in this function. */ void TQXmlSimpleReader::parseFailed( ParseFunction where, int state ) { if ( d->parseStack!=0 && d->error.isNull() ) { pushParseState( where, state ); } } /* This private function pushes the function pointer \a function and state \a state to the parse stack. This is used when you are doing an incremental parsing and reach the end of file too early. Only call this function when d->parseStack!=0. */ void TQXmlSimpleReader::pushParseState( ParseFunction function, int state ) { TQXmlSimpleReaderPrivate::ParseState ps; ps.function = function; ps.state = state; d->parseStack->push( ps ); } inline static void updateValue(TQString &value, const TQChar *array, int &arrayPos, int &valueLen) { value.setLength(valueLen + arrayPos); memcpy(const_cast(value.unicode()) + valueLen, array, arrayPos * sizeof(TQChar)); valueLen += arrayPos; arrayPos = 0; } // use buffers instead of TQString::operator+= when single characters are read const TQString& TQXmlSimpleReader::string() { updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen); return stringValue; } const TQString& TQXmlSimpleReader::name() { updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen); return nameValue; } const TQString& TQXmlSimpleReader::ref() { updateValue(refValue, refArray, refArrayPos, d->refValueLen); return refValue; } void TQXmlSimpleReader::stringAddC(const TQChar &ch) { if (stringArrayPos == 256) updateValue(stringValue, stringArray, stringArrayPos, d->stringValueLen); stringArray[stringArrayPos++] = ch; } void TQXmlSimpleReader::nameAddC(const TQChar &ch) { if (nameArrayPos == 256) updateValue(nameValue, nameArray, nameArrayPos, d->nameValueLen); nameArray[nameArrayPos++] = ch; } void TQXmlSimpleReader::refAddC(const TQChar &ch) { if (refArrayPos == 256) updateValue(refValue, refArray, refArrayPos, d->refValueLen); refArray[refArrayPos++] = ch; } void TQXmlSimpleReader::stringClear() { d->stringValueLen = 0; stringArrayPos = 0; } #endif //TQT_NO_XML