Structure xmlExpCtxt

struct _xmlExpCtxt {
The content of this structure is not made public by the API.
} xmlExpCtxt;

Typedef xmlExpCtxtPtr

xmlExpCtxt * xmlExpCtxtPtr;

Structure xmlExpNode

struct _xmlExpNode {
The content of this structure is not made public by the API.
} xmlExpNode;

Typedef xmlExpNodePtr

xmlExpNode * xmlExpNodePtr;

Enum xmlExpNodeType

enum xmlExpNodeType {
    XML_EXP_EMPTY = 0
    XML_EXP_FORBID = 1
    XML_EXP_ATOM = 2
    XML_EXP_SEQ = 3
    XML_EXP_OR = 4
    XML_EXP_COUNT = 5
};

Structure xmlRegExecCtxt

struct _xmlRegExecCtxt {
The content of this structure is not made public by the API.
} xmlRegExecCtxt;

Typedef xmlRegExecCtxtPtr

xmlRegExecCtxt * xmlRegExecCtxtPtr;

A libxml progressive regular expression evaluation context

Structure xmlRegexp

struct _xmlRegexp {
The content of this structure is not made public by the API.
} xmlRegexp;

Typedef xmlRegexpPtr

xmlRegexp * xmlRegexpPtr;

A libxml regular expression, they can actually be far more complex thank the POSIX regex expressions.

Function type xmlRegExecCallbacks

void	xmlRegExecCallbacks		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * token, 
					 void * transdata, 
					 void * inputdata)

Callback function when doing a transition in the automata

Variable emptyExp

xmlExpNodePtr emptyExp;

Variable forbiddenExp

xmlExpNodePtr forbiddenExp;

xmlExpCtxtNbCons ()

int	xmlExpCtxtNbCons		(xmlExpCtxtPtr ctxt)

Debugging facility provides the number of allocated nodes over lifetime

xmlExpCtxtNbNodes ()

int	xmlExpCtxtNbNodes		(xmlExpCtxtPtr ctxt)

Debugging facility provides the number of allocated nodes at a that point

xmlExpDump ()

void	xmlExpDump			(xmlBufferPtr buf, 
					 xmlExpNodePtr expr)

Serialize the expression as compiled to the buffer

xmlExpExpDerive ()

xmlExpNodePtr	xmlExpExpDerive		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub)

Evaluates the expression resulting from @exp consuming a sub expression @sub Based on algebraic derivation and sometimes direct Brzozowski derivation it usually takes less than linear time and can handle expressions generating infinite languages.

xmlExpFree ()

void	xmlExpFree			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp)

Dereference the expression

xmlExpFreeCtxt ()

void	xmlExpFreeCtxt			(xmlExpCtxtPtr ctxt)

Free an expression context

xmlExpGetLanguage ()

int	xmlExpGetLanguage		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** langList, 
					 int len)

Find all the strings used in @exp and store them in @list

xmlExpGetStart ()

int	xmlExpGetStart			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** tokList, 
					 int len)

Find all the strings that appears at the start of the languages accepted by @exp and store them in @list. E.g. for (a, b) | c it will return the list [a, c]

xmlExpIsNillable ()

int	xmlExpIsNillable		(xmlExpNodePtr exp)

Finds if the expression is nillable, i.e. if it accepts the empty sequence

xmlExpMaxToken ()

int	xmlExpMaxToken			(xmlExpNodePtr expr)

Indicate the maximum number of input a expression can accept

xmlExpNewAtom ()

xmlExpNodePtr	xmlExpNewAtom		(xmlExpCtxtPtr ctxt, 
					 const xmlChar * name, 
					 int len)

Get the atom associated to this name from that context

xmlExpNewCtxt ()

xmlExpCtxtPtr	xmlExpNewCtxt		(int maxNodes, 
					 xmlDictPtr dict)

Creates a new context for manipulating expressions

xmlExpNewOr ()

xmlExpNodePtr	xmlExpNewOr		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right)

Get the atom associated to the choice @left | @right Note that @left and @right are consumed in the operation, to keep an handle on them use xmlExpRef() and use xmlExpFree() to release them, this is true even in case of failure (unless ctxt == NULL).

xmlExpNewRange ()

xmlExpNodePtr	xmlExpNewRange		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr subset, 
					 int min, 
					 int max)

Get the atom associated to the range (@subset){@min, @max} Note that @subset is consumed in the operation, to keep an handle on it use xmlExpRef() and use xmlExpFree() to release it, this is true even in case of failure (unless ctxt == NULL).

xmlExpNewSeq ()

xmlExpNodePtr	xmlExpNewSeq		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right)

Get the atom associated to the sequence @left , @right Note that @left and @right are consumed in the operation, to keep an handle on them use xmlExpRef() and use xmlExpFree() to release them, this is true even in case of failure (unless ctxt == NULL).

xmlExpParse ()

xmlExpNodePtr	xmlExpParse		(xmlExpCtxtPtr ctxt, 
					 const char * expr)

Minimal parser for regexps, it understand the following constructs - string terminals - choice operator | - sequence operator , - subexpressions (...) - usual cardinality operators + * and ? - finite sequences { min, max } - infinite sequences { min, * } There is minimal checkings made especially no checking on strings values

xmlExpRef ()

void	xmlExpRef			(xmlExpNodePtr exp)

Increase the reference count of the expression

xmlExpStringDerive ()

xmlExpNodePtr	xmlExpStringDerive	(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar * str, 
					 int len)

Do one step of Brzozowski derivation of the expression @exp with respect to the input string

xmlExpSubsume ()

int	xmlExpSubsume			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub)

Check whether @exp accepts all the languages accepted by @sub the input being a subexpression.

xmlRegExecErrInfo ()

int	xmlRegExecErrInfo		(xmlRegExecCtxtPtr exec, 
					 const xmlChar ** string, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal)

Extract error information from the regexp execution, the parameter @string will be updated with the value pushed and not accepted, the parameter @values must point to an array of @nbval string pointers on return nbval will contain the number of possible strings in that state and the @values array will be updated with them. The string values

xmlRegExecNextValues ()

int	xmlRegExecNextValues		(xmlRegExecCtxtPtr exec, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal)

Extract information from the regexp execution, the parameter @values must point to an array of @nbval string pointers on return nbval will contain the number of possible strings in that state and the @values array will be updated with them. The string values

xmlRegExecPushString ()

int	xmlRegExecPushString		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 void * data)

Push one input token in the execution context

xmlRegExecPushString2 ()

int	xmlRegExecPushString2		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 const xmlChar * value2, 
					 void * data)

Push one input token in the execution context

xmlRegFreeExecCtxt ()

void	xmlRegFreeExecCtxt		(xmlRegExecCtxtPtr exec)

Free the structures associated to a regular expression evaluation context.

xmlRegFreeRegexp ()

void	xmlRegFreeRegexp		(xmlRegexpPtr regexp)

Free a regexp

xmlRegNewExecCtxt ()

xmlRegExecCtxtPtr	xmlRegNewExecCtxt	(xmlRegexpPtr comp, 
						 xmlRegExecCallbacks callback, 
						 void * data)

Build a context used for progressive evaluation of a regexp.

xmlRegexpCompile ()

xmlRegexpPtr	xmlRegexpCompile	(const xmlChar * regexp)

Parses a regular expression conforming to XML Schemas Part 2 Datatype Appendix F and builds an automata suitable for testing strings against that regular expression

xmlRegexpExec ()

int	xmlRegexpExec			(xmlRegexpPtr comp, 
					 const xmlChar * content)

Check if the regular expression generates the value

xmlRegexpIsDeterminist ()

int	xmlRegexpIsDeterminist		(xmlRegexpPtr comp)

Check if the regular expression is determinist

xmlRegexpPrint ()

void	xmlRegexpPrint			(FILE * output, 
					 xmlRegexpPtr regexp)

Print the content of the compiled regular expression