#include "aux-ginga.h"
#include "Parser.h"
#include "Context.h"
#include "Document.h"
#include "Media.h"
#include "MediaSettings.h"
#include "Switch.h"
#include <libxml/tree.h>
#include <libxml/parser.h>

Include dependency graph for Parser.cpp:

Classes
class	ParserElt

struct	ParserConnRole

struct	ParserLinkBind

class	ParserState

struct	ParserSyntaxAttr

struct	ParserSyntaxElt

Macros
#define	toCString(s) deconst (char *, (s))

#define	toXmlChar(s) (xmlChar )(deconst (char , (s).c_str ()))

#define	toCPPString(s) string (deconst (char *, (s)))

#define	UDATA_GET(obj, key, ptr)

#define	UDATA_SET(obj, key, ptr, fn)

#define	ATTR_REQUIRED (PARSER_SYNTAX_ATTR_REQUIRED)

#define	ATTR_UNIQUE (PARSER_SYNTAX_ATTR_UNIQUE)

#define	ATTR_NONEMPTY (PARSER_SYNTAX_ATTR_NONEMPTY)

#define	ATTR_NAME (PARSER_SYNTAX_ATTR_NAME)

#define	ATTR_NONEMPTY_NAME (ATTR_NONEMPTY \| ATTR_NAME)

#define	ATTR_REQUIRED_NONEMPTY_NAME (ATTR_REQUIRED \| ATTR_NONEMPTY_NAME)

#define	ATTR_ID (ATTR_UNIQUE \| ATTR_REQUIRED_NONEMPTY_NAME)

#define	ATTR_OPT_ID (ATTR_UNIQUE \| ATTR_NONEMPTY_NAME)

#define	ATTR_IDREF (ATTR_REQUIRED_NONEMPTY_NAME)

#define	ATTR_OPT_IDREF (ATTR_NONEMPTY_NAME)

#define	ELT_CACHE (PARSER_SYNTAX_ELT_CACHE)

#define	ELT_GEN_ID (PARSER_SYNTAX_ELT_GEN_ID)

#define	PARSER_SYNTAX_TABLE_INDEX_DEFN(tabname, Type)

#define	FLAGS (XML_PARSE_NOERROR \| XML_PARSE_NOWARNING)

Typedefs
typedef struct ParserConnRole	ParserConnRole

typedef struct ParserLinkBind	ParserLinkBind

typedef bool(	ParserSyntaxEltPush) (ParserState , ParserElt )

typedef bool(	ParserSyntaxEltPop) (ParserState , ParserElt )

typedef struct ParserSyntaxAttr	ParserSyntaxAttr

typedef struct ParserSyntaxElt	ParserSyntaxElt

Enumerations
enum	ParserSyntaxAttrFlag { PARSER_SYNTAX_ATTR_REQUIRED = 1<<1, PARSER_SYNTAX_ATTR_UNIQUE = 1<<2, PARSER_SYNTAX_ATTR_NONEMPTY = 1<<3, PARSER_SYNTAX_ATTR_NAME = 1<<4 }

enum	ParserSyntaxEltFlag { PARSER_SYNTAX_ELT_CACHE = 1<<1, PARSER_SYNTAX_ELT_GEN_ID = 1<<2 }

Functions
static bool	xmlGetPropAsString (xmlNode node, const string &name, string result)

static bool	xmlIsValidName (const string &value, char *offending)

static bool	parser_syntax_table_index (const string &tag, ParserSyntaxElt **result)

static map< string, bool >	parser_syntax_table_get_possible_children (const string &tag)

static bool	parser_syntax_reserved_role_table_index (const string &role, bool condition, Event::Type type, Event::Transition *transition)

	PARSER_SYNTAX_TABLE_INDEX_DEFN (event_type, Event::Type)

	PARSER_SYNTAX_TABLE_INDEX_DEFN (transition, Event::Transition)

	PARSER_SYNTAX_TABLE_INDEX_DEFN (connective, Predicate::Type)

	PARSER_SYNTAX_TABLE_INDEX_DEFN (comparator, Predicate::Test)

static bool	parser_syntax_parse_bool (const string &str, bool *result)

static void	savedRectCleanup (void *ptr)

static void	assessCleanup (void *ptr)

static void	rolesCleanup (void *ptr)

static void	predCleanup (void *ptr)

static void	leftOrRightCleanup (void *ptr)

static void	portsCleanup (void *ptr)

static void	bindsCleanup (void *ptr)

static void	paramsCleanup (void *ptr)

static Document *	process (xmlDoc xml, int width, int height, string errmsg)

Variables
static map< string, ParserSyntaxElt >	parser_syntax_table

static map< string, pair< Event::Type, Event::Transition > >	parser_syntax_reserved_role_table

static map< string, Event::Type >	parser_syntax_event_type_table

static map< string, Event::Transition >	parser_syntax_transition_table

static map< string, Predicate::Type >	parser_syntax_connective_table

static map< string, Predicate::Test >	parser_syntax_comparator_table

Macro Definition Documentation

#define ATTR_ID (ATTR_UNIQUE | ATTR_REQUIRED_NONEMPTY_NAME)

#define ATTR_IDREF (ATTR_REQUIRED_NONEMPTY_NAME)

#define ATTR_NAME (PARSER_SYNTAX_ATTR_NAME)

Referenced by ParserState::processNode().

#define ATTR_NONEMPTY (PARSER_SYNTAX_ATTR_NONEMPTY)

Referenced by ParserState::processNode().

#define ATTR_NONEMPTY_NAME (ATTR_NONEMPTY | ATTR_NAME)

#define ATTR_OPT_ID (ATTR_UNIQUE | ATTR_NONEMPTY_NAME)

#define ATTR_OPT_IDREF (ATTR_NONEMPTY_NAME)

#define ATTR_REQUIRED (PARSER_SYNTAX_ATTR_REQUIRED)

Referenced by ParserState::processNode().

#define ATTR_REQUIRED_NONEMPTY_NAME (ATTR_REQUIRED | ATTR_NONEMPTY_NAME)

#define ATTR_UNIQUE (PARSER_SYNTAX_ATTR_UNIQUE)

Referenced by ParserState::processNode().

#define ELT_CACHE (PARSER_SYNTAX_ELT_CACHE)

Referenced by ParserState::processNode().

#define ELT_GEN_ID (PARSER_SYNTAX_ELT_GEN_ID)

Referenced by ParserState::processNode().

#define FLAGS (XML_PARSE_NOERROR | XML_PARSE_NOWARNING)

Referenced by Parser::parseBuffer(), and Parser::parseFile().

#define PARSER_SYNTAX_TABLE_INDEX_DEFN	(	tabname,
		Type
	)

Value:

static bool                                                   \
  parser_syntax_##tabname##_table_index (const string &str,     \
                                         Type *result)          \
  {                                                             \
    auto it = parser_syntax_##tabname##_table.find (str);       \
    if (it == parser_syntax_##tabname##_table.end ())           \
      return false;                                             \
    tryset (result, it->second);                                \
    return true;                                                \
  }

#define toCPPString ( s ) string (deconst (char *, (s)))

Referenced by ParserElt::ParserElt(), ParserState::popRegion(), ParserState::processNode(), ParserState::pushMedia(), ParserState::pushRegion(), and xmlGetPropAsString().

#define toCString ( s ) deconst (char *, (s))

Referenced by ParserState::errElt().

#define toXmlChar ( s ) (xmlChar *)(deconst (char *, (s).c_str ()))

Referenced by xmlGetPropAsString().

#define UDATA_GET	(	obj,
		key,
		ptr
	)

Value:

G_STMT_START                                          \
  {                                                     \
    *(ptr) = nullptr;                                   \
    g_assert ((obj)->getData ((key), (void **)(ptr)));  \
    g_assert_nonnull (*(ptr));                          \
  }                                                     \
  G_STMT_END

Referenced by ParserState::popAssessmentStatement(), ParserState::popCausalConnector(), ParserState::popCompoundStatement(), ParserState::popContext(), ParserState::popNcl(), ParserState::pushAttributeAssessment(), ParserState::pushBind(), ParserState::pushCompoundStatement(), ParserState::pushLinkParam(), ParserState::pushPort(), ParserState::pushRegion(), and ParserState::pushSimpleCondition().

#define UDATA_SET	(	obj,
		key,
		ptr,
		fn
	)

Value:

G_STMT_START                                          \
  {                                                     \
    (obj)->setData ((key), (void *)(ptr), (fn));        \
  }                                                     \
  G_STMT_END

Referenced by ParserState::popCausalConnector(), ParserState::pushAttributeAssessment(), ParserState::pushBind(), ParserState::pushCausalConnector(), ParserState::pushCompoundCondition(), ParserState::pushCompoundStatement(), ParserState::pushContext(), ParserState::pushLink(), and ParserState::pushRegion().

Typedef Documentation

typedef struct ParserConnRole ParserConnRole

typedef struct ParserLinkBind ParserLinkBind

typedef struct ParserSyntaxAttr ParserSyntaxAttr

typedef struct ParserSyntaxElt ParserSyntaxElt

typedef bool( ParserSyntaxEltPop) (ParserState *, ParserElt *)

typedef bool( ParserSyntaxEltPush) (ParserState *, ParserElt *)

Enumeration Type Documentation

enum ParserSyntaxAttrFlag

Enumerator
PARSER_SYNTAX_ATTR_REQUIRED
PARSER_SYNTAX_ATTR_UNIQUE
PARSER_SYNTAX_ATTR_NONEMPTY
PARSER_SYNTAX_ATTR_NAME

enum ParserSyntaxEltFlag

Enumerator
PARSER_SYNTAX_ELT_CACHE
PARSER_SYNTAX_ELT_GEN_ID

Function Documentation

static void assessCleanup ( void * ptr )

static

Referenced by ParserState::pushCausalConnector().

static void bindsCleanup ( void * ptr )

static

Referenced by ParserState::pushLink().

static void leftOrRightCleanup ( void * ptr )

static

Referenced by ParserState::pushAttributeAssessment().

static void paramsCleanup ( void * ptr )

static

Referenced by ParserState::pushLink().

static bool parser_syntax_parse_bool	(	const string &	str,
		bool *	result
	)

static

References try_parse_bool().

Referenced by ParserState::pushCompoundStatement().

static bool parser_syntax_reserved_role_table_index	(	const string &	role,
		bool *	condition,
		Event::Type *	type,
		Event::Transition *	transition
	)

static

References parser_syntax_reserved_role_table, tryset, and xstrhasprefix().

Referenced by ParserState::pushSimpleCondition().

static map<string, bool> parser_syntax_table_get_possible_children ( const string & tag )

static

References parser_syntax_table.

Referenced by ParserState::processNode().

static bool parser_syntax_table_index	(	const string &	tag,
		ParserSyntaxElt **	result
	)

static

References parser_syntax_table, and tryset.

Referenced by ParserState::processNode().

PARSER_SYNTAX_TABLE_INDEX_DEFN	(	event_type	,
		Event::Type
	)

PARSER_SYNTAX_TABLE_INDEX_DEFN	(	transition	,
		Event::Transition
	)

PARSER_SYNTAX_TABLE_INDEX_DEFN	(	connective	,
		Predicate::Type
	)

PARSER_SYNTAX_TABLE_INDEX_DEFN	(	comparator	,
		Predicate::Test
	)

static void portsCleanup ( void * ptr )

static

Referenced by ParserState::pushContext().

static void predCleanup ( void * ptr )

static

Referenced by ParserState::pushCompoundCondition().

static Document* process	(	xmlDoc *	xml,
		int	width,
		int	height,
		string *	errmsg
	)

static

References ParserState::ERROR_NONE, g_assert(), ParserState::getError(), ParserState::process(), and unlikely.

Referenced by Parser::parseBuffer(), and Parser::parseFile().

static void rolesCleanup ( void * ptr )

static

Referenced by ParserState::pushCausalConnector().

static void savedRectCleanup ( void * ptr )

static

Referenced by ParserState::pushRegion().

static bool xmlGetPropAsString	(	xmlNode *	node,
		const string &	name,
		string *	result
	)

inlinestatic

References g_free(), toCPPString, toXmlChar, and tryset.

Referenced by ParserState::processNode().

static bool xmlIsValidName	(	const string &	value,
		char *	offending
	)

static

References tryset.

Referenced by ParserState::processNode().

Variable Documentation

map<string, Predicate::Test> parser_syntax_comparator_table

static

Initial value:

=
{
 {"eq",  Predicate::EQ},
 {"ne",  Predicate::NE},
 {"lt",  Predicate::LT},
 {"lte", Predicate::LE},
 {"gt",  Predicate::GT},
 {"gte", Predicate::GE},
}

map<string, Predicate::Type> parser_syntax_connective_table

static

Initial value:

=
{
 {"not", Predicate::NEGATION},
 {"and", Predicate::CONJUNCTION},
 {"or",  Predicate::DISJUNCTION},
}

map<string, Event::Type> parser_syntax_event_type_table

static

Initial value:

=
{
 {"presentation", Event::PRESENTATION},
 {"attribution",  Event::ATTRIBUTION},
 {"selection",    Event::SELECTION},
}

map<string, pair<Event::Type, Event::Transition> > parser_syntax_reserved_role_table

static

Initial value:

=
{
 {"onBegin",            {Event::PRESENTATION, Event::START}}, 
 {"onEnd",              {Event::PRESENTATION, Event::STOP}},
 {"onAbort",            {Event::PRESENTATION, Event::ABORT}},
 {"onPause",            {Event::PRESENTATION, Event::PAUSE}},
 {"onResumes",          {Event::PRESENTATION, Event::RESUME}},
 {"onBeginAttribution", {Event::ATTRIBUTION,  Event::START}},
 {"onEndAttribution",   {Event::ATTRIBUTION,  Event::STOP}},
 {"onSelection",        {Event::SELECTION,    Event::START}},
 {"onBeginSelection",   {Event::SELECTION,    Event::START}},
 {"onEndSelection",     {Event::SELECTION,    Event::STOP}},
 {"start",              {Event::PRESENTATION, Event::START}}, 
 {"stop",               {Event::PRESENTATION, Event::STOP}},
 {"abort",              {Event::PRESENTATION, Event::ABORT}},
 {"pause",              {Event::PRESENTATION, Event::PAUSE}},
 {"resume",             {Event::PRESENTATION, Event::RESUME}},
 {"set",                {Event::ATTRIBUTION,  Event::START}},
}

Referenced by parser_syntax_reserved_role_table_index().

map<string, ParserSyntaxElt> parser_syntax_table

static

Referenced by parser_syntax_table_get_possible_children(), and parser_syntax_table_index().

map<string, Event::Transition> parser_syntax_transition_table

static

Initial value:

=
{
 {"start",   Event::START},
 {"starts",  Event::START},
 {"pause",   Event::PAUSE},
 {"pauses",  Event::PAUSE},
 {"resume",  Event::RESUME},
 {"resumes", Event::RESUME},
 {"stop",    Event::STOP},
 {"stops",   Event::STOP},
 {"abort",   Event::ABORT},
 {"aborts",  Event::ABORT},
}

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation