xmlregexp

xmlregexp - regular expressions handling

basic API for libxml regular expressions handling used for XML Schemas and validation.

Author(s): Daniel Veillard

Synopsis

typedef xmlRegExecCtxt * xmlRegExecCtxtPtr;
typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpNode * xmlExpNodePtr;
typedef xmlExpCtxt * xmlExpCtxtPtr;
typedef enum xmlExpNodeType;
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef struct _xmlExpNode xmlExpNode;
typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp * xmlRegexpPtr;
typedef void xmlRegExecCallbacks		(xmlRegExecCtxtPtr exec, 
const xmlChar * token,
void * transdata,
void * inputdata); xmlRegExecCtxtPtr xmlRegNewExecCtxt (xmlRegexpPtr comp,
xmlRegExecCallbacks callback,
void * data); xmlExpNodePtr xmlExpNewOr (xmlExpCtxtPtr ctxt,
xmlExpNodePtr left,
xmlExpNodePtr right); void xmlRegFreeRegexp (xmlRegexpPtr regexp); void xmlExpRef (xmlExpNodePtr exp); int xmlRegexpIsDeterminist (xmlRegexpPtr comp); int xmlRegExecErrInfo (xmlRegExecCtxtPtr exec,
const xmlChar ** string,
int * nbval,
int * nbneg,
xmlChar ** values,
int * terminal); void xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec); int xmlExpCtxtNbCons (xmlExpCtxtPtr ctxt); int xmlExpSubsume (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp,
xmlExpNodePtr sub); int xmlRegExecPushString2 (xmlRegExecCtxtPtr exec,
const xmlChar * value,
const xmlChar * value2,
void * data); int xmlRegExecNextValues (xmlRegExecCtxtPtr exec,
int * nbval,
int * nbneg,
xmlChar ** values,
int * terminal); xmlExpNodePtr xmlExpExpDerive (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp,
xmlExpNodePtr sub); int xmlExpIsNillable (xmlExpNodePtr exp); void xmlExpFreeCtxt (xmlExpCtxtPtr ctxt); void xmlExpDump (xmlBufferPtr buf,
xmlExpNodePtr expr); xmlExpNodePtr xmlExpNewSeq (xmlExpCtxtPtr ctxt,
xmlExpNodePtr left,
xmlExpNodePtr right); void xmlExpFree (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp); xmlExpNodePtr xmlExpNewRange (xmlExpCtxtPtr ctxt,
xmlExpNodePtr subset,
int min,
int max); xmlRegexpPtr xmlRegexpCompile (const xmlChar * regexp); xmlExpNodePtr xmlExpNewAtom (xmlExpCtxtPtr ctxt,
const xmlChar * name,
int len); int xmlRegexpExec (xmlRegexpPtr comp,
const xmlChar * content); int xmlRegExecPushString (xmlRegExecCtxtPtr exec,
const xmlChar * value,
void * data); int xmlExpGetStart (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp,
const xmlChar ** tokList,
int len); xmlExpNodePtr xmlExpParse (xmlExpCtxtPtr ctxt,
const char * expr); xmlExpCtxtPtr xmlExpNewCtxt (int maxNodes,
xmlDictPtr dict); int xmlExpGetLanguage (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp,
const xmlChar ** langList,
int len); xmlExpNodePtr xmlExpStringDerive (xmlExpCtxtPtr ctxt,
xmlExpNodePtr exp,
const xmlChar * str,
int len); int xmlExpCtxtNbNodes (xmlExpCtxtPtr ctxt); int xmlExpMaxToken (xmlExpNodePtr expr); void xmlRegexpPrint (FILE * output,
xmlRegexpPtr regexp);

Description

Details

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;



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

exec:the regular expression context
token:the current token string
transdata:transition data
inputdata:input data

Variable emptyExp

xmlExpNodePtr emptyExp;


Variable forbiddenExp

xmlExpNodePtr forbiddenExp;


xmlExpCtxtNbCons ()

int	xmlExpCtxtNbCons		(xmlExpCtxtPtr ctxt)

Debugging facility provides the number of allocated nodes over lifetime

ctxt:an expression context
Returns:the number of nodes ever allocated or -1 in case of error

xmlExpCtxtNbNodes ()

int	xmlExpCtxtNbNodes		(xmlExpCtxtPtr ctxt)

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

ctxt:an expression context
Returns:the number of nodes in use or -1 in case of error

xmlExpDump ()

void	xmlExpDump			(xmlBufferPtr buf, 
xmlExpNodePtr expr)

Serialize the expression as compiled to the buffer

buf:a buffer to receive the output
expr:the compiled expression

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.

ctxt:the expressions context
exp:the englobing expression
sub:the subexpression
Returns:the resulting expression or NULL in case of internal error, the result must be freed

xmlExpFree ()

void	xmlExpFree			(xmlExpCtxtPtr ctxt, 
xmlExpNodePtr exp)

Dereference the expression

ctxt:the expression context
exp:the expression

xmlExpFreeCtxt ()

void	xmlExpFreeCtxt			(xmlExpCtxtPtr ctxt)

Free an expression context

ctxt: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

ctxt:the expression context
exp:the expression
langList:where to store the tokens
len:the allocated length of @list
Returns:the number of unique strings found, -1 in case of errors and -2 if there is more than @len strings

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]

ctxt:the expression context
exp:the expression
tokList:where to store the tokens
len:the allocated length of @list
Returns:the number of unique strings found, -1 in case of errors and -2 if there is more than @len strings

xmlExpIsNillable ()

int	xmlExpIsNillable		(xmlExpNodePtr exp)

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

exp:the expression
Returns:1 if nillable, 0 if not and -1 in case of error

xmlExpMaxToken ()

int	xmlExpMaxToken			(xmlExpNodePtr expr)

Indicate the maximum number of input a expression can accept

expr:a compiled expression
Returns:the maximum length or -1 in case of error

xmlExpNewAtom ()

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

Get the atom associated to this name from that context

ctxt:the expression context
name:the atom name
len:the atom name length in byte (or -1);
Returns:the node or NULL in case of error

xmlExpNewCtxt ()

xmlExpCtxtPtr	xmlExpNewCtxt		(int maxNodes, 
xmlDictPtr dict)

Creates a new context for manipulating expressions

maxNodes:the maximum number of nodes
dict:optional dictionary to use internally
Returns:the context or NULL in case of error

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).

ctxt:the expression context
left:left expression
right:right expression
Returns:the node or NULL in case of error

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).

ctxt:the expression context
subset:the expression to be repeated
min:the lower bound for the repetition
max:the upper bound for the repetition, -1 means infinite
Returns:the node or NULL in case of error

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).

ctxt:the expression context
left:left expression
right:right expression
Returns:the node or NULL in case of error

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

ctxt:the expressions context
expr:the 0 terminated string
Returns:a new expression or NULL in case of failure

xmlExpRef ()

void	xmlExpRef			(xmlExpNodePtr exp)

Increase the reference count of the expression

exp: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

ctxt:the expression context
exp:the expression
str:the string
len:the string len in bytes if available
Returns:the resulting expression or NULL in case of internal error

xmlExpSubsume ()

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

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

ctxt:the expressions context
exp:the englobing expression
sub:the subexpression
Returns:1 if true 0 if false and -1 in case of failure.

xmlRegExecErrInfo ()

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

Extract error informations 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

exec:a regexp execution context generating an error
string:return value for the error string
nbval:pointer to the number of accepted values IN/OUT
nbneg:return number of negative transitions
values:pointer to the array of acceptable values
terminal:return value if this was a terminal state
Returns:will be freed with the @exec context and don't need to be deallocated. Returns: 0 in case of success or -1 in case of error.

xmlRegExecNextValues ()

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

Extract informations 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

exec:a regexp execution context
nbval:pointer to the number of accepted values IN/OUT
nbneg:return number of negative transitions
values:pointer to the array of acceptable values
terminal:return value if this was a terminal state
Returns:will be freed with the @exec context and don't need to be deallocated. Returns: 0 in case of success or -1 in case of error.

xmlRegExecPushString ()

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

Push one input token in the execution context

exec:a regexp execution context or NULL to indicate the end
value:a string token input
data:data associated to the token to reuse in callbacks
Returns:1 if the regexp reached a final state, 0 if non-final, and a negative value in case of error.

xmlRegExecPushString2 ()

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

Push one input token in the execution context

exec:a regexp execution context or NULL to indicate the end
value:the first string token input
value2:the second string token input
data:data associated to the token to reuse in callbacks
Returns:1 if the regexp reached a final state, 0 if non-final, and a negative value in case of error.

xmlRegFreeExecCtxt ()

void	xmlRegFreeExecCtxt		(xmlRegExecCtxtPtr exec)

Free the structures associated to a regular expression evaluation context.

exec:a regular expression evaluation context

xmlRegFreeRegexp ()

void	xmlRegFreeRegexp		(xmlRegexpPtr regexp)

Free a regexp

regexp:the regexp

xmlRegNewExecCtxt ()

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

Build a context used for progressive evaluation of a regexp.

comp:a precompiled regular expression
callback:a callback function used for handling progresses in the automata matching phase
data:the context data associated to the callback in this context
Returns:the new context

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

regexp:a regular expression string
Returns:the compiled expression or NULL in case of error

xmlRegexpExec ()

int	xmlRegexpExec			(xmlRegexpPtr comp, 
const xmlChar * content)

Check if the regular expression generates the value

comp:the compiled regular expression
content:the value to check against the regular expression
Returns:1 if it matches, 0 if not and a negative value in case of error

xmlRegexpIsDeterminist ()

int	xmlRegexpIsDeterminist		(xmlRegexpPtr comp)

Check if the regular expression is determinist

comp:the compiled regular expression
Returns:1 if it yes, 0 if not and a negative value in case of error

xmlRegexpPrint ()

void	xmlRegexpPrint			(FILE * output, 
xmlRegexpPtr regexp)

Print the content of the compiled regular expression

output:the file for the output debug
regexp:the compiled regexp