| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef BOOTSTRP_XMLPARSE_HXX |
| #define BOOTSTRP_XMLPARSE_HXX |
| |
| #include <signal.h> |
| #include <expat.h> |
| #include <rtl/ustring.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include "tools/string.hxx" |
| #include "tools/list.hxx" |
| #define ENABLE_BYTESTRING_STREAM_OPERATORS |
| #include "tools/stream.hxx" |
| #include "tools/isofallback.hxx" |
| #include "export.hxx" |
| #include "xmlutil.hxx" |
| |
| #include <fstream> |
| #include <iostream> |
| |
| class XMLParentNode; |
| class XMLElement; |
| |
| |
| using namespace ::rtl; |
| using namespace std; |
| |
| #include <hash_map> /* std::hashmap*/ |
| #include <deque> /* std::deque*/ |
| #include <iterator> /* std::iterator*/ |
| #include <list> /* std::list*/ |
| #include <vector> /* std::vector*/ |
| #define XML_NODE_TYPE_FILE 0x001 |
| #define XML_NODE_TYPE_ELEMENT 0x002 |
| #define XML_NODE_TYPE_DATA 0x003 |
| #define XML_NODE_TYPE_COMMENT 0x004 |
| #define XML_NODE_TYPE_DEFAULT 0x005 |
| #define MAX_LANGUAGES 99 |
| |
| |
| //#define TESTDRIVER /* use xml2gsi testclass */ |
| //------------------------------------------------------------------------- |
| |
| /** Holds data of Attributes |
| */ |
| class XMLAttribute : public String |
| { |
| private: |
| String sValue; |
| |
| public: |
| /// creates an attribute |
| XMLAttribute( |
| const String &rName, // attributes name |
| const String &rValue // attributes data |
| ) |
| : String( rName ), sValue( rValue ) {} |
| |
| /// getting value of an attribue |
| const String &GetValue() { return sValue; } |
| |
| void setValue(const String &rValue){sValue=rValue;} |
| |
| /// returns true if two attributes are equal and have the same value |
| sal_Bool IsEqual( |
| const XMLAttribute &rAttribute // the attribute which has to be equal |
| ) |
| { |
| return (( rAttribute == *this ) && ( rAttribute.sValue == sValue )); |
| } |
| }; |
| |
| DECLARE_LIST( XMLAttributeList, XMLAttribute * ) |
| |
| //------------------------------------------------------------------------- |
| |
| /** Virtual base to handle different kinds of XML nodes |
| */ |
| class XMLNode |
| { |
| protected: |
| XMLNode() {} |
| |
| public: |
| virtual sal_uInt16 GetNodeType() = 0; |
| virtual ~XMLNode() {} |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| /** Virtual base to handle different kinds of child nodes |
| */ |
| class XMLChildNode : public XMLNode |
| { |
| private: |
| XMLParentNode *pParent; |
| |
| protected: |
| XMLChildNode( XMLParentNode *pPar ); |
| XMLChildNode():pParent( NULL ){}; |
| XMLChildNode( const XMLChildNode& obj); |
| XMLChildNode& operator=(const XMLChildNode& obj); |
| public: |
| virtual sal_uInt16 GetNodeType() = 0; |
| |
| /// returns the parent of this node |
| XMLParentNode *GetParent() { return pParent; } |
| virtual ~XMLChildNode(){}; |
| }; |
| |
| DECLARE_LIST( XMLChildNodeList, XMLChildNode * ) |
| |
| //------------------------------------------------------------------------- |
| |
| /** Virtual base to handle different kinds of parent nodes |
| */ |
| class XMLData; |
| |
| class XMLParentNode : public XMLChildNode |
| { |
| private: |
| XMLChildNodeList *pChildList; |
| static int dbgcnt; |
| //int nParentPos; |
| protected: |
| XMLParentNode( XMLParentNode *pPar ) |
| : XMLChildNode( pPar ), pChildList( NULL ) |
| { |
| } |
| XMLParentNode(): pChildList(NULL){ |
| } |
| /// Copyconstructor |
| XMLParentNode( const XMLParentNode& ); |
| |
| XMLParentNode& operator=(const XMLParentNode& obj); |
| virtual ~XMLParentNode(); |
| |
| |
| public: |
| virtual sal_uInt16 GetNodeType() = 0; |
| |
| /// returns child list of this node |
| XMLChildNodeList *GetChildList() { return pChildList; } |
| |
| /// adds a new child |
| void AddChild( |
| XMLChildNode *pChild /// the new child |
| ); |
| |
| void AddChild( |
| XMLChildNode *pChild , int pos /// the new child |
| ); |
| |
| virtual int GetPosition( ByteString id ); |
| int RemoveChild( XMLElement *pRefElement ); |
| void RemoveAndDeleteAllChilds(); |
| |
| /// returns a child element which matches the given one |
| XMLElement *GetChildElement( |
| XMLElement *pRefElement // the reference elelement |
| ); |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| DECLARE_LIST( XMLStringList, XMLElement* ) |
| |
| /// Mapping numeric Language code <-> XML Element |
| typedef std::hash_map< ByteString ,XMLElement* , hashByteString,equalByteString > LangHashMap; |
| |
| /// Mapping XML Element string identifier <-> Language Map |
| typedef std::hash_map<ByteString , LangHashMap* , |
| hashByteString,equalByteString> XMLHashMap; |
| |
| /// Mapping iso alpha string code <-> iso numeric code |
| typedef std::hash_map<ByteString, int, hashByteString,equalByteString> HashMap; |
| |
| /// Mapping XML tag names <-> have localizable strings |
| typedef std::hash_map<ByteString , sal_Bool , |
| hashByteString,equalByteString> TagMap; |
| |
| /** Holds information of a XML file, is root node of tree |
| */ |
| |
| |
| class XMLFile : public XMLParentNode |
| { |
| public: |
| XMLFile() ; |
| XMLFile( |
| const String &rFileName // the file name, empty if created from memory stream |
| ); |
| XMLFile( const XMLFile& obj ) ; |
| ~XMLFile(); |
| |
| ByteString* GetGroupID(std::deque<ByteString> &groupid); |
| void Print( XMLNode *pCur = NULL, sal_uInt16 nLevel = 0 ); |
| virtual void SearchL10NElements( XMLParentNode *pCur, int pos = 0 ); |
| void Extract( XMLFile *pCur = NULL ); |
| void View(); |
| // void static Signal_handler(int signo);//void*,oslSignalInfo * pInfo); |
| void showType(XMLParentNode* node); |
| |
| XMLHashMap* GetStrings(){return XMLStrings;} |
| sal_Bool Write( ByteString &rFilename ); |
| sal_Bool Write( ofstream &rStream , XMLNode *pCur = NULL ); |
| |
| bool CheckExportStatus( XMLParentNode *pCur = NULL );// , int pos = 0 ); |
| |
| XMLFile& operator=(const XMLFile& obj); |
| |
| virtual sal_uInt16 GetNodeType(); |
| |
| /// returns file name |
| const String &GetName() { return sFileName; } |
| void SetName( const String &rFilename ) { sFileName = rFilename; } |
| void SetFullName( const String &rFullFilename ) { sFullName = rFullFilename; } |
| const std::vector<ByteString> getOrder(){ return order; } |
| |
| protected: |
| // writes a string as UTF8 with dos line ends to a given stream |
| void WriteString( ofstream &rStream, const String &sString ); |
| |
| // quotes the given text for writing to a file |
| void QuotHTML( String &rString ); |
| |
| void InsertL10NElement( XMLElement* pElement); |
| |
| // DATA |
| String sFileName; |
| String sFullName; |
| |
| const ByteString ID,OLDREF,XML_LANG; |
| |
| TagMap nodes_localize; |
| XMLHashMap* XMLStrings; |
| |
| std::vector <ByteString> order; |
| }; |
| |
| /// An Utility class for XML |
| /// See RFC 3066 / #i8252# for ISO codes |
| class XMLUtil{ |
| |
| public: |
| /// Quot the XML characters and replace \n \t |
| static void QuotHTML( String &rString ); |
| |
| /// UnQuot the XML characters and restore \n \t |
| static void UnQuotHTML ( String &rString ); |
| |
| /// Return the numeric iso language code |
| //sal_uInt16 GetLangByIsoLang( const ByteString &rIsoLang ); |
| |
| /// Return the alpha strings representation |
| ByteString GetIsoLangByIndex( sal_uInt16 nIndex ); |
| |
| static XMLUtil& Instance(); |
| ~XMLUtil(); |
| |
| void dump(); |
| |
| private: |
| /// Mapping iso alpha string code <-> iso numeric code |
| HashMap lMap; |
| |
| /// Mapping iso numeric code <-> iso alpha string code |
| ByteString isoArray[MAX_LANGUAGES]; |
| |
| static void UnQuotData( String &rString ); |
| static void UnQuotTags( String &rString ); |
| |
| XMLUtil(); |
| XMLUtil(const XMLUtil&); |
| |
| }; |
| |
| |
| |
| //------------------------------------------------------------------------- |
| |
| /** Hold information of an element node |
| */ |
| class XMLElement : public XMLParentNode |
| { |
| private: |
| String sElementName; |
| XMLAttributeList *pAttributes; |
| ByteString project, |
| filename, |
| id, |
| sOldRef, |
| resourceType, |
| languageId; |
| int nPos; |
| |
| protected: |
| void Print(XMLNode *pCur, OUStringBuffer& buffer , bool rootelement); |
| public: |
| /// create a element node |
| XMLElement(){} |
| XMLElement( |
| const String &rName, // the element name |
| XMLParentNode *Parent // parent node of this element |
| ): XMLParentNode( Parent ), |
| sElementName( rName ), |
| pAttributes( NULL ), |
| project(""), |
| filename(""), |
| id(""), |
| sOldRef(""), |
| resourceType(""), |
| languageId(""), |
| nPos(0) |
| { |
| } |
| ~XMLElement(); |
| XMLElement(const XMLElement&); |
| |
| XMLElement& operator=(const XMLElement& obj); |
| /// returns node type XML_NODE_ELEMENT |
| virtual sal_uInt16 GetNodeType(); |
| |
| /// returns element name |
| const String &GetName() { return sElementName; } |
| |
| /// returns list of attributes of this element |
| XMLAttributeList *GetAttributeList() { return pAttributes; } |
| |
| /// adds a new attribute to this element, typically used by parser |
| void AddAttribute( const String &rAttribute, const String &rValue ); |
| |
| void ChangeLanguageTag( const String &rValue ); |
| // Return a ASCII String representation of this object |
| OString ToOString(); |
| |
| // Return a Unicode String representation of this object |
| OUString ToOUString(); |
| |
| bool Equals(OUString refStr); |
| |
| /// returns a attribute |
| XMLAttribute *GetAttribute( |
| const String &rName // the attribute name |
| ); |
| void SetProject ( ByteString prj ){ project = prj; } |
| void SetFileName ( ByteString fn ){ filename = fn; } |
| void SetId ( ByteString theId ){ id = theId; } |
| void SetResourceType ( ByteString rt ){ resourceType = rt; } |
| void SetLanguageId ( ByteString lid ){ languageId = lid; } |
| void SetPos ( int nPos_in ){ nPos = nPos_in; } |
| void SetOldRef ( ByteString sOldRef_in ){ sOldRef = sOldRef_in; } |
| |
| virtual int GetPos() { return nPos; } |
| ByteString GetProject() { return project; } |
| ByteString GetFileName() { return filename; } |
| ByteString GetId() { return id; } |
| ByteString GetOldref() { return sOldRef; } |
| ByteString GetResourceType(){ return resourceType; } |
| ByteString GetLanguageId() { return languageId; } |
| |
| |
| }; |
| //------------------------------------------------------------------------- |
| |
| |
| /** Holds character data |
| */ |
| class XMLData : public XMLChildNode |
| { |
| private: |
| String sData; |
| bool isNewCreated; |
| |
| public: |
| /// create a data node |
| XMLData( |
| const String &rData, // the initial data |
| XMLParentNode *Parent // the parent node of this data, typically a element node |
| ) |
| : XMLChildNode( Parent ), sData( rData ) , isNewCreated ( false ){} |
| XMLData( |
| const String &rData, // the initial data |
| XMLParentNode *Parent, // the parent node of this data, typically a element node |
| bool newCreated |
| ) |
| : XMLChildNode( Parent ), sData( rData ) , isNewCreated ( newCreated ){} |
| |
| XMLData(const XMLData& obj); |
| |
| XMLData& operator=(const XMLData& obj); |
| virtual sal_uInt16 GetNodeType(); |
| |
| /// returns the data |
| const String &GetData() { return sData; } |
| |
| bool isNew() { return isNewCreated; } |
| /// adds new character data to the existing one |
| void AddData( |
| const String &rData // the new data |
| ); |
| |
| |
| |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| /** Holds comments |
| */ |
| class XMLComment : public XMLChildNode |
| { |
| private: |
| String sComment; |
| |
| public: |
| /// create a comment node |
| XMLComment( |
| const String &rComment, // the comment |
| XMLParentNode *Parent // the parent node of this comemnt, typically a element node |
| ) |
| : XMLChildNode( Parent ), sComment( rComment ) {} |
| |
| virtual sal_uInt16 GetNodeType(); |
| |
| XMLComment( const XMLComment& obj ); |
| |
| XMLComment& operator=(const XMLComment& obj); |
| |
| /// returns the comment |
| const String &GetComment() { return sComment; } |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| /** Holds additional file content like those for which no handler exists |
| */ |
| class XMLDefault : public XMLChildNode |
| { |
| private: |
| String sDefault; |
| |
| public: |
| /// create a comment node |
| XMLDefault( |
| const String &rDefault, // the comment |
| XMLParentNode *Parent // the parent node of this comemnt, typically a element node |
| ) |
| : XMLChildNode( Parent ), sDefault( rDefault ) {} |
| |
| XMLDefault(const XMLDefault& obj); |
| |
| XMLDefault& operator=(const XMLDefault& obj); |
| |
| /// returns node type XML_NODE_TYPE_COMMENT |
| virtual sal_uInt16 GetNodeType(); |
| |
| /// returns the comment |
| const String &GetDefault() { return sDefault; } |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| /** struct for error information, used by class SimpleXMLParser |
| */ |
| struct XMLError { |
| XML_Error eCode; // the error code |
| sal_uLong nLine; // error line number |
| sal_uLong nColumn; // error column number |
| String sMessage; // readable error message |
| }; |
| |
| //------------------------------------------------------------------------- |
| |
| /** validating xml parser, creates a document tree with xml nodes |
| */ |
| |
| |
| class SimpleXMLParser |
| { |
| private: |
| XML_Parser aParser; |
| XMLError aErrorInformation; |
| |
| XMLFile *pXMLFile; |
| XMLParentNode *pCurNode; |
| XMLData *pCurData; |
| |
| |
| static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts ); |
| static void EndElementHandler( void *userData, const XML_Char *name ); |
| static void CharacterDataHandler( void *userData, const XML_Char *s, int len ); |
| static void CommentHandler( void *userData, const XML_Char *data ); |
| static void DefaultHandler( void *userData, const XML_Char *s, int len ); |
| |
| |
| void StartElement( const XML_Char *name, const XML_Char **atts ); |
| void EndElement( const XML_Char *name ); |
| void CharacterData( const XML_Char *s, int len ); |
| void Comment( const XML_Char *data ); |
| void Default( const XML_Char *s, int len ); |
| |
| |
| public: |
| /// creates a new parser |
| SimpleXMLParser(); |
| ~SimpleXMLParser(); |
| |
| /// parse a file, returns NULL on criticall errors |
| XMLFile *Execute( |
| const String &rFullFileName, |
| const String &rFileName, // the file name |
| XMLFile *pXMLFileIn // the XMLFile |
| ); |
| |
| /// parse a memory stream, returns NULL on criticall errors |
| XMLFile *Execute( |
| SvMemoryStream *pStream // the stream |
| ); |
| |
| /// returns an error struct |
| const XMLError &GetError() { return aErrorInformation; } |
| }; |
| |
| #endif |