l10ntools/inc/xmlparse.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
  21 #define INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
  22
  23 #include <sal/config.h>
  24
  25 #include <cstddef>
  26 #include <memory>
  27 #include <vector>
  28
  29 #include <signal.h>
  30
  31 #include <libxml/xmlexports.h>
  32 #include <expat.h>
  33
  34 #include <rtl/string.hxx>
  35 #include <rtl/strbuf.hxx>
  36 #include "export.hxx"
  37 #include <unordered_map>
  38
  39 class XMLParentNode;
  40 class XMLElement;
  41
  42 enum class XMLNodeType{
  43     XFILE   = 0x001,
  44     ELEMENT = 0x002,
  45     DATA    = 0x003,
  46     COMMENT = 0x004,
  47     DEFAULT = 0x005
  48 };
  49
  50 /** Holds data of Attributes
  51  */
  52 class XMLAttribute
  53 {
  54 private:
  55     OString m_sName;
  56     OString m_sValue;
  57
  58 public:
  59     /// creates an attribute
  60     XMLAttribute(
  61         const OString &rName,    // attributes name
  62         const OString &rValue    // attributes data
  63     )
  64     : m_sName( rName ), m_sValue( rValue ) {}
  65
  66     const OString& GetName() const { return m_sName; }
  67     const OString& GetValue() const { return m_sValue; }
  68
  69     void setValue( const OString &rValue ){ m_sValue = rValue; }
  70 };
  71
  72
  73 typedef std::vector< XMLAttribute* > XMLAttributeList;
  74
  75 /** Virtual base to handle different kinds of XML nodes
  76  */
  77 class XMLNode
  78 {
  79 protected:
  80     XMLNode(){}
  81
  82 public:
  83     virtual XMLNodeType GetNodeType() const = 0;
  84     virtual ~XMLNode(){}
  85 };
  86
  87
  88 /** Virtual base to handle different kinds of child nodes
  89  */
  90 class XMLChildNode : public XMLNode
  91 {
  92 private:
  93     XMLParentNode *m_pParent;
  94
  95 protected:
  96     XMLChildNode( XMLParentNode *pPar );
  97     XMLChildNode( const XMLChildNode& rObj);
  98     XMLChildNode& operator=(const XMLChildNode& rObj);
  99 public:
 100     /// returns the parent of this node
 101     XMLParentNode *GetParent() { return m_pParent; }
 102 };
 103
 104 typedef std::vector< XMLChildNode* > XMLChildNodeList;
 105
 106 class XMLData;
 107
 108 /** Virtual base to handle different kinds of parent nodes
 109  */
 110
 111 class XMLParentNode : public XMLChildNode
 112 {
 113 private:
 114     std::unique_ptr<XMLChildNodeList> m_pChildList;
 115
 116 protected:
 117     XMLParentNode( XMLParentNode *pPar )
 118         : XMLChildNode( pPar ) {}
 119
 120     XMLParentNode( const XMLParentNode& );
 121
 122     XMLParentNode& operator=(const XMLParentNode& rObj);
 123     virtual ~XMLParentNode() override;
 124
 125 public:
 126     /// returns child list of this node
 127     XMLChildNodeList *GetChildList() { return m_pChildList.get(); }
 128
 129     /// adds a new child
 130     void AddChild(
 131         XMLChildNode *pChild    /// the new child
 132     );
 133
 134     void RemoveAndDeleteAllChildren();
 135 };
 136
 137 /// Mapping numeric Language code <-> XML Element
 138 typedef std::unordered_map<OString, XMLElement*> LangHashMap;
 139
 140 /// Mapping XML Element string identifier <-> Language Map
 141 typedef std::unordered_map<OString, LangHashMap*> XMLHashMap;
 142
 143 /** Holds information of a XML file, is root node of tree
 144  */
 145 class XMLFile final : public XMLParentNode
 146 {
 147 public:
 148     XMLFile(
 149         const OString &rFileName // the file name, empty if created from memory stream
 150     );
 151     XMLFile( const XMLFile& rObj ) ;
 152     virtual ~XMLFile() override;
 153
 154     void Print( XMLNode *pCur, sal_uInt16 nLevel = 0 );
 155     void SearchL10NElements( XMLChildNode *pCur );
 156     void Extract();
 157
 158     XMLHashMap* GetStrings(){ return m_pXMLStrings.get(); }
 159     void Write( OString const &rFilename );
 160     bool Write( std::ofstream &rStream, XMLNode *pCur = nullptr );
 161
 162     bool CheckExportStatus( XMLParentNode *pCur = nullptr );
 163
 164     XMLFile& operator=(const XMLFile& rObj);
 165
 166     virtual XMLNodeType GetNodeType() const override { return XMLNodeType::XFILE; }
 167
 168     /// returns file name
 169     const OString& GetName() const { return m_sFileName; }
 170     void SetName( const OString &rFilename ) { m_sFileName = rFilename; }
 171     const std::vector<OString>& getOrder() const { return m_vOrder; }
 172
 173 private:
 174
 175     void InsertL10NElement( XMLElement* pElement);
 176
 177     // DATA
 178     OString m_sFileName;
 179
 180     /// Mapping XML tag names <-> have localizable strings
 181     std::unordered_map<OString, bool> m_aNodes_localize;
 182
 183     std::unique_ptr<XMLHashMap> m_pXMLStrings;
 184
 185     std::vector <OString> m_vOrder;
 186 };
 187
 188 /// An Utility class for XML
 189 class XMLUtil
 190 {
 191 public:
 192     /// Quot the XML characters
 193     static OString QuotHTML( const OString& rString );
 194 };
 195
 196
 197 /** Hold information of an element node
 198  */
 199 class XMLElement : public XMLParentNode
 200 {
 201 private:
 202     OString m_sElementName;
 203     std::unique_ptr<XMLAttributeList> m_pAttributes;
 204     OString m_sId;
 205     OString m_sLanguageId;
 206
 207 protected:
 208     void Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement) const;
 209 public:
 210     /// create an element node
 211     XMLElement(
 212         const OString &rName,    // the element name
 213         XMLParentNode *pParent   // parent node of this element
 214     );
 215
 216     virtual ~XMLElement() override;
 217     XMLElement(const XMLElement&);
 218
 219     XMLElement& operator=(const XMLElement& rObj);
 220     virtual XMLNodeType GetNodeType() const override { return XMLNodeType::ELEMENT; }
 221
 222     /// returns element name
 223     const OString& GetName() const { return m_sElementName; }
 224
 225     /// returns list of attributes of this element
 226     XMLAttributeList *GetAttributeList() { return m_pAttributes.get(); }
 227
 228     /// adds a new attribute to this element, typically used by parser
 229     void AddAttribute( const OString &rAttribute, const OString &rValue );
 230
 231     void ChangeLanguageTag( const OString &rValue );
 232
 233     /// Return a Unicode String representation of this object
 234     OString ToOString();
 235
 236     void SetId              ( OString const & sTheId )      { m_sId = sTheId; }
 237     void SetLanguageId      ( OString const & sLangId )     { m_sLanguageId = sLangId; }
 238 };
 239
 240 /** Holds character data
 241  */
 242 class XMLData : public XMLChildNode
 243 {
 244 private:
 245     OString m_sData;
 246
 247 public:
 248     /// create a data node
 249     XMLData(
 250         const OString &rData,    // the initial data
 251         XMLParentNode *pParent   // the parent node of this data, typically a element node
 252     )
 253         : XMLChildNode( pParent ), m_sData( rData ) {}
 254
 255     // Default copy constructor and copy operator work well.
 256
 257     virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DATA; }
 258
 259     /// returns the data
 260     const OString& GetData() const { return m_sData; }
 261
 262     /// adds new character data to the existing one
 263     void AddData( const OString &rData ) { m_sData += rData; }
 264 };
 265
 266 /** Holds comments
 267  */
 268 class XMLComment : public XMLChildNode
 269 {
 270 private:
 271     OString m_sComment;
 272
 273 public:
 274     /// create a comment node
 275     XMLComment(
 276         const OString &rComment, // the comment
 277         XMLParentNode *pParent   // the parent node of this comemnt, typically a element node
 278     )
 279         : XMLChildNode( pParent ), m_sComment( rComment ) {}
 280
 281     // Default copy constructor and copy operator work well.
 282
 283     virtual XMLNodeType GetNodeType() const override { return XMLNodeType::COMMENT; }
 284
 285     /// returns the comment
 286     const OString& GetComment() const { return m_sComment; }
 287 };
 288
 289 /** Holds additional file content like those for which no handler exists
 290  */
 291 class XMLDefault : public XMLChildNode
 292 {
 293 private:
 294     OString m_sDefault;
 295
 296 public:
 297     /// create a comment node
 298     XMLDefault(
 299         const OString &rDefault, // the comment
 300         XMLParentNode *pParent   // the parent node of this comemnt, typically a element node
 301     )
 302         : XMLChildNode( pParent ), m_sDefault( rDefault ) {}
 303
 304     // Default copy constructor and copy operator work well.
 305
 306     virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DEFAULT; }
 307
 308     /// returns the comment
 309     const OString& GetDefault() const { return m_sDefault; }
 310 };
 311
 312 /** struct for error information, used by class SimpleXMLParser
 313  */
 314 struct XMLError {
 315     XML_Error m_eCode;    ///< the error code
 316     std::size_t m_nLine; ///< error line number
 317     std::size_t m_nColumn; ///< error column number
 318     OString m_sMessage;    ///< readable error message
 319 };
 320
 321 /** validating xml parser, creates a document tree with xml nodes
 322  */
 323
 324 class SimpleXMLParser
 325 {
 326 private:
 327     XML_Parser m_aParser;
 328     XMLError m_aErrorInformation;
 329
 330     XMLParentNode *m_pCurNode;
 331     XMLData *m_pCurData;
 332
 333
 334     static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts );
 335     static void EndElementHandler( void *userData, const XML_Char *name );
 336     static void CharacterDataHandler( void *userData, const XML_Char *s, int len );
 337     static void CommentHandler( void *userData, const XML_Char *data );
 338     static void DefaultHandler( void *userData, const XML_Char *s, int len );
 339
 340
 341     void StartElement( const XML_Char *name, const XML_Char **atts );
 342     void EndElement();
 343     void CharacterData( const XML_Char *s, int len );
 344     void Comment( const XML_Char *data );
 345     void Default( const XML_Char *s, int len );
 346
 347 public:
 348     /// creates a new parser
 349     SimpleXMLParser();
 350     ~SimpleXMLParser();
 351
 352     /// parse a file, returns NULL on criticall errors
 353     XMLFile *Execute(
 354         const OString &rFileName,    // the file name
 355         XMLFile *pXMLFileIn         // the XMLFile
 356     );
 357
 358     /// returns an error struct
 359     const XMLError &GetError() const { return m_aErrorInformation; }
 360 };
 361
 362 #endif // INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
 363
 364 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */