summaryrefslogtreecommitdiffstats
path: root/l10ntools/inc/xmlparse.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'l10ntools/inc/xmlparse.hxx')
-rw-r--r--l10ntools/inc/xmlparse.hxx360
1 files changed, 360 insertions, 0 deletions
diff --git a/l10ntools/inc/xmlparse.hxx b/l10ntools/inc/xmlparse.hxx
new file mode 100644
index 000000000..9a8b1e673
--- /dev/null
+++ b/l10ntools/inc/xmlparse.hxx
@@ -0,0 +1,360 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+#ifndef INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
+#define INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
+
+#include <sal/config.h>
+
+#include <cstddef>
+#include <memory>
+#include <vector>
+
+#include <expat.h>
+
+#include <rtl/string.hxx>
+#include <rtl/strbuf.hxx>
+#include <unordered_map>
+
+class XMLParentNode;
+class XMLElement;
+
+enum class XMLNodeType{
+ XFILE = 0x001,
+ ELEMENT = 0x002,
+ DATA = 0x003,
+ COMMENT = 0x004,
+ DEFAULT = 0x005
+};
+
+/** Holds data of Attributes
+ */
+class XMLAttribute
+{
+private:
+ OString m_sName;
+ OString m_sValue;
+
+public:
+ /// creates an attribute
+ XMLAttribute(
+ const OString &rName, // attributes name
+ const OString &rValue // attributes data
+ )
+ : m_sName( rName ), m_sValue( rValue ) {}
+
+ const OString& GetName() const { return m_sName; }
+ const OString& GetValue() const { return m_sValue; }
+
+ void setValue( const OString &rValue ){ m_sValue = rValue; }
+};
+
+
+typedef std::vector< XMLAttribute* > XMLAttributeList;
+
+/** Virtual base to handle different kinds of XML nodes
+ */
+class XMLNode
+{
+protected:
+ XMLNode(){}
+
+public:
+ virtual XMLNodeType GetNodeType() const = 0;
+ virtual ~XMLNode(){}
+
+ XMLNode(XMLNode const &) = default;
+ XMLNode(XMLNode &&) = default;
+ XMLNode & operator =(XMLNode const &) = default;
+ XMLNode & operator =(XMLNode &&) = default;
+};
+
+
+/** Virtual base to handle different kinds of child nodes
+ */
+class XMLChildNode : public XMLNode
+{
+private:
+ XMLParentNode *m_pParent;
+
+protected:
+ XMLChildNode( XMLParentNode *pPar );
+ XMLChildNode( const XMLChildNode& rObj);
+ XMLChildNode& operator=(const XMLChildNode& rObj);
+public:
+ /// returns the parent of this node
+ XMLParentNode *GetParent() { return m_pParent; }
+};
+
+typedef std::vector< XMLChildNode* > XMLChildNodeList;
+
+class XMLData;
+
+/** Virtual base to handle different kinds of parent nodes
+ */
+
+class XMLParentNode : public XMLChildNode
+{
+private:
+ std::unique_ptr<XMLChildNodeList> m_pChildList;
+
+protected:
+ XMLParentNode( XMLParentNode *pPar )
+ : XMLChildNode( pPar ) {}
+
+ XMLParentNode( const XMLParentNode& );
+
+ XMLParentNode& operator=(const XMLParentNode& rObj);
+ virtual ~XMLParentNode() override;
+
+public:
+ /// returns child list of this node
+ XMLChildNodeList *GetChildList() { return m_pChildList.get(); }
+
+ /// adds a new child
+ void AddChild(
+ XMLChildNode *pChild /// the new child
+ );
+
+ void RemoveAndDeleteAllChildren();
+};
+
+/// Mapping numeric Language code <-> XML Element
+typedef std::unordered_map<OString, XMLElement*> LangHashMap;
+
+/// Mapping XML Element string identifier <-> Language Map
+typedef std::unordered_map<OString, LangHashMap*> XMLHashMap;
+
+/** Holds information of a XML file, is root node of tree
+ */
+class XMLFile final : public XMLParentNode
+{
+public:
+ XMLFile(
+ const OString &rFileName // the file name, empty if created from memory stream
+ );
+ XMLFile( const XMLFile& rObj ) ;
+ virtual ~XMLFile() override;
+
+ void Print( XMLNode *pCur, sal_uInt16 nLevel = 0 );
+ void SearchL10NElements( XMLChildNode *pCur );
+ void Extract();
+
+ XMLHashMap* GetStrings(){ return m_pXMLStrings.get(); }
+ void Write( OString const &rFilename );
+ void Write( std::ofstream &rStream, XMLNode *pCur = nullptr );
+
+ bool CheckExportStatus( XMLParentNode *pCur = nullptr );
+
+ XMLFile& operator=(const XMLFile& rObj);
+
+ virtual XMLNodeType GetNodeType() const override { return XMLNodeType::XFILE; }
+
+ /// returns file name
+ const OString& GetName() const { return m_sFileName; }
+ void SetName( const OString &rFilename ) { m_sFileName = rFilename; }
+ const std::vector<OString>& getOrder() const { return m_vOrder; }
+
+private:
+
+ void InsertL10NElement( XMLElement* pElement);
+
+ // DATA
+ OString m_sFileName;
+
+ /// Mapping XML tag names <-> have localizable strings
+ std::unordered_map<OString, bool> m_aNodes_localize;
+
+ std::unique_ptr<XMLHashMap> m_pXMLStrings;
+
+ std::vector <OString> m_vOrder;
+};
+
+/// A Utility class for XML
+class XMLUtil
+{
+public:
+ /// Quot the XML characters
+ static OString QuotHTML( const OString& rString );
+};
+
+
+/** Hold information of an element node
+ */
+class XMLElement : public XMLParentNode
+{
+private:
+ OString m_sElementName;
+ std::unique_ptr<XMLAttributeList> m_pAttributes;
+
+protected:
+ void Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement) const;
+public:
+ /// create an element node
+ XMLElement(
+ const OString &rName, // the element name
+ XMLParentNode *pParent // parent node of this element
+ );
+
+ virtual ~XMLElement() override;
+ XMLElement(const XMLElement&);
+
+ XMLElement& operator=(const XMLElement& rObj);
+ virtual XMLNodeType GetNodeType() const override { return XMLNodeType::ELEMENT; }
+
+ /// returns element name
+ const OString& GetName() const { return m_sElementName; }
+
+ /// returns list of attributes of this element
+ XMLAttributeList *GetAttributeList() { return m_pAttributes.get(); }
+
+ /// adds a new attribute to this element, typically used by parser
+ void AddAttribute( const OString &rAttribute, const OString &rValue );
+
+ void ChangeLanguageTag( const OString &rValue );
+
+ /// Return a Unicode String representation of this object
+ OString ToOString();
+};
+
+/** Holds character data
+ */
+class XMLData : public XMLChildNode
+{
+private:
+ OString m_sData;
+
+public:
+ /// create a data node
+ XMLData(
+ const OString &rData, // the initial data
+ XMLParentNode *pParent // the parent node of this data, typically an element node
+ )
+ : XMLChildNode( pParent ), m_sData( rData ) {}
+
+ // Default copy constructor and copy operator work well.
+
+ virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DATA; }
+
+ /// returns the data
+ const OString& GetData() const { return m_sData; }
+
+ /// adds new character data to the existing one
+ void AddData( const OString &rData ) { m_sData += rData; }
+};
+
+/** Holds comments
+ */
+class XMLComment final : public XMLChildNode
+{
+private:
+ OString m_sComment;
+
+public:
+ /// create a comment node
+ XMLComment(
+ const OString &rComment, // the comment
+ XMLParentNode *pParent // the parent node of this comment, typically an element node
+ )
+ : XMLChildNode( pParent ), m_sComment( rComment ) {}
+
+ // Default copy constructor and copy operator work well.
+
+ virtual XMLNodeType GetNodeType() const override { return XMLNodeType::COMMENT; }
+
+ /// returns the comment
+ const OString& GetComment() const { return m_sComment; }
+};
+
+/** Holds additional file content like those for which no handler exists
+ */
+class XMLDefault final : public XMLChildNode
+{
+private:
+ OString m_sDefault;
+
+public:
+ /// create a comment node
+ XMLDefault(
+ const OString &rDefault, // the comment
+ XMLParentNode *pParent // the parent node of this comment, typically an element node
+ )
+ : XMLChildNode( pParent ), m_sDefault( rDefault ) {}
+
+ // Default copy constructor and copy operator work well.
+
+ virtual XMLNodeType GetNodeType() const override { return XMLNodeType::DEFAULT; }
+
+ /// returns the comment
+ const OString& GetDefault() const { return m_sDefault; }
+};
+
+/** struct for error information, used by class SimpleXMLParser
+ */
+struct XMLError {
+ XML_Error m_eCode; ///< the error code
+ std::size_t m_nLine; ///< error line number
+ std::size_t m_nColumn; ///< error column number
+ OString m_sMessage; ///< readable error message
+};
+
+/** validating xml parser, creates a document tree with xml nodes
+ */
+
+class SimpleXMLParser
+{
+private:
+ XML_Parser m_aParser;
+ XMLError m_aErrorInformation;
+
+ XMLParentNode *m_pCurNode;
+ XMLData *m_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();
+ 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, return false on critical errors
+ bool Execute(
+ const OString &rFileName, // the file name
+ XMLFile* pXMLFile // the XMLFile
+ );
+
+ /// returns an error struct
+ const XMLError &GetError() const { return m_aErrorInformation; }
+};
+
+#endif // INCLUDED_L10NTOOLS_INC_XMLPARSE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */