ExpatCoreParser Class Reference

#include <ExpatCoreParser.h>

Collaboration diagram for ExpatCoreParser:

Public Types
typedef std::map< std::string, std::string >	ExternalEntityMap

Static Public Member Functions
static std::unique_ptr< CoreParser::DOMNode >	parse (const std::string &file_name)
static void	register_external_entity (const std::string &name, const std::string &file_name)
static void	register_text_entity (const std::string &name, const std::string &text)

Private Types
typedef std::lock_guard< std::mutex >	lock_t

Private Member Functions
	ExpatCoreParser (const std::string &prefix)
void	do_start (const char *el, const char **attr)
void	do_end (const char *el)
void	do_char_data (const XML_Char *s, int len)
void	do_default_handler (const XML_Char *s, int len)
void	do_comment (const XML_Char *s)
int	generic_parse (XML_Parser p, const std::string &file_name)
int	generic_text_parse (XML_Parser p, const std::string &text)
int	do_external_entity (XML_Parser parser, const XML_Char *context, const XML_Char *systemId)
std::unique_ptr< CoreParser::DOMNode >	get_document ()
void	clean ()

Static Private Member Functions
static void	start (void *, const char *el, const char **attr)
static void	end (void *, const char *el)
static void	char_data (void *, const XML_Char *s, int len)
static void	default_handler (void *, const XML_Char *s, int len)
static void	comment (void *, const XML_Char *s)
static int	external_entity (XML_Parser parser, const XML_Char *context, const XML_Char *, const XML_Char *systemId, const XML_Char *)
static void	entity (void *userData, const XML_Char *entityName, int is_parameter_entity, const XML_Char *value, int value_length, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *)
static const std::string &	find_external_entity (const std::string &name)
static const std::string &	find_text_entity (const std::string &name)

Private Attributes
std::unique_ptr< CoreParser::DOMNode >	m_top
CoreParser::DOMNode *	m_last
std::string	m_prefix

Static Private Attributes
static std::mutex	s_mutex
static ExternalEntityMap s_entities	ATLAS_THREAD_SAFE
static ExternalEntityMap s_text_entities	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 15 of file ExpatCoreParser.h.

Member Typedef Documentation

ExternalEntityMap

typedef std::map<std::string, std::string> ExpatCoreParser::ExternalEntityMap

Definition at line 19 of file ExpatCoreParser.h.

lock_t

typedef std::lock_guard<std::mutex> ExpatCoreParser::lock_t

private

Definition at line 71 of file ExpatCoreParser.h.

Constructor & Destructor Documentation

ExpatCoreParser()

ExpatCoreParser::ExpatCoreParser ( const std::string &  prefix )

private

Definition at line 156 of file ExpatCoreParser.cxx.

  : m_top (nullptr),
    m_last (nullptr),
    m_prefix (prefix)
{
}

Member Function Documentation

char_data()

void ExpatCoreParser::char_data ( void *  user_data, const XML_Char *  s, int  len  )

staticprivate

Definition at line 55 of file ExpatCoreParser.cxx.

{
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  me.do_char_data (s, len);
}

clean()

void ExpatCoreParser::clean ( )

private

comment()

void ExpatCoreParser::comment ( void *  user_data, const XML_Char *  s  )

staticprivate

Definition at line 67 of file ExpatCoreParser.cxx.

{
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  me.do_comment (s);
}

default_handler()

void ExpatCoreParser::default_handler ( void *  user_data, const XML_Char *  s, int  len  )

staticprivate

Definition at line 61 of file ExpatCoreParser.cxx.

{
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  me.do_default_handler (s, len);
}

do_char_data()

void ExpatCoreParser::do_char_data ( const XML_Char *  s, int  len  )

private

Definition at line 203 of file ExpatCoreParser.cxx.

{
  if (len == 0) return;
 
  while ((len > 0) && (s[len-1] == '\n')) len--;
  
  if (len == 0) return;
 
  char* temp = (char*) malloc (len + 1);
  strncpy (temp, s, len);
  temp[len] = 0;
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_char_data> [" << temp << "]" << std::endl;
    }
  
  free (temp);
}

do_comment()

void ExpatCoreParser::do_comment ( const XML_Char *  s )

private

Definition at line 243 of file ExpatCoreParser.cxx.

{
  if (!m_top) 
    {
      m_top = std::make_unique<CoreParser::DOMNode> ();
      m_last = m_top.get();
    }
 
  CoreParser::DOMNode* node = new CoreParser::DOMNode (CoreParser::DOMNode::COMMENT_NODE, s, m_last);
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_comment> s=" << s << " top=" << m_top.get() << " last=" << m_last << " node=" << node << std::endl; 
    }
 
  // Node is owned by m_last.
  // cppcheck-suppress memleak
  node = nullptr;
}

do_default_handler()

void ExpatCoreParser::do_default_handler ( const XML_Char *  s, int  len  )

private

Definition at line 223 of file ExpatCoreParser.cxx.

{
  if (len == 0) return;
 
  while ((len > 0) && (s[len-1] == '\n')) len--;
  
  if (len == 0) return;
 
  char* temp = (char*) malloc (len + 1);
  strncpy (temp, s, len);
  temp[len] = 0;
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_default_handler> [" << temp << "]" << std::endl;
    }
  
  free (temp);
}

do_end()

void ExpatCoreParser::do_end ( const char *  el )

private

Definition at line 193 of file ExpatCoreParser.cxx.

{
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_end> el=" << el << std::endl; 
    }
  
  m_last = m_last->m_parent;
}

do_external_entity()

int ExpatCoreParser::do_external_entity ( XML_Parser  parser, const XML_Char *  context, const XML_Char *  systemId  )

private

Definition at line 456 of file ExpatCoreParser.cxx.

{
  std::string context_str;
  
  if (context == 0) context_str = "none";
  else context_str = context;
 
  bool done = false;
  int status = 0;
 
  if (context != 0)
    {
      std::string replacement = find_text_entity (context_str);
 
      if (replacement != "")
    {
      if (ExpatCoreParserDebugger::debug ())
        {
          std::cout << "ExpatCoreParser::do_external_entity> "
            << " context=[" << context_str << "]"
            << " replacement=[" << replacement << "]"
            << std::endl;
        }
      
      XML_Parser p = XML_ExternalEntityParserCreate (parser, context, NULL);
      
      status = generic_text_parse (p, replacement);
      
      XML_ParserFree (p);
      
      done = true;
    }
    }
 
  if (!done)
    {
      std::string replacement = find_external_entity (context_str);
  
      if (replacement == "NULL")
    {
      return (1);
    }
 
      if (replacement != "")
    {
      systemId = replacement.c_str ();
    }
 
      if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_external_entity> "
            << " context=[" << context_str << "]"
            << " systemId=[" << systemId << "]"
            << " replacement=[" << replacement << "]"
            << std::endl;
    }
      
      XML_Parser p = XML_ExternalEntityParserCreate (parser, context, NULL);
      
      status = generic_parse (p, systemId);
  
      XML_ParserFree (p);
    }
 
 
  return (status);
}

do_start()

void ExpatCoreParser::do_start ( const char *  el, const char **  attr  )

private

Definition at line 163 of file ExpatCoreParser.cxx.

{
  int i;
  
  std::map <std::string, std::string> a;
  
  if (!m_top)
    {
      m_top = std::make_unique<CoreParser::DOMNode> ();
      m_last = m_top.get();
    }
 
  CoreParser::DOMNode* node = new CoreParser::DOMNode (CoreParser::DOMNode::ELEMENT_NODE, el, m_last);
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::do_start> el=" << el << " top=" << m_top.get() << " last=" << m_last << " node=" << node << std::endl; 
    }
  
  m_last = node;
  
  for (i = 0; attr[i]; i += 2) 
    {
      const char* name = attr[i];
      const char* value = attr[i+1];
      
      node->m_attributes[name] = value;
    }
}

end()

void ExpatCoreParser::end ( void *  user_data, const char *  el  )

staticprivate

Definition at line 49 of file ExpatCoreParser.cxx.

{
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  me.do_end (el);
}

entity()

void ExpatCoreParser::entity ( void *  userData, const XML_Char *  entityName, int  is_parameter_entity, const XML_Char *  value, int  value_length, const XML_Char *  base, const XML_Char *  systemId, const XML_Char *  publicId, const XML_Char *    )

staticprivate

Definition at line 108 of file ExpatCoreParser.cxx.

{
  if (!base) base = "none";
  if (!systemId) systemId = "none";
  if (!publicId) publicId = "none";
  
  std::string temp = "none";
  
  if (value)
    {
      char* t = (char*) malloc (value_length + 1);
      strncpy (t, value, value_length);
      t[value_length] = 0;
      
      temp = (const char*) t;
      
      free (t);
    }
  
  if (ExpatCoreParserDebugger::debug ())
    {
      //XML_Parser p = (XML_Parser) userData;
      
      //int ln = XML_GetCurrentLineNumber (p);
      
      std::cout << "ExpatCoreParser::entity[" << 0 << "]> " << entityName;
      std::cout << " is_parameter=" << is_parameter_entity;
      std::cout << " value=[" << temp << "]";
      std::cout << " base=[" << base << "]";
      std::cout << " systemId=[" << systemId << "]";
      std::cout << " publicId=[" << publicId << "]";
      std::cout << std::endl;
    }
}

external_entity()

int ExpatCoreParser::external_entity ( XML_Parser  parser, const XML_Char *  context, const XML_Char *  , const XML_Char *  systemId, const XML_Char *    )

staticprivate

Definition at line 73 of file ExpatCoreParser.cxx.

{
  void* user_data = XML_GetUserData (parser);
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  return (me.do_external_entity (parser, context, systemId));
}

find_external_entity()

const std::string & ExpatCoreParser::find_external_entity ( const std::string &  name )

staticprivate

Definition at line 526 of file ExpatCoreParser.cxx.

{ 
  lock_t lock (s_mutex);
  ExternalEntityMap::const_iterator it = s_entities.find (name); 
  if (it == s_entities.end ()) 
    {
      static const std::string empty;
      return (empty); 
    }
  else 
    { 
      return ((*it).second); 
    } 
} 

find_text_entity()

const std::string & ExpatCoreParser::find_text_entity ( const std::string &  name )

staticprivate

Definition at line 541 of file ExpatCoreParser.cxx.

{ 
  lock_t lock (s_mutex);
  ExternalEntityMap::const_iterator it = s_text_entities.find (name); 
  if (it == s_text_entities.end ()) 
    {
      static const std::string empty;
      return (empty); 
    }
  else 
    { 
      return ((*it).second); 
    } 
} 

generic_parse()

int ExpatCoreParser::generic_parse ( XML_Parser  p, const std::string &  file_name  )

private

Definition at line 263 of file ExpatCoreParser.cxx.

{
  FILE* docfd;
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::generic_parse> file_name=" << file_name << " prefix=" << m_prefix << std::endl; 
    }
  
  std::string temp_name = file_name;
  
  docfd = fopen (temp_name.c_str (), "r");
  if (!docfd)
    {
      temp_name = m_prefix + "/" + file_name;
      
      docfd = fopen (temp_name.c_str (), "r");
    }
  
  if (docfd == 0)
    {
      const char* xmlpathenv = ::getenv ("XMLPATH");
      
      if (xmlpathenv == 0) return (0);
      
      std::string xmlpath = xmlpathenv;
      
      std::string::size_type pos = 0;
      
      while (pos != std::string::npos)
    {
      std::string::size_type sep = xmlpath.find (":", pos);
      
      if (sep == std::string::npos)
        {
          temp_name = xmlpath.substr (pos);
          pos = std::string::npos;
        }
      else
        {
          temp_name = xmlpath.substr (pos, sep - pos);
          pos = sep + 1;
        }
      
      if (temp_name == "") continue;
 
      std::string last_temp_name = temp_name;
      
      temp_name += "/";
      temp_name += file_name;
      
      if (ExpatCoreParserDebugger::debug ())
        {
          std::cout << "ExpatCoreParser::generic_parse> file_name=" << file_name
            << " xmlpath=" << xmlpath
            << " temp_name=" << temp_name
            << std::endl; 
        }
      
      docfd = fopen (temp_name.c_str (), "r");
      if (docfd != 0) break;
 
      // Test whether prefix is a relative path and if so use it
      if (m_prefix != "" && '/' != m_prefix[0]) {
 
          temp_name =  last_temp_name;
          temp_name += "/";
          temp_name += m_prefix;
          temp_name += "/";
          temp_name += file_name;
      
          if (ExpatCoreParserDebugger::debug ()) 
        {
          std::cout << "ExpatCoreParser::generic_parse> file_name=" << file_name
                << " xmlpath=" << xmlpath
                << " temp_name=" << temp_name
                << std::endl; 
        }
      
          docfd = fopen (temp_name.c_str (), "r");
          if (docfd != 0) break;
      }
    }
    }
  
  if (docfd == 0)
    {
      return (0);
    }
  
  int result = 1;
  
  XML_SetParamEntityParsing (p, XML_PARAM_ENTITY_PARSING_ALWAYS);
  XML_SetElementHandler (p, start, end);
  XML_SetCharacterDataHandler (p, char_data);
  XML_SetExternalEntityRefHandler (p, external_entity);
  XML_SetCommentHandler (p, comment);
  XML_SetUserData (p, this);
  //XML_SetDefaultHandlerExpand (p, default_handler);
  //XML_SetEntityDeclHandler (p, entity);
  //XML_UseParserAsHandlerArg (p);
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::generic_parse> starting" << std::endl;
    }
  
  for (;;) 
    {
      int items;
      
      char* buff = (char*) XML_GetBuffer (p, BUFFSIZE + 1);
      
      items = fread (buff, 1, BUFFSIZE, docfd);
      
      if (ferror (docfd))
    {
      std::cout << "Read error" << std::endl;
      result = 0;
      break;
    }
      
      int done = feof (docfd);
      
      buff[items] = 0;
      
      //std::cout << "2) read=" << items << " [" << buff << "] " << done << std::endl;
      
      if (XML_ParseBuffer (p, BUFFSIZE, done) == XML_STATUS_ERROR) 
    {
      if (!done)
        {
          std::cout << "ExpatCoreParser::Parse error at line " << XML_GetCurrentLineNumber(p)
            << " of file " << file_name
            << ":" << std::endl
            << XML_ErrorString (XML_GetErrorCode(p)) << std::endl;
          result = 0;
        }
      /* handle parse error */
    }
      if (done) break;
    }  
  
  fclose (docfd);
  
  return (result);
}

generic_text_parse()

int ExpatCoreParser::generic_text_parse ( XML_Parser  p, const std::string &  text  )

private

Definition at line 411 of file ExpatCoreParser.cxx.

{
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::generic_text_parse> " << std::endl; 
    }
  
  int result = 1;
  
  XML_SetParamEntityParsing (p, XML_PARAM_ENTITY_PARSING_ALWAYS);
  XML_SetElementHandler (p, start, end);
  XML_SetCharacterDataHandler (p, char_data);
  XML_SetExternalEntityRefHandler (p, external_entity);
  XML_SetCommentHandler (p, comment);
  XML_SetUserData (p, this);
  //XML_SetDefaultHandlerExpand (p, default_handler);
  //XML_SetEntityDeclHandler (p, entity);
  //XML_UseParserAsHandlerArg (p);
  
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::generic_text_parse> starting" << std::endl;
    }
  
  //for (;;) 
    {
      char* buff = (char*) XML_GetBuffer (p, text.size() + 1);
      strcpy (buff, text.c_str ());
 
      int done = 1;
 
      if (XML_ParseBuffer (p, text.size(), done) == XML_STATUS_ERROR) 
    {
            std::cout << "ExpatCoreParser::Parse error at line " << XML_GetCurrentLineNumber(p)
                      << ":" << std::endl
                      << XML_ErrorString (XML_GetErrorCode(p)) << std::endl;
            result = 0;
      /* handle parse error */
    }
      //if (done) break;
    }  
 
  return (result);
}

get_document()

std::unique_ptr< CoreParser::DOMNode > ExpatCoreParser::get_document ( )

private

Definition at line 151 of file ExpatCoreParser.cxx.

{
  return std::move(m_top);
}

parse()

std::unique_ptr< CoreParser::DOMNode > ExpatCoreParser::parse ( const std::string &  file_name )

static

Definition at line 557 of file ExpatCoreParser.cxx.

{
  std::string name = file_name;
 
  std::string::size_type pos = file_name.rfind ('/');
  std::string prefix;
  if (pos != std::string::npos)
    {
      prefix = file_name.substr (0, pos);
      name = file_name.substr (pos + 1);
    }
 
  ExpatCoreParser me (prefix);
  XML_Parser p = XML_ParserCreate (NULL);
 
  if (!p) 
    {
      std::cout << "ExpatCoreParser::Couldn't allocate memory for parser" << std::endl;
      std::abort();
    }
 
  me.generic_parse (p, name);
 
  XML_ParserFree (p);
 
  return me.get_document ();
}

register_external_entity()

void ExpatCoreParser::register_external_entity ( const std::string &  name, const std::string &  file_name  )

static

Definition at line 84 of file ExpatCoreParser.cxx.

{
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::register_external_entity> name=" << name
        << " file_name=" << file_name << std::endl; 
    }
 
  lock_t lock (s_mutex);
  s_entities[name] = file_name; 
} 

register_text_entity()

void ExpatCoreParser::register_text_entity ( const std::string &  name, const std::string &  text  )

static

Definition at line 96 of file ExpatCoreParser.cxx.

{
  if (ExpatCoreParserDebugger::debug ())
    {
      std::cout << "ExpatCoreParser::register_text_entity> name=" << name
        << std::endl; 
    }
 
  lock_t lock (s_mutex);
  s_text_entities[name] = text; 
} 

start()

void ExpatCoreParser::start ( void *  user_data, const char *  el, const char **  attr  )

staticprivate

Definition at line 43 of file ExpatCoreParser.cxx.

{
  ExpatCoreParser& me = *reinterpret_cast<ExpatCoreParser*> (user_data);
  me.do_start (el, attr);
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

ExternalEntityMap s_entities ExpatCoreParser::ATLAS_THREAD_SAFE

staticprivate

Definition at line 72 of file ExpatCoreParser.h.

ATLAS_THREAD_SAFE [2/2]

ExternalEntityMap s_text_entities ExpatCoreParser::ATLAS_THREAD_SAFE

staticprivate

Definition at line 73 of file ExpatCoreParser.h.

m_last

CoreParser::DOMNode* ExpatCoreParser::m_last

private

Definition at line 67 of file ExpatCoreParser.h.

m_prefix

std::string ExpatCoreParser::m_prefix

private

Definition at line 68 of file ExpatCoreParser.h.

m_top

std::unique_ptr<CoreParser::DOMNode> ExpatCoreParser::m_top

private

Definition at line 66 of file ExpatCoreParser.h.

s_mutex

std::mutex ExpatCoreParser::s_mutex

staticprivate

Definition at line 70 of file ExpatCoreParser.h.

---

The documentation for this class was generated from the following files:

• ExpatCoreParser.h
• ExpatCoreParser.cxx