mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up l10ntools xml parser.

Browse Source 
-Remove namespaces from header.
-Remove unused members (dbgcnt)
-Remove helpless methods (SetValue, copy ctr and operator,
inherited but not overriden virtual functions)
-Use prefixes for variables
-Use const where it possible
-Remove visual noise
-Correct indentation

Change-Id: I295be484dde157847cd16f260ec70d5cdb5b6fb4
This commit is contained in:
Zolnai Tamás
2013-09-18 20:30:41 +02:00
parent ede828789a
commit e808cae99e
3 changed files with 578 additions and 717 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
l10ntools/inc/xmlparse.hxx
View File

@@ -38,26 +38,19 @@
class XMLParentNode; class XMLParentNode;
class XMLElement; class XMLElement;
using namespace ::rtl;
using namespace std;
#define XML_NODE_TYPE_FILE 0x001 #define XML_NODE_TYPE_FILE 0x001
#define XML_NODE_TYPE_ELEMENT 0x002 #define XML_NODE_TYPE_ELEMENT 0x002
#define XML_NODE_TYPE_DATA 0x003 #define XML_NODE_TYPE_DATA 0x003
#define XML_NODE_TYPE_COMMENT 0x004 #define XML_NODE_TYPE_COMMENT 0x004
#define XML_NODE_TYPE_DEFAULT 0x005 #define XML_NODE_TYPE_DEFAULT 0x005
//-------------------------------------------------------------------------
/** Holds data of Attributes /** Holds data of Attributes
*/ */
class XMLAttribute class XMLAttribute
{ {
private: private:
OString sName; OString m_sName;
OString sValue; OString m_sValue;
public: public:
/// creates an attribute /// creates an attribute
@@ -65,25 +58,16 @@ public:
const OString &rName, // attributes name const OString &rName, // attributes name
const OString &rValue // attributes data const OString &rValue // attributes data
) )
: sName( rName ), sValue( rValue ) {} : m_sName( rName ), m_sValue( rValue ) {}
OString GetName() const { return sName; } OString GetName() const { return m_sName; }
OString GetValue() const { return sValue; } OString GetValue() const { return m_sValue; }
void setValue(const OString &rValue){sValue=rValue;} void setValue( const OString &rValue ){ m_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.sName == sName ) && ( rAttribute.sValue == sValue ));
}
}; };
typedef std::vector< XMLAttribute* > XMLAttributeList;
//------------------------------------------------------------------------- typedef std::vector< XMLAttribute* > XMLAttributeList;
/** Virtual base to handle different kinds of XML nodes /** Virtual base to handle different kinds of XML nodes
*/ */
@@ -93,36 +77,31 @@ protected:
XMLNode(){} XMLNode(){}
public: public:
virtual sal_uInt16 GetNodeType() = 0; virtual sal_uInt16 GetNodeType() const = 0;
virtual ~XMLNode(){} virtual ~XMLNode(){}
}; };
//-------------------------------------------------------------------------
/** Virtual base to handle different kinds of child nodes /** Virtual base to handle different kinds of child nodes
*/ */
class XMLChildNode : public XMLNode class XMLChildNode : public XMLNode
{ {
private: private:
XMLParentNode *pParent; XMLParentNode *m_pParent;
protected: protected:
XMLChildNode( XMLParentNode *pPar ); XMLChildNode( XMLParentNode *pPar );
XMLChildNode():pParent( NULL ){}; XMLChildNode(): m_pParent( NULL ){};
XMLChildNode( const XMLChildNode& obj); XMLChildNode( const XMLChildNode& rObj);
XMLChildNode& operator=(const XMLChildNode& obj); XMLChildNode& operator=(const XMLChildNode& rObj);
public: public:
virtual sal_uInt16 GetNodeType() = 0;
/// returns the parent of this node /// returns the parent of this node
XMLParentNode *GetParent() { return pParent; } XMLParentNode *GetParent() { return m_pParent; }
virtual ~XMLChildNode(){}; virtual ~XMLChildNode(){};
}; };
typedef std::vector< XMLChildNode* > XMLChildNodeList; typedef std::vector< XMLChildNode* > XMLChildNodeList;
//-------------------------------------------------------------------------
class XMLData; class XMLData;
/** Virtual base to handle different kinds of parent nodes /** Virtual base to handle different kinds of parent nodes
@@ -131,28 +110,21 @@ class XMLData;
class XMLParentNode : public XMLChildNode class XMLParentNode : public XMLChildNode
{ {
private: private:
XMLChildNodeList* pChildList; XMLChildNodeList* m_pChildList;
static int dbgcnt;
protected: protected:
XMLParentNode( XMLParentNode *pPar ) XMLParentNode( XMLParentNode *pPar )
: XMLChildNode( pPar ), pChildList( NULL ) : XMLChildNode( pPar ), m_pChildList( NULL ){}
{ XMLParentNode(): m_pChildList(NULL){}
}
XMLParentNode(): pChildList(NULL){
}
XMLParentNode( const XMLParentNode& ); XMLParentNode( const XMLParentNode& );
XMLParentNode& operator=(const XMLParentNode& obj); XMLParentNode& operator=(const XMLParentNode& rObj);
virtual ~XMLParentNode(); virtual ~XMLParentNode();
public: public:
virtual sal_uInt16 GetNodeType() = 0;
/// returns child list of this node /// returns child list of this node
XMLChildNodeList *GetChildList() { return pChildList; } XMLChildNodeList *GetChildList() { return m_pChildList; }
/// adds a new child /// adds a new child
void AddChild( void AddChild(
@@ -162,122 +134,103 @@ public:
void RemoveAndDeleteAllChildren(); void RemoveAndDeleteAllChildren();
}; };
//-------------------------------------------------------------------------
/// Mapping numeric Language code <-> XML Element /// Mapping numeric Language code <-> XML Element
typedef boost::unordered_map<OString, XMLElement*, OStringHash> LangHashMap; typedef boost::unordered_map<OString, XMLElement*, OStringHash> LangHashMap;
/// Mapping XML Element string identifier <-> Language Map /// Mapping XML Element string identifier <-> Language Map
typedef boost::unordered_map<OString, LangHashMap*, OStringHash> XMLHashMap; typedef boost::unordered_map<OString, LangHashMap*, OStringHash> XMLHashMap;
/// Mapping iso alpha string code <-> iso numeric code
typedef boost::unordered_map<OString, int, OStringHash> HashMap;
/// Mapping XML tag names <-> have localizable strings /// Mapping XML tag names <-> have localizable strings
typedef boost::unordered_map<OString, sal_Bool, OStringHash> TagMap; typedef boost::unordered_map<OString, sal_Bool, OStringHash> TagMap;
/** Holds information of a XML file, is root node of tree /** Holds information of a XML file, is root node of tree
*/ */
class XMLFile : public XMLParentNode class XMLFile : public XMLParentNode
{ {
public: public:
XMLFile( XMLFile(
const OString &rFileName // the file name, empty if created from memory stream const OString &rFileName // the file name, empty if created from memory stream
); );
XMLFile( const XMLFile& obj ) ; XMLFile( const XMLFile& rObj ) ;
~XMLFile(); ~XMLFile();
void Print( XMLNode *pCur = NULL, sal_uInt16 nLevel = 0 ); void Print( XMLNode *pCur = NULL, sal_uInt16 nLevel = 0 );
virtual void SearchL10NElements( XMLParentNode *pCur, int pos = 0 ); virtual void SearchL10NElements( XMLParentNode *pCur, int pos = 0 );
void Extract( XMLFile *pCur = NULL ); void Extract( XMLFile *pCur = NULL );
XMLHashMap* GetStrings(){return XMLStrings;} XMLHashMap* GetStrings(){ return m_pXMLStrings; }
void Write( OString const &rFilename ); void Write( OString const &rFilename );
sal_Bool Write( ofstream &rStream , XMLNode *pCur = NULL ); sal_Bool Write( std::ofstream &rStream, XMLNode *pCur = NULL );
bool CheckExportStatus( XMLParentNode *pCur = NULL );// , int pos = 0 ); bool CheckExportStatus( XMLParentNode *pCur = NULL );
XMLFile& operator=(const XMLFile& obj); XMLFile& operator=(const XMLFile& rObj);
virtual sal_uInt16 GetNodeType(); virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_FILE; }
/// returns file name /// returns file name
OString GetName() const { return sFileName; } OString GetName() const { return m_sFileName; }
void SetName( const OString &rFilename ) { sFileName = rFilename; } void SetName( const OString &rFilename ) { m_sFileName = rFilename; }
const std::vector<OString>& getOrder() const { return order; } const std::vector<OString>& getOrder() const { return m_vOrder; }
protected: protected:
void InsertL10NElement( XMLElement* pElement); void InsertL10NElement( XMLElement* pElement);
// DATA // DATA
OString sFileName; OString m_sFileName;
TagMap nodes_localize; TagMap m_aNodes_localize;
XMLHashMap* XMLStrings; XMLHashMap* m_pXMLStrings;
std::vector <OString> order; std::vector <OString> m_vOrder;
}; };
/// An Utility class for XML /// An Utility class for XML
class XMLUtil{ class XMLUtil
{
public: public:
/// Quot the XML characters /// Quot the XML characters
static OString QuotHTML( const OString& rString ); static OString QuotHTML( const OString& rString );
}; };
//-------------------------------------------------------------------------
/** Hold information of an element node /** Hold information of an element node
*/ */
class XMLElement : public XMLParentNode class XMLElement : public XMLParentNode
{ {
private: private:
OString sElementName; OString m_sElementName;
XMLAttributeList *pAttributes; XMLAttributeList *m_pAttributes;
OString project, OString m_sProject;
filename, OString m_sFilename;
id, OString m_sId;
sOldRef, OString m_sOldRef;
resourceType, OString m_sResourceType;
languageId; OString m_sLanguageId;
int nPos; int m_nPos;
protected: protected:
void Print(XMLNode *pCur, OStringBuffer& buffer , bool rootelement); void Print(XMLNode *pCur, OStringBuffer& rBuffer, bool bRootelement) const;
public: public:
/// create an element node /// create an element node
XMLElement(){} XMLElement(){}
XMLElement( XMLElement(
const OString &rName, // the element name const OString &rName, // the element name
XMLParentNode *Parent // parent node of this element XMLParentNode *pParent // parent node of this element
): XMLParentNode( Parent ), );
sElementName( rName ),
pAttributes( NULL ),
project(""),
filename(""),
id(""),
sOldRef(""),
resourceType(""),
languageId(""),
nPos(0)
{
}
~XMLElement(); ~XMLElement();
XMLElement(const XMLElement&); XMLElement(const XMLElement&);
XMLElement& operator=(const XMLElement& obj); XMLElement& operator=(const XMLElement& rObj);
/// returns node type XML_NODE_ELEMENT virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_ELEMENT; }
virtual sal_uInt16 GetNodeType();
/// returns element name /// returns element name
OString GetName() const { return sElementName; } OString GetName() const { return m_sElementName; }
/// returns list of attributes of this element /// returns list of attributes of this element
XMLAttributeList *GetAttributeList() { return pAttributes; } XMLAttributeList *GetAttributeList() { return m_pAttributes; }
/// adds a new attribute to this element, typically used by parser /// adds a new attribute to this element, typically used by parser
void AddAttribute( const OString &rAttribute, const OString &rValue ); void AddAttribute( const OString &rAttribute, const OString &rValue );
@@ -287,147 +240,122 @@ public:
/// Return a Unicode String representation of this object /// Return a Unicode String representation of this object
OString ToOString(); OString ToOString();
void SetProject ( OString const & prj ){ project = prj; } void SetProject ( OString const & sPrj ) { m_sProject = sPrj; }
void SetFileName ( OString const & fn ){ filename = fn; } void SetFileName ( OString const & sFileName ) { m_sFilename = sFileName; }
void SetId ( OString const & theId ){ id = theId; } void SetId ( OString const & sTheId ) { m_sId = sTheId; }
void SetResourceType ( OString const & rt ){ resourceType = rt; } void SetResourceType ( OString const & sResType ) { m_sResourceType = sResType; }
void SetLanguageId ( OString const & lid ){ languageId = lid; } void SetLanguageId ( OString const & sLangId ) { m_sLanguageId = sLangId; }
void SetPos ( int nPos_in ){ nPos = nPos_in; } void SetPos ( int nPos ) { m_nPos = nPos; }
void SetOldRef ( OString const & sOldRef_in ){ sOldRef = sOldRef_in; } void SetOldRef ( OString const & sOldRef ) { m_sOldRef = sOldRef; }
virtual int GetPos() { return nPos; } virtual int GetPos() { return m_nPos; }
OString GetProject() const { return project; } OString GetProject() const { return m_sProject; }
OString GetFileName() const { return filename; } OString GetFileName() const { return m_sFilename; }
OString GetId() const { return id; } OString GetId() const { return m_sId; }
OString GetOldref() const { return sOldRef; } OString GetOldref() const { return m_sOldRef; }
OString GetResourceType() const { return resourceType; } OString GetResourceType() const { return m_sResourceType; }
OString GetLanguageId() const { return languageId; } OString GetLanguageId() const { return m_sLanguageId; }
}; };
//-------------------------------------------------------------------------
/** Holds character data /** Holds character data
*/ */
class XMLData : public XMLChildNode class XMLData : public XMLChildNode
{ {
private: private:
OString sData; OString m_sData;
bool isNewCreated; bool m_bIsNewCreated;
public: public:
/// create a data node /// create a data node
XMLData( XMLData(
const OString &rData, // the initial data const OString &rData, // the initial data
XMLParentNode *Parent // the parent node of this data, typically a element node XMLParentNode *pParent, // the parent node of this data, typically a element node
bool bNewCreated = false
) )
: XMLChildNode( Parent ), sData( rData ) , isNewCreated ( false ){} : XMLChildNode( pParent ), m_sData( rData ), m_bIsNewCreated( bNewCreated ){}
XMLData(
const OString &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); // Default copy constructor and copy operator work well.
XMLData& operator=(const XMLData& obj); virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_DATA; }
virtual sal_uInt16 GetNodeType();
/// returns the data /// returns the data
OString GetData() const { return sData; } OString GetData() const { return m_sData; }
bool isNew() const { return m_bIsNewCreated; }
bool isNew() { return isNewCreated; }
/// adds new character data to the existing one /// adds new character data to the existing one
void AddData( void AddData( const OString &rData ) { m_sData += rData; }
const OString &rData // the new data
);
}; };
//-------------------------------------------------------------------------
/** Holds comments /** Holds comments
*/ */
class XMLComment : public XMLChildNode class XMLComment : public XMLChildNode
{ {
private: private:
OString sComment; OString m_sComment;
public: public:
/// create a comment node /// create a comment node
XMLComment( XMLComment(
const OString &rComment, // the comment const OString &rComment, // the comment
XMLParentNode *Parent // the parent node of this comemnt, typically a element node XMLParentNode *pParent // the parent node of this comemnt, typically a element node
) )
: XMLChildNode( Parent ), sComment( rComment ) {} : XMLChildNode( pParent ), m_sComment( rComment ) {}
virtual sal_uInt16 GetNodeType(); // Default copy constructor and copy operator work well.
XMLComment( const XMLComment& obj ); virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_COMMENT; }
XMLComment& operator=(const XMLComment& obj);
/// returns the comment /// returns the comment
OString GetComment() const { return sComment; } OString GetComment() const { return m_sComment; }
}; };
//-------------------------------------------------------------------------
/** Holds additional file content like those for which no handler exists /** Holds additional file content like those for which no handler exists
*/ */
class XMLDefault : public XMLChildNode class XMLDefault : public XMLChildNode
{ {
private: private:
OString sDefault; OString m_sDefault;
public: public:
/// create a comment node /// create a comment node
XMLDefault( XMLDefault(
const OString &rDefault, // the comment const OString &rDefault, // the comment
XMLParentNode *Parent // the parent node of this comemnt, typically a element node XMLParentNode *pParent // the parent node of this comemnt, typically a element node
) )
: XMLChildNode( Parent ), sDefault( rDefault ) {} : XMLChildNode( pParent ), m_sDefault( rDefault ) {}
XMLDefault(const XMLDefault& obj); // Default copy constructor and copy operator work well.
XMLDefault& operator=(const XMLDefault& obj); virtual sal_uInt16 GetNodeType() const { return XML_NODE_TYPE_DEFAULT; }
/// returns node type XML_NODE_TYPE_COMMENT
virtual sal_uInt16 GetNodeType();
/// returns the comment /// returns the comment
OString GetDefault() const { return sDefault; } OString GetDefault() const { return m_sDefault; }
}; };
//-------------------------------------------------------------------------
/** struct for error information, used by class SimpleXMLParser /** struct for error information, used by class SimpleXMLParser
*/ */
struct XMLError { struct XMLError {
XML_Error eCode; ///< the error code XML_Error m_eCode; ///< the error code
std::size_t nLine; ///< error line number std::size_t m_nLine; ///< error line number
std::size_t nColumn; ///< error column number std::size_t m_nColumn; ///< error column number
OString sMessage; ///< readable error message OString m_sMessage; ///< readable error message
}; };
//-------------------------------------------------------------------------
/** validating xml parser, creates a document tree with xml nodes /** validating xml parser, creates a document tree with xml nodes
*/ */
class SimpleXMLParser class SimpleXMLParser
{ {
private: private:
XML_Parser aParser; XML_Parser m_aParser;
XMLError aErrorInformation; XMLError m_aErrorInformation;
XMLFile *pXMLFile; XMLFile *m_pXMLFile;
XMLParentNode *pCurNode; XMLParentNode *m_pCurNode;
XMLData *pCurData; XMLData *m_pCurData;
static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts ); static void StartElementHandler( void *userData, const XML_Char *name, const XML_Char **atts );
@@ -455,7 +383,7 @@ public:
); );
/// returns an error struct /// returns an error struct
const XMLError &GetError() { return aErrorInformation; } const XMLError &GetError() const { return m_aErrorInformation; }
}; };
#endif // BOOTSTRP_XMLPARSE_HXX #endif // BOOTSTRP_XMLPARSE_HXX

2
l10ntools/source/helpmerge.cxx
View File

@@ -88,7 +88,7 @@ bool HelpParser::CreatePO(
printf( printf(
"%s: %s\n", "%s: %s\n",
sHelpFile.getStr(), sHelpFile.getStr(),
aParser.GetError().sMessage.getStr()); aParser.GetError().m_sMessage.getStr());
exit(-1); exit(-1);
} }
file->Extract(); file->Extract();

999
l10ntools/source/xmlparse.cxx
View File

File diff suppressed because it is too large Load Diff