xmlparser.cpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
//---------------------------------------------------------------------------
#include <istream>
#include <fstream>
#include <string>
#include <cstring>
#include <cassert>
 
#include <expat.h>
#include <utf8cpp/utf8.h>
#if __has_include(<utf8cpp/cpp17.h>)
  #include <utf8cpp/cpp17.h>
  #define LIBXCKS_UTF8CPP_HAS_STRING_VIEW
#endif
 
#include "xmlparser.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
//###########################################################################
// An exception class for the XML parser.
//###########################################################################
 
XMLParserException::XMLParserException() noexcept
{
}
//---------------------------------------------------------------------------
 
 
XMLParserException::XMLParserException(const XMLParserException& source) noexcept
{
  if (this != &source)
  {
    this->message = source.message;
  }
}
//---------------------------------------------------------------------------
 
 
XMLParserException& XMLParserException::operator=(const XMLParserException& source) noexcept
{
  if (this != &source)
  {
    this->message = source.message;
  }
  return *this;
}
//---------------------------------------------------------------------------
 
 
XMLParserException::XMLParserException(const std::string& msg) noexcept
{
  setMessage(msg);
}
//---------------------------------------------------------------------------
 
 
XMLParserException::~XMLParserException()
{
}
//---------------------------------------------------------------------------
 
 
string XMLParserException::what() const noexcept
{
  return getMessage();
}
//---------------------------------------------------------------------------
 
 
string XMLParserException::getMessage() const noexcept
{
  return message;
}
//---------------------------------------------------------------------------
 
 
void XMLParserException::setMessage(const string& msg) noexcept
{
  message = msg;
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// Manages elements' attributes.
//###########################################################################
void XMLParserAttributes::addAttribute(const std::string& name, const std::string& value)
{
  addAttribute(XMLParserAttribute{name, value});
}
//---------------------------------------------------------------------------
 
 
void XMLParserAttributes::addAttribute(const XMLParserAttribute&& attribute)
{
  attributes.emplace_back(attribute);
}
//---------------------------------------------------------------------------
 
 
void XMLParserAttributes::clear()
{
  attributes.clear();
  attributes.shrink_to_fit();
}
//---------------------------------------------------------------------------
 
 
int XMLParserAttributes::getIndex(const string& name) const
{
  bool notFound = true;
  const int s = attributes.size();
  int i = 0;
  while (notFound && i < s)
  {
    if (name == attributes[i].first)
      notFound = false;
    else
      i++;
  }
 
  return notFound ? Not_Found : i;
}
//---------------------------------------------------------------------------
 
 
size_t XMLParserAttributes::getCount() const
{
  return attributes.size();
}
//---------------------------------------------------------------------------
 
 
bool XMLParserAttributes::getName(size_t index, string& name) const
{
  if (index < 0 || index >= getCount())
    return false;
 
  name = attributes[index].first;
  return true;
}
//---------------------------------------------------------------------------
 
 
bool XMLParserAttributes::getValue(size_t index, std::string& value) const
{
  if (index < 0 || index >= getCount())
    return false;
 
  value = attributes[index].second;
  return true;
}
//---------------------------------------------------------------------------
 
 
bool XMLParserAttributes::getValue(const std::string& name, std::string& value) const
{
  int idx = getIndex(name);
  if (idx != Not_Found)
  {
    value = attributes[idx].second;
    return true;
  }
 
  return false;
}
//---------------------------------------------------------------------------
 
 
 
//###########################################################################
// XMLParser's implementation.
//###########################################################################
 
 
static constexpr size_t DEF_BUFF_SIZE = 4096;
 
 
inline static string convXMLCharStrtoUTF8Charset(const XML_Char* xlmStr)
{
  #if defined(XML_UNICODE)  // XML_Char* is UTF-16 encoded.
  assert(sizeof(XML_Char) == 2);
  #if defined(LIBXCKS_UTF8CPP_HAS_STRING_VIEW)
  return utf8::utf16to8(u16string_view(reinterpret_cast<const char16_t*>(xlmStr)));
  #else
  return utf8::utf16to8(u16string(reinterpret_cast<const char16_t*>(xlmStr)));
  #endif
  #else  // XML_Char* is UTF-8 encoded.
  return string(xlmStr);
  #endif
}
//---------------------------------------------------------------------------
 
 
XMLParser::XMLParser()
{
  parser = nullptr;
}
//---------------------------------------------------------------------------
 
 
XMLParser::~XMLParser()
{
  if (parser != nullptr)
    XML_ParserFree(parser);
}
//---------------------------------------------------------------------------
 
 
bool XMLParser::initParser()
{
  if (parser != nullptr)
    XML_ParserFree(parser);
 
  setDepth(0);
  parser = XML_ParserCreate(nullptr);
  if (parser != nullptr)
  {
    // Register expat handlers.
    XML_SetUserData(parser, this);
    XML_SetElementHandler(parser, XMLParser::startElementHandler, XMLParser::endElementHandler);
    XML_SetCharacterDataHandler(parser, XMLParser::characterDataHandler);
  }
 
  return (parser != nullptr);
}
//---------------------------------------------------------------------------
 
 
void XMLParser::startElement(const string& name, const XMLParserAttributes& atts)
{
}
//---------------------------------------------------------------------------
 
 
void XMLParser::endElement(const string& name)
{
}
//---------------------------------------------------------------------------
 
 
void XMLParser::characters(const string& chars)
{
}
//---------------------------------------------------------------------------
 
 
void XMLParser::fatalError(XML_Error errorCode, const string& errorMessage, int line, int column) noexcept
{
}
//---------------------------------------------------------------------------
 
 
// Static methods for binding expat handlers
void XMLCALL XMLParser::startElementHandler(void* userData, const XML_Char* name, const XML_Char** atts)
{
  // userData can't (shouldn't) be nullptr
  XMLParser* p = reinterpret_cast<XMLParser*>(userData);
  XMLParserAttributes a;
 
  // Get the elements' attributes
  for (int i = 0; atts[i] != nullptr; i += 2)
    a.addAttribute(XMLParserAttribute{convXMLCharStrtoUTF8Charset(atts[i]), convXMLCharStrtoUTF8Charset(atts[i + 1])});
 
  // Call start element callback.
  p->startElement(convXMLCharStrtoUTF8Charset(name), a);
 
  // Change the current depth
  p->setDepth(p->getDepth() + 1);
}
//---------------------------------------------------------------------------
 
 
void XMLCALL XMLParser::endElementHandler(void* userData, const XML_Char* name)
{
  // userData can't (shouldn't) be nullptr
  XMLParser* p = reinterpret_cast<XMLParser*>(userData);
 
  // Change the current depth
  p->setDepth(p->getDepth() - 1);
 
  // Call start element callback.
  p->endElement(convXMLCharStrtoUTF8Charset(name));
}
//---------------------------------------------------------------------------
 
 
void XMLCALL XMLParser::characterDataHandler(void* userData, const XML_Char* s, int len)
{
  // userData can't (shouldn't) be nullptr
  XMLParser* p = reinterpret_cast<XMLParser*>(userData);
 
  // Creates a temporary buffer
  XML_Char* str = new XML_Char[len + 1];
  memcpy(str, s, sizeof(XML_Char) * len);
  #if defined(XML_UNICODE)
  str[len] = L'\0';
  #else
  str[len] = '\0';
  #endif
  string chData = convXMLCharStrtoUTF8Charset(str);
  delete[] str;
  p->characters(chData);
}
//---------------------------------------------------------------------------
 
 
void XMLParser::setDepth(int depth)
{
  xmlDepth = depth;
}
//---------------------------------------------------------------------------
 
 
int XMLParser::getDepth() const
{
  return xmlDepth;
}
//---------------------------------------------------------------------------
 
 
bool XMLParser::parse(const std::string& filename)
{
  ifstream is(filename, ios::in | ios::binary);
  return parse(is);  // parse(istream&) calls initParser()
}
//---------------------------------------------------------------------------
 
 
bool XMLParser::parse(std::istream& is)
{
  if (!is.good())
    return false;
 
  if (!initParser())
    return false;
 
  // Initializes the buffer.
  char buff[DEF_BUFF_SIZE];
 
  // Reads data from the input stream.
  size_t read;
  ios::iostate errorState = ios::goodbit;
  XML_Status lastXMLError = XML_STATUS_OK;
  bool parserExceptionLaunched = false;
  string exceptionMessage;
  try
  {
    while (!is.eof() && (errorState & ios::goodbit) == ios::goodbit && lastXMLError == XML_STATUS_OK)
    {
      read = is.read(buff, sizeof(char) * DEF_BUFF_SIZE).gcount();
      if (read > 0 && read <= sizeof(char) * DEF_BUFF_SIZE)
        lastXMLError = XML_Parse(parser, buff, static_cast<int>(read), static_cast<int>(XML_FALSE));
      errorState = is.rdstate();
    }
  }
  catch (const XMLParserException& e)
  {
    exceptionMessage = e.what();
    parserExceptionLaunched = true;
  }
 
  // Finishing parsing.
  if (parserExceptionLaunched || ((errorState & ios::goodbit) != ios::goodbit && (errorState & ios::eofbit) != ios::eofbit))
    XML_StopParser(parser, XML_FALSE);
 
  if (lastXMLError == XML_STATUS_OK)
    lastXMLError = XML_Parse(parser, buff, 0, static_cast<int>(XML_TRUE));
 
  if (lastXMLError != XML_STATUS_OK)
  {
    XML_Error err = XML_GetErrorCode(parser);
    if (exceptionMessage.empty())
      fatalError(err, convXMLCharStrtoUTF8Charset(XML_ErrorString(err)), XML_GetCurrentLineNumber(parser), XML_GetCurrentColumnNumber(parser));
    else
      fatalError(err, exceptionMessage, XML_GetCurrentLineNumber(parser), XML_GetCurrentColumnNumber(parser));
  }
 
  return ((!parserExceptionLaunched) && (lastXMLError == XML_STATUS_OK));
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------