xml-copy-editor-code/src/wrapexpat.cpp

#include "wrapexpat.h"
#include "expat.h"
#include <stdexcept>
#include <iostream>
#include <sstream>

WrapExpat::WrapExpat(bool nameSpaceAware)
{
 p = (nameSpaceAware) ? XML_ParserCreateNS(NULL, (XML_Char)':') : XML_ParserCreate(NULL);
 if (p == 0)
   throw runtime_error("WrapExpat::WrapExpat");
}

WrapExpat::~WrapExpat()
{
  if (p)
    XML_ParserFree(p);                       
}

bool WrapExpat::parse(const char *buffer, size_t size, bool isFinal)
{
  if (!p)
    return false;
  if (XML_Parse(p, buffer, size, isFinal) == XML_STATUS_ERROR)
    return false;
  return true;      
 
}

bool WrapExpat::parse(const string &buffer, bool isFinal)
{
  return parse(buffer.c_str(), buffer.size(), isFinal);

/*
  if (!p)
    return false;
  
  if (XML_Parse(p, buffer.c_str(), buffer.size(), isFinal) == XML_STATUS_ERROR)
    return false;
  return true;      
*/

}

pair<int, int> WrapExpat::getErrorPosition()
{
  return make_pair(
    XML_GetCurrentLineNumber(p),// - 1,
    XML_GetCurrentColumnNumber(p));
}

string WrapExpat::getLastError()
{
  if (!p)
    return "Unable to create parser instance";
    
  stringstream ss;
  ss << "Error at line ";
  ss << XML_GetCurrentLineNumber(p);
  ss << ", column " << XML_GetCurrentColumnNumber(p) + 1 << ":" << endl;
  ss << XML_ErrorString(XML_GetErrorCode(p));
  return ss.str();
}

string WrapExpat::xmliseTextNode(const string &textnode)
{
  size_t size = textnode.size();
  string output;
    
  for (size_t i = 0; i < size; ++i)
  {
    char c = textnode[i];
    switch (c)
    {
      case '<':
        output += "&lt;";
        break;
      case '>':
        output += "&gt;";
        break;
      case '&':
        output += "&amp;";
        break;
      default:
        output += textnode[i];
    }
  }
  return output;
}

string WrapExpat::xmliseAttribute(const string &attribute)
{
  string intermediate = xmliseTextNode(attribute);
  
  size_t size = intermediate.size();
  string output;
    
  for (size_t i = 0; i < size; ++i)
  {
    char c = intermediate[i];
    switch (c)
    {
      case '"':
        output += "&quot;";
        break;
      case '\'':
        output += "&apos;";
        break;
      default:
        output += intermediate[i];
    }
  }
  return output;
}

bool WrapExpat::isWhitespace(const string &textnode)
{
  size_t size = textnode.size();
  for (size_t i = 0; i < size; ++i)
    if (!isspace(textnode[i]))
      return false;
  return true;
}

bool WrapExpat::isEncodingError()
{
  if (!p)
    return false;

  int errorCode = XML_GetErrorCode(p);
  return (
    errorCode == XML_ERROR_UNKNOWN_ENCODING ||
    errorCode == XML_ERROR_INCORRECT_ENCODING) ?
      true : false;
}