SimpleSAXParser Class Reference

#include <SimpleSAXParser.h>

Inheritance diagram for SimpleSAXParser:

Classes
struct	Attribute
class	ParserError

Public Types
typedef std::vector< Attribute >	Attributes
enum	PARSER_STATES {   IN_DOCUMENT, IN_BEGIN_TAG, IN_DONE, IN_BEGIN_ELEMENT,   IN_ELEMENT_WHITESPACE, IN_END_ELEMENT, IN_ATTRIBUTE_KEY, IN_END_TAG,   IN_DATA, IN_BEGIN_ATTRIBUTE_VALUE, IN_STRING, IN_END_ATTRIBUTE_VALUE,   IN_STRING_ENTITY, IN_DATA_ENTITY }

Public Member Functions
virtual void	data (const std::string &)
virtual void	endElement (const std::string &)
const SimpleSAXParser &	operator= (const SimpleSAXParser &)=delete
void	parse (void)
	SimpleSAXParser (std::istream &f)
	SimpleSAXParser (const SimpleSAXParser &)=delete
virtual void	startElement (const std::string &, Attributes &)
virtual	~SimpleSAXParser ()

Private Member Functions
std::string	getToken (const char *delim)
std::string	getToken (const char delim)
int	nextChar (void)
std::string	parseEntity (const std::string &entity)
bool	skipChar (int c)

Private Attributes
Attributes	m_attributes
char *	m_buffer
size_t	m_bufferSize
std::vector< std::string >	m_elementTags
std::istream &	m_in
int	m_nextChar

Detailed Description

A simple SAX parser which is able to parse the configuration.

State machine for the parser can be drawn by cut and pasting the following to graphviz:

digraph { IN_DOCUMENT->IN_BEGIN_TAG [label="nextChar == '<'"]; IN_DOCUMENT->IN_DATA [label="nextChar != '<'"];

IN_BEGIN_TAG->IN_BEGIN_ELEMENT [label="nextChar >= 'a' && nextChar < 'Z'"]; IN_BEGIN_TAG->IN_END_ELEMENT [label= "nextChar == '/'"];

IN_BEGIN_ELEMENT->IN_END_ELEMENT [label="nextChar == '/'"]; IN_BEGIN_ELEMENT->IN_ELEMENT_WHITESPACE [label="nextChar == ' '"]; IN_BEGIN_ELEMENT->IN_END_TAG [label="nextChar == '>'"];

IN_ELEMENT_WHITESPACE->IN_ELEMENT_WHITESPACE [ label = "nextChar == \"\ \t\n""] IN_ELEMENT_WHITESPACE->IN_ATTRIBUTE_KEY [ label = "nextChar >= 'a' && nextChar < 'Z'"] IN_ELEMENT_WHITESPACE->IN_END_ELEMENT [label="nextChar == '/'"]

IN_END_ELEMENT->IN_END_TAG [label = "nextChar == '>'"];

IN_END_TAG->IN_BEGIN_TAG [label="nextChar == '<'"]; IN_END_TAG->IN_DATA [label="nextChar != '<'"]

IN_DATA->IN_BEGIN_TAG [label="nextChar == '<'"]; IN_DATA->IN_DATA_ENTITY [label="nextChar == '&'"]; IN_DATA->IN_DONE [label = "nextChar == EOF"];

IN_DATA_ENTITY->IN_DATA [label="nextChar == ';'"];

IN_ATTRIBUTE_KEY->IN_BEGIN_ATTRIBUTE_VALUE [label = "nextChar == '='"]

IN_BEGIN_ATTRIBUTE_VALUE->IN_STRING [label = "nextChar == '\"' || nextChar == '\'' "]

IN_STRING->IN_END_ATTRIBUTE_VALUE [label = "nextChar == quote"] IN_STRING->IN_STRING_ENTITY [label = "nextChar == '&'"]

IN_END_ATTRIBUTE_VALUE->IN_ELEMENT_WHITESPACE [label = "nextChar == ' '"] IN_END_ATTRIBUTE_VALUE->IN_END_ELEMENT [label = "nextChar == '/'"] IN_END_ATTRIBUTE_VALUE->IN_END_TAG [label = "nextChar == '>'"]

IN_STRING_ENTITY->IN_STRING [label = "nextChar == ';'"] }

Definition at line 69 of file SimpleSAXParser.h.

Member Typedef Documentation

Attributes

typedef std::vector<Attribute> SimpleSAXParser::Attributes

Definition at line 80 of file SimpleSAXParser.h.

Member Enumeration Documentation

PARSER_STATES

enum SimpleSAXParser::PARSER_STATES

Enumerator
IN_DOCUMENT
IN_BEGIN_TAG
IN_DONE
IN_BEGIN_ELEMENT
IN_ELEMENT_WHITESPACE
IN_END_ELEMENT
IN_ATTRIBUTE_KEY
IN_END_TAG
IN_DATA
IN_BEGIN_ATTRIBUTE_VALUE
IN_STRING
IN_END_ATTRIBUTE_VALUE
IN_STRING_ENTITY
IN_DATA_ENTITY

Definition at line 91 of file SimpleSAXParser.h.

                     {
    IN_DOCUMENT,
    IN_BEGIN_TAG,
    IN_DONE,
    IN_BEGIN_ELEMENT,
    IN_ELEMENT_WHITESPACE,
    IN_END_ELEMENT,
    IN_ATTRIBUTE_KEY,
    IN_END_TAG,
    IN_DATA,
    IN_BEGIN_ATTRIBUTE_VALUE,
    IN_STRING,
    IN_END_ATTRIBUTE_VALUE,
    IN_STRING_ENTITY,
    IN_DATA_ENTITY
  };

Constructor & Destructor Documentation

SimpleSAXParser() [1/2]

SimpleSAXParser::SimpleSAXParser ( std::istream &  f )

inline

Definition at line 108 of file SimpleSAXParser.h.

      : m_in(f), m_bufferSize(1024), m_buffer(new char[m_bufferSize]), m_nextChar(m_in.get()) {}

~SimpleSAXParser()

SimpleSAXParser::~SimpleSAXParser ( )

virtual

Definition at line 197 of file SimpleSAXParser.cc.

References m_buffer.

{ delete[] m_buffer; }

SimpleSAXParser() [2/2]

SimpleSAXParser::SimpleSAXParser ( const SimpleSAXParser &  )

delete

Member Function Documentation

data()

virtual void SimpleSAXParser::data ( const std::string &  )

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 117 of file SimpleSAXParser.h.

Referenced by parse().

{}

endElement()

virtual void SimpleSAXParser::endElement ( const std::string &  )

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 116 of file SimpleSAXParser.h.

Referenced by parse().

{}

getToken() [1/2]

std::string SimpleSAXParser::getToken ( const char *  delim )

inlineprivate

Definition at line 124 of file SimpleSAXParser.h.

References fgettoken(), m_buffer, m_bufferSize, m_in, and m_nextChar.

Referenced by parse().

                                        {
    fgettoken(m_in, &m_buffer, &m_bufferSize, delim, &m_nextChar);
    return m_buffer;
  }

getToken() [2/2]

std::string SimpleSAXParser::getToken ( const char  delim )

inlineprivate

Definition at line 129 of file SimpleSAXParser.h.

References visDQMUpload::buf, fgettoken(), m_buffer, m_bufferSize, m_in, and m_nextChar.

                                       {
    char buf[2] = {delim, 0};
    fgettoken(m_in, &m_buffer, &m_bufferSize, buf, &m_nextChar);
    m_nextChar = m_in.get();
    return m_buffer;
  }

nextChar()

int SimpleSAXParser::nextChar ( void  )

inlineprivate

Definition at line 143 of file SimpleSAXParser.h.

References m_nextChar.

Referenced by parse().

{ return m_nextChar; }

operator=()

const SimpleSAXParser& SimpleSAXParser::operator= ( const SimpleSAXParser &  )

delete

parse()

void SimpleSAXParser::parse

(

void

)

Runs the state machine of the parser, invoking startElement(), setAttribute(), endElement(), data() virtual methods as approppriate. In order have the parser doing something usefull you need to derive from it and specialize the above mentioned virtual methods.

Default implementation is in any case useful to check syntax.

Definition at line 46 of file SimpleSAXParser.cc.

References data(), debug_state_machine(), endElement(), getToken(), mps_fire::i, IN_ATTRIBUTE_KEY, IN_BEGIN_ATTRIBUTE_VALUE, IN_BEGIN_ELEMENT, IN_BEGIN_TAG, IN_DATA, IN_DATA_ENTITY, IN_DOCUMENT, IN_DONE, IN_ELEMENT_WHITESPACE, IN_END_ATTRIBUTE_VALUE, IN_END_ELEMENT, IN_END_TAG, IN_STRING, IN_STRING_ENTITY, SimpleSAXParser::Attribute::key, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, m_attributes, m_elementTags, nextChar(), parseEntity(), skipChar(), startElement(), AlCaHLTBitMon_QueryRunRegistry::string, and createJobs::tmp.

Referenced by FWConfigurationManager::readFromFile().

                                {
  enum PARSER_STATES state = IN_DOCUMENT;
  // Current delimiters for strings in attributes.
  char stringDelims[] = "\"&";
  std::string attributeName;
  std::string attributeValue;
  std::string tmp;
  std::string currentData;

  while (state != IN_DONE) {
    debug_state_machine(state);

    switch (state) {
      // FIXME: IN_DOCUMENT should check the dtd...
      case IN_DOCUMENT:
        state = IN_DATA;
        if (skipChar('<'))
          state = IN_BEGIN_TAG;
        break;

      case IN_BEGIN_TAG:
        if (nextChar() >= 'A' && nextChar() <= 'z')
          state = IN_BEGIN_ELEMENT;
        else if (skipChar('/'))
          state = IN_END_ELEMENT;
        else
          throw ParserError("Bad tag");
        break;

      case IN_BEGIN_ELEMENT:
        m_attributes.clear();
        m_elementTags.push_back(getToken(" />"));
        if (nextChar() == ' ')
          state = IN_ELEMENT_WHITESPACE;
        else if (skipChar('/'))
          state = IN_END_ELEMENT;
        else if (skipChar('>')) {
          startElement(m_elementTags.back(), m_attributes);
          state = IN_END_TAG;
        } else
          throw ParserError("Bad element.");
        break;

      case IN_ELEMENT_WHITESPACE:
        while (skipChar(' ') || skipChar('\n') || skipChar('\t')) {
        }

        if (nextChar() >= 'A' && nextChar() <= 'z')
          state = IN_ATTRIBUTE_KEY;
        else if (nextChar() == '/')
          state = IN_END_ELEMENT;
        else
          throw ParserError("Syntax error in element" + m_elementTags.back());
        break;

      case IN_ATTRIBUTE_KEY:
        attributeName = getToken('=');
        state = IN_BEGIN_ATTRIBUTE_VALUE;
        break;

      case IN_BEGIN_ATTRIBUTE_VALUE:
        if (skipChar('"')) {
          state = IN_STRING;
          attributeValue.clear();
          stringDelims[0] = '\"';
        } else if (skipChar('\'')) {
          state = IN_STRING;
          attributeValue.clear();
          stringDelims[0] = '\'';
        } else
          throw ParserError("Expecting quotes.");
        break;

      case IN_STRING:
        attributeValue += getToken(stringDelims);
        if (skipChar(stringDelims[0])) {
          // Save the attributes in order, replacing those that are
          // specified more than once.
          Attribute attr(attributeName, attributeValue);
          Attributes::iterator i = std::lower_bound(m_attributes.begin(), m_attributes.end(), attr);
          if (i != m_attributes.end() && i->key == attr.key)
            throw ParserError("Attribute " + i->key + " defined more than once");
          m_attributes.insert(i, attr);
          state = IN_END_ATTRIBUTE_VALUE;
        } else if (skipChar(stringDelims[1]))
          state = IN_STRING_ENTITY;
        else
          throw ParserError("Unexpected end of input at " + attributeValue);
        break;

      case IN_END_ATTRIBUTE_VALUE:
        getToken(" />");
        if (nextChar() == ' ')
          state = IN_ELEMENT_WHITESPACE;
        else if (skipChar('/'))
          state = IN_END_ELEMENT;
        else if (skipChar('>')) {
          startElement(m_elementTags.back(), m_attributes);
          state = IN_END_TAG;
        }
        break;

      case IN_END_ELEMENT:
        tmp = getToken('>');
        if (!tmp.empty() && tmp != m_elementTags.back())
          throw ParserError("Non-matching closing element " + tmp + " for " + attributeValue);
        endElement(tmp);
        m_elementTags.pop_back();
        state = IN_END_TAG;
        break;

      case IN_END_TAG:
        if (nextChar() == EOF)
          return;
        else if (skipChar('<'))
          state = IN_BEGIN_TAG;
        else
          state = IN_DATA;
        break;

      case IN_DATA:
        currentData += getToken("<&");
        if (skipChar('&'))
          state = IN_DATA_ENTITY;
        else if (skipChar('<')) {
          data(currentData);
          currentData.clear();
          state = IN_BEGIN_TAG;
        } else if (nextChar() == EOF) {
          data(currentData);
          return;
        } else
          throw ParserError("Unexpected end of input in element " + m_elementTags.back() + currentData);
        break;

      case IN_DATA_ENTITY:
        currentData += parseEntity(getToken(';'));
        state = IN_DATA;
        break;

      case IN_STRING_ENTITY:
        attributeValue += parseEntity(getToken(';'));
        state = IN_STRING;
        break;

      case IN_DONE:
        return;
    }
  }
}

parseEntity()

std::string SimpleSAXParser::parseEntity ( const std::string &  entity )

private

Helper function to handle entities, i.e. characters specified with the "&label;" syntax.

Definition at line 6 of file SimpleSAXParser.cc.

Referenced by parse().

                                                              {
  if (entity == "quot")
    return "\"";
  else if (entity == "amp")
    return "&";
  else if (entity == "lt")
    return "<";
  else if (entity == "gt")
    return ">";
  throw ParserError("Unknown entity " + entity);
}

skipChar()

bool SimpleSAXParser::skipChar ( int  c )

inlineprivate

Definition at line 136 of file SimpleSAXParser.h.

References HltBtagPostValidation_cff::c, m_in, and m_nextChar.

Referenced by parse().

                       {
    if (m_nextChar != c)
      return false;
    m_nextChar = m_in.get();
    return true;
  }

startElement()

virtual void SimpleSAXParser::startElement ( const std::string &  , Attributes &    )

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 115 of file SimpleSAXParser.h.

Referenced by parse().

{}

Member Data Documentation

m_attributes

Attributes SimpleSAXParser::m_attributes

private

Definition at line 150 of file SimpleSAXParser.h.

Referenced by parse().

m_buffer

char* SimpleSAXParser::m_buffer

private

Definition at line 147 of file SimpleSAXParser.h.

Referenced by getToken(), and ~SimpleSAXParser().

m_bufferSize

size_t SimpleSAXParser::m_bufferSize

private

Definition at line 146 of file SimpleSAXParser.h.

Referenced by getToken().

m_elementTags

std::vector<std::string> SimpleSAXParser::m_elementTags

private

Definition at line 149 of file SimpleSAXParser.h.

Referenced by parse().

m_in

std::istream& SimpleSAXParser::m_in

private

Definition at line 145 of file SimpleSAXParser.h.

Referenced by getToken(), and skipChar().

m_nextChar

int SimpleSAXParser::m_nextChar

private

Definition at line 148 of file SimpleSAXParser.h.

Referenced by getToken(), nextChar(), and skipChar().