#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 &)

void	parse (void)

	SimpleSAXParser (std::istream &f)

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)

const SimpleSAXParser &	operator= (const SimpleSAXParser &)=delete

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

	SimpleSAXParser (const SimpleSAXParser &)=delete

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 71 of file SimpleSAXParser.h.

Member Typedef Documentation

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

Definition at line 93 of file SimpleSAXParser.h.

Member Enumeration Documentation

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 106 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::SimpleSAXParser ( std::istream & f )

inline

Definition at line 123 of file SimpleSAXParser.h.

References parse(), and ~SimpleSAXParser().

Referenced by data().

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

SimpleSAXParser::~SimpleSAXParser ( )

virtual

Definition at line 223 of file SimpleSAXParser.cc.

References m_buffer.

Referenced by SimpleSAXParser().

223 { delete [] m_buffer;}

SimpleSAXParser::m_buffer

char * m_buffer

Definition: SimpleSAXParser.h:170

SimpleSAXParser::SimpleSAXParser ( const SimpleSAXParser & )

privatedelete

Member Function Documentation

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

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 137 of file SimpleSAXParser.h.

References operator=(), parseEntity(), SimpleSAXParser(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parse().

137 {}

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

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 136 of file SimpleSAXParser.h.

Referenced by parse().

136 {}

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

inlineprivate

Definition at line 144 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;
       }

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

inlineprivate

Definition at line 150 of file SimpleSAXParser.h.

References tablePrinter::delim, 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;
       }

int SimpleSAXParser::nextChar ( void )

inlineprivate

Definition at line 166 of file SimpleSAXParser.h.

References m_nextChar.

Referenced by parse().

166 { return m_nextChar; }

SimpleSAXParser::m_nextChar

int m_nextChar

Definition: SimpleSAXParser.h:171

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

privatedelete

Referenced by data().

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 53 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, m_attributes, m_elementTags, nextChar(), parseEntity(), skipChar(), startElement(), AlCaHLTBitMon_QueryRunRegistry::string, and tmp.

Referenced by FWPartialConfigGUI::FWPartialConfigGUI(), FWConfigurationManager::readFromFile(), SimpleSAXParser(), and FWPartialConfigSaveGUI::WriteConfig().

 {
    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;
       }
    }
 }

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 7 of file SimpleSAXParser.cc.

Referenced by data(), and 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);      
 }

bool SimpleSAXParser::skipChar ( int c )

inlineprivate

Definition at line 158 of file SimpleSAXParser.h.

References m_in, and m_nextChar.

Referenced by parse().

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

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

inlinevirtual

Reimplemented in FWXMLConfigParser.

Definition at line 134 of file SimpleSAXParser.h.

Referenced by parse().

135 {}

Member Data Documentation

Attributes SimpleSAXParser::m_attributes

private

Definition at line 173 of file SimpleSAXParser.h.

Referenced by parse().

char* SimpleSAXParser::m_buffer

private

Definition at line 170 of file SimpleSAXParser.h.

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

size_t SimpleSAXParser::m_bufferSize

private

Definition at line 169 of file SimpleSAXParser.h.

Referenced by getToken().

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

private

Definition at line 172 of file SimpleSAXParser.h.

Referenced by parse().

std::istream& SimpleSAXParser::m_in

private

Definition at line 168 of file SimpleSAXParser.h.

Referenced by getToken(), and skipChar().

int SimpleSAXParser::m_nextChar

private

Definition at line 171 of file SimpleSAXParser.h.

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

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation