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 139 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 53 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 65 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 59 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 174 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 202 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 188 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 166 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 347 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 146 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 47 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 102 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 ()){
    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 71 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 393 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 405 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 217 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.empty()) 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);
  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;
    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 317 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);
  if (ExpatCoreParserDebugger::debug ()) {
    std::cout << "ExpatCoreParser::generic_text_parse> starting" << std::endl;
  }
  {
    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 */
      }
  }  
  return (result);
}

get_document()

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

private

Definition at line 135 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 417 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();
  }
  int result = me.generic_parse (p, name);
  XML_ParserFree (p);
  if (result == 0) return nullptr;
  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 82 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 92 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 41 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