From 7e7109fa019b3a7ac95d2cdb139948603d541b20 Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 29 Nov 2015 23:37:08 +0300 Subject: Move xml class based on libxml into libxml.cpp file. --- src/utils/xml/libxml.cpp | 315 +++++++++++++++++++++++++++++++++++++++++++++++ src/utils/xml/libxml.h | 171 +++++++++++++++++++++++++ 2 files changed, 486 insertions(+) create mode 100644 src/utils/xml/libxml.cpp create mode 100644 src/utils/xml/libxml.h (limited to 'src/utils/xml') diff --git a/src/utils/xml/libxml.cpp b/src/utils/xml/libxml.cpp new file mode 100644 index 000000000..29bd83b4b --- /dev/null +++ b/src/utils/xml/libxml.cpp @@ -0,0 +1,315 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2016 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifdef ENABLE_LIBXML + +#include "utils/xml/libxml.h" + +#include "logger.h" + +#include "utils/fuzzer.h" +#include "utils/physfstools.h" +#include "utils/stringutils.h" + +#include "utils/translation/podict.h" + +#include "debug.h" + +namespace +{ + bool valid = false; +} // namespace + +static void xmlErrorLogger(void *ctx A_UNUSED, const char *msg A_UNUSED, ...) +#ifdef __GNUC__ +#ifdef __OpenBSD__ + __attribute__((__format__(printf, 2, 3))) +#else + __attribute__((__format__(gnu_printf, 2, 3))) +#endif +#endif +; + +static void xmlErrorLogger(void *ctx A_UNUSED, const char *msg, ...) +{ + if (!msg) + return; + + size_t size = 1024; + const size_t msgSize = strlen(msg); + if (msgSize * 3 > size) + size = msgSize * 3; + + char* buf = new char[size + 1]; + va_list ap; + + // Use a temporary buffer to fill in the variables + va_start(ap, msg); + vsnprintf(buf, size, msg, ap); + buf[size] = 0; + va_end(ap); + + if (logger) + logger->log_r("%s", buf); + else + puts(buf); + + // Delete temporary buffer + delete [] buf; + valid = false; +} + +namespace XML +{ + Document::Document(const std::string &filename, + const UseResman useResman, + const SkipError skipError) : + mDoc(nullptr), + mIsValid(false) + { +#ifdef USE_FUZZER + if (Fuzzer::conditionTerminate(filename.c_str())) + return; +#endif + BLOCK_START("XML::Document::Document") + int size = 0; + char *data = nullptr; + valid = true; + if (useResman == UseResman_true) + { + data = static_cast(PhysFs::loadFile( + filename.c_str(), size)); + } + else + { + std::ifstream file; + file.open(filename.c_str(), std::ios::in); + + if (file.is_open()) + { + // Get length of file + file.seekg(0, std::ios::end); + size = static_cast(file.tellg()); + if (size < 0) + { + logger->log("Error loading XML file %s", filename.c_str()); + } + else + { + file.seekg(0, std::ios::beg); + data = static_cast(malloc(size)); + file.read(data, size); + } + file.close(); + } + else + { + logger->log("Error loading XML file %s", filename.c_str()); + } + } + + if (data) + { + mDoc = xmlParseMemory(data, size); + free(data); + + if (!mDoc) + logger->log("Error parsing XML file %s", filename.c_str()); + } + else if (skipError == SkipError_false) + { + logger->log("Error loading %s", filename.c_str()); + } + mIsValid = valid; + BLOCK_END("XML::Document::Document") + } + + Document::Document(const char *const data, const int size) : + mDoc(data ? xmlParseMemory(data, size) : nullptr), + mIsValid(true) + { + } + + Document::~Document() + { + if (mDoc) + xmlFreeDoc(mDoc); + } + + XmlNodePtr Document::rootNode() + { + return mDoc ? xmlDocGetRootElement(mDoc) : nullptr; + } + + int getProperty(const XmlNodePtr node, + const char *const name, + int def) + { + int &ret = def; + + xmlChar *const prop = XmlGetProp(node, name); + if (prop) + { + ret = atoi(reinterpret_cast(prop)); + xmlFree(prop); + } + + return ret; + } + + int getIntProperty(const XmlNodePtr node, + const char *const name, + int def, + const int min, + const int max) + { + int &ret = def; + + xmlChar *const prop = XmlGetProp(node, name); + if (prop) + { + ret = atoi(reinterpret_cast(prop)); + xmlFree(prop); + } + if (ret < min) + ret = min; + else if (ret > max) + ret = max; + return ret; + } + + double getFloatProperty(const XmlNodePtr node, + const char *const name, + double def) + { + double &ret = def; + + xmlChar *const prop = XmlGetProp(node, name); + if (prop) + { + ret = atof(reinterpret_cast(prop)); + xmlFree(prop); + } + + return ret; + } + + std::string getProperty(const XmlNodePtr node, + const char *const name, + const std::string &def) + { + xmlChar *const prop = XmlGetProp(node, name); + if (prop) + { + std::string val = reinterpret_cast(prop); + xmlFree(prop); + return val; + } + + return def; + } + + std::string langProperty(const XmlNodePtr node, + const char *const name, + const std::string &def) + { + std::string str = getProperty(node, name, def); + if (!translator) + return str; + + return translator->getStr(str); + } + + bool getBoolProperty(const XmlNodePtr node, + const char *const name, + const bool def) + { + xmlChar *const prop = XmlGetProp(node, name); + + if (XmlStrEqual(prop, "true")) + return true; + if (XmlStrEqual(prop, "false")) + return false; + return def; + } + + XmlNodePtr findFirstChildByName(const XmlNodePtrConst parent, + const char *const name) + { + if (!parent) + return nullptr; + for_each_xml_child_node(child, parent) + { + if (xmlNameEqual(child, name)) + return child; + } + + return nullptr; + } + + // Initialize libxml2 and check for potential ABI mismatches between + // compiled version and the shared library actually used. + void initXML() + { + xmlInitParser(); + LIBXML_TEST_VERSION; + + // Suppress libxml2 error messages + xmlSetGenericErrorFunc(nullptr, &xmlErrorLogger); + } + + // Shutdown libxml + void cleanupXML() + { + xmlCleanupParser(); + } + + bool Document::validateXml(const std::string &fileName) + { + const xmlDocPtr doc = xmlReadFile(fileName.c_str(), + nullptr, XML_PARSE_PEDANTIC); + const bool valid1(doc); + xmlFreeDoc(doc); + if (!valid1) + return false; + + std::ifstream file; + file.open(fileName.c_str(), std::ios::in); + if (!file.is_open()) + { + file.close(); + return false; + } + char line[101]; + if (!file.getline(line, 100)) + return false; + file.close(); + + const std::string str = line; + if (!strStartWith(str, ". + */ + +#ifndef UTILS_XML_LIBXML_H +#define UTILS_XML_LIBXML_H + +#ifdef ENABLE_LIBXML + +#include "enums/simpletypes/skiperror.h" +#include "enums/simpletypes/useresman.h" + +#include +#include + +#include + +#include "localconsts.h" + +#define XmlNodePtr xmlNodePtr +#define XmlNodePtrConst xmlNode *const +#define XmlStrEqual(str1, str2) xmlStrEqual(str1, \ + reinterpret_cast(str2)) +#define xmlNameEqual(node, str) xmlStrEqual((node)->name, \ + reinterpret_cast(str)) +#define XmlTextWriterPtr xmlTextWriterPtr +#define xmlTypeEqual(node, typ) ((node)->type == (typ)) +#define XmlHasProp(node, name) (xmlHasProp(node, \ + reinterpret_cast(name)) != nullptr) +#define XmlGetProp(node, name) xmlGetProp(node, \ + reinterpret_cast(name)) +#define XmlTextWriterStartElement(writer, name) \ + xmlTextWriterStartElement(writer, reinterpret_cast(name)) +#define XmlTextWriterWriteAttribute(writer, name, content) \ + xmlTextWriterWriteAttribute(writer, \ + reinterpret_cast(name), \ + reinterpret_cast(content)) + +/** + * XML helper functions. + */ +namespace XML +{ + /** + * A helper class for parsing an XML document, which also cleans it up + * again (RAII). + */ + class Document final + { + public: + /** + * Constructor that attempts to load the given file through the + * resource manager. Logs errors. + */ + Document(const std::string &filename, + const UseResman useResman, + const SkipError skipError); + + /** + * Constructor that attempts to load an XML document from memory. + * Does not log errors. + * + * @param data the string to parse as XML + * @param size the length of the string in bytes + */ + Document(const char *const data, const int size); + + A_DELETE_COPY(Document) + + /** + * Destructor. Frees the loaded XML file. + */ + ~Document(); + + /** + * Returns the root node of the document (or NULL if there was a + * load error). + */ + XmlNodePtr rootNode() A_WARN_UNUSED; + + bool isLoaded() const + { return mDoc != nullptr; } + + bool isValid() const + { return mIsValid; } + + static bool validateXml(const std::string &fileName); + + private: + xmlDocPtr mDoc; + bool mIsValid; + }; + + /** + * Gets an floating point property from an XmlNodePtr. + */ + double getFloatProperty(const XmlNodePtr node, + const char *const name, + double def) A_WARN_UNUSED; + + /** + * Gets an integer property from an XmlNodePtr. + */ + int getProperty(const XmlNodePtr node, + const char *const name, + int def) A_WARN_UNUSED; + + /** + * Gets an integer property from an XmlNodePtr. + */ + int getIntProperty(const XmlNodePtr node, + const char *const name, + int def, + const int min, + const int max) A_WARN_UNUSED; + + /** + * Gets a string property from an XmlNodePtr. + */ + std::string getProperty(const XmlNodePtr node, + const char *const name, + const std::string &def) A_WARN_UNUSED; + + /** + * Gets a translated string property from an XmlNodePtr. + */ + std::string langProperty(const XmlNodePtr node, + const char *const name, + const std::string &def) A_WARN_UNUSED; + + /** + * Gets a boolean property from an XmlNodePtr. + */ + bool getBoolProperty(const XmlNodePtr node, + const char *const name, + const bool def) A_WARN_UNUSED; + + /** + * Finds the first child node with the given name + */ + XmlNodePtr findFirstChildByName(const XmlNodePtrConst parent, + const char *const name) A_WARN_UNUSED; + + void initXML(); + + void cleanupXML(); +} // namespace XML + +#define for_each_xml_child_node(var, parent) \ + for (XmlNodePtr var = parent->xmlChildrenNode; var; var = var->next) + +#endif // ENABLE_LIBXML +#endif // UTILS_XML_LIBXML_H -- cgit v1.2.3-70-g09d2