  
    
    
    
    
    
    
    
  
  
    
      
        
          
libxml2-xmlreader.html            
Prev          
        
        
          
general.html            
Up          
        
        
          
index.html            
Home          
        
        
          
libxml2-xmlsave.html            
Next          
        
        
libxml2 Reference Manual      
    
    
      
xmlregexp    
    
xmlregexp - regular expressions handling
    
basic API for libxml regular expressions handling used for XML Schemas and validation. 
    
Author(s): Daniel Veillard 
    
      
Synopsis
      
typedef libxml2-xmlregexp.html#xmlRegExecCtxtxmlRegExecCtxt  * #xmlRegExecCtxtPtrxmlRegExecCtxtPtr ;
typedef struct _xmlExpCtxt 
#xmlExpCtxtxmlExpCtxt ;
typedef 
libxml2-xmlregexp.html#xmlExpNodexmlExpNode  * #xmlExpNodePtrxmlExpNodePtr ;
typedef 
libxml2-xmlregexp.html#xmlExpCtxtxmlExpCtxt  * #xmlExpCtxtPtrxmlExpCtxtPtr ;
typedef enum 
#xmlExpNodeTypexmlExpNodeType ;
typedef struct _xmlRegExecCtxt 
#xmlRegExecCtxtxmlRegExecCtxt ;
typedef struct _xmlExpNode 
#xmlExpNodexmlExpNode ;
typedef struct _xmlRegexp 
#xmlRegexpxmlRegexp ;
typedef 
libxml2-xmlregexp.html#xmlRegexpxmlRegexp  * #xmlRegexpPtrxmlRegexpPtr ;
typedef void 
#xmlRegExecCallbacksxmlRegExecCallbacks 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * token, 					 void * transdata, 					 void * inputdata);
libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr 	#xmlRegNewExecCtxtxmlRegNewExecCtxt 	( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  comp, 						 libxml2-xmlregexp.html#xmlRegExecCallbacksxmlRegExecCallbacks  callback, 						 void * data);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpNewOrxmlExpNewOr 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  left, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  right);
void	
#xmlRegFreeRegexpxmlRegFreeRegexp 		( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  regexp);
void	
#xmlExpRefxmlExpRef 			( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp);
int	
#xmlRegexpIsDeterministxmlRegexpIsDeterminist 		( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  comp);
int	
#xmlRegExecErrInfoxmlRegExecErrInfo 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** string, 					 int * nbval, 					 int * nbneg, 					 libxml2-xmlstring.html#xmlCharxmlChar  ** values, 					 int * terminal);
void	
#xmlRegFreeExecCtxtxmlRegFreeExecCtxt 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec);
int	
#xmlExpCtxtNbConsxmlExpCtxtNbCons 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt);
int	
#xmlExpSubsumexmlExpSubsume 			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  sub);
int	
#xmlRegExecPushString2xmlRegExecPushString2 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * value, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * value2, 					 void * data);
int	
#xmlRegExecNextValuesxmlRegExecNextValues 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 int * nbval, 					 int * nbneg, 					 libxml2-xmlstring.html#xmlCharxmlChar  ** values, 					 int * terminal);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpExpDerivexmlExpExpDerive 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  sub);
int	
#xmlExpIsNillablexmlExpIsNillable 		( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp);
void	
#xmlExpFreeCtxtxmlExpFreeCtxt 			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt);
void	
#xmlExpDumpxmlExpDump 			( libxml2-tree.html#xmlBufferPtrxmlBufferPtr  buf, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  expr);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpNewSeqxmlExpNewSeq 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  left, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  right);
void	
#xmlExpFreexmlExpFree 			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpNewRangexmlExpNewRange 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  subset, 					 int min, 					 int max);
libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr 	#xmlRegexpCompilexmlRegexpCompile 	(const libxml2-xmlstring.html#xmlCharxmlChar  * regexp);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpNewAtomxmlExpNewAtom 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * name, 					 int len);
int	
#xmlRegexpExecxmlRegexpExec 			( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  comp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * content);
int	
#xmlRegExecPushStringxmlRegExecPushString 		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * value, 					 void * data);
int	
#xmlExpGetStartxmlExpGetStart 			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** tokList, 					 int len);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpParsexmlExpParse 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 const char * expr);
libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr 	#xmlExpNewCtxtxmlExpNewCtxt 		(int maxNodes, 					 libxml2-dict.html#xmlDictPtrxmlDictPtr  dict);
int	
#xmlExpGetLanguagexmlExpGetLanguage 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** langList, 					 int len);
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	#xmlExpStringDerivexmlExpStringDerive 	( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * str, 					 int len);
int	
#xmlExpCtxtNbNodesxmlExpCtxtNbNodes 		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt);
int	
#xmlExpMaxTokenxmlExpMaxToken 			( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  expr);
void	
#xmlRegexpPrintxmlRegexpPrint 			(FILE * output, 					 libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  regexp);
    
    
      
Description
    
    
      
Details
      
        
Structure xmlExpCtxt
struct _xmlExpCtxt {
The content of this structure is not made public by the API.
} xmlExpCtxt;
        
        
Typedef xmlExpCtxtPtr
libxml2-xmlregexp.html#xmlExpCtxtxmlExpCtxt  * xmlExpCtxtPtr;
        
        
Structure xmlExpNode
struct _xmlExpNode {
The content of this structure is not made public by the API.
} xmlExpNode;
        
        
Typedef xmlExpNodePtr
libxml2-xmlregexp.html#xmlExpNodexmlExpNode  * xmlExpNodePtr;
        
        
Enum xmlExpNodeType
enum #xmlExpNodeTypexmlExpNodeType  {
    
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
libxml2-xmlregexp.html#xmlRegExecCtxtxmlRegExecCtxt  * 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
libxml2-xmlregexp.html#xmlRegexpxmlRegexp  * xmlRegexpPtr;
A libxml regular expression, they can actually be far more complex thank the POSIX regex expressions.
        
        
Function type xmlRegExecCallbacks
void	xmlRegExecCallbacks		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * token, 					 void * transdata, 					 void * inputdata) exec: token: transdata: inputdata:         
        
Variable emptyExp
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  emptyExp;
        
        
Variable forbiddenExp
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  forbiddenExp;
        
        
xmlExpCtxtNbCons ()
int	xmlExpCtxtNbCons		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  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		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  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			( libxml2-tree.html#xmlBufferPtrxmlBufferPtr  buf, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  expr)Serialize the expression as compiled to the buffer
buf: a buffer to receive the output expr: the compiled expression         
        
xmlExpExpDerive ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpExpDerive		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  sub)Evaluates the expression resulting from @exp consuming a sub expression @sub Based on algebraic derivation and sometimes direct Brzozowski derivation it usually tatkes 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			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp)Dereference the expression
ctxt: the expression context exp: the expression         
        
xmlExpFreeCtxt ()
void	xmlExpFreeCtxt			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt)Free an expression context
ctxt: an expression context         
        
xmlExpGetLanguage ()
int	xmlExpGetLanguage		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** 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 lenght 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			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** 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 lenght 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		( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp)Finds if the expression is nillable, i.e. if it accepts the empty sequqnce
exp: the expression Returns: 1 if nillable, 0 if not and -1 in case of error         
        
xmlExpMaxToken ()
int	xmlExpMaxToken			( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  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 ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpNewAtom		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * 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 lenght in byte (or -1); Returns: the node or NULL in case of error         
        
xmlExpNewCtxt ()
libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr 	xmlExpNewCtxt		(int maxNodes, 					 libxml2-dict.html#xmlDictPtrxmlDictPtr  dict)Creates a new context for manipulating expressions
maxNodes: the maximum number of nodes dict: optional dictionnary to use internally Returns: the context or NULL in case of error         
        
xmlExpNewOr ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpNewOr		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  left, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  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 ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpNewRange		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  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 ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpNewSeq		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  left, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  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 ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpParse		( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  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			( libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp)Increase the libxml2-SAX.html#referencereference  count of the expression
exp: the expression         
        
xmlExpStringDerive ()
libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr 	xmlExpStringDerive	( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * 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			( libxml2-xmlregexp.html#xmlExpCtxtPtrxmlExpCtxtPtr  ctxt, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  exp, 					 libxml2-xmlregexp.html#xmlExpNodePtrxmlExpNodePtr  sub)Check whether @exp accepts all the languages accexpted 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		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  ** string, 					 int * nbval, 					 int * nbneg, 					 libxml2-xmlstring.html#xmlCharxmlChar  ** 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		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 int * nbval, 					 int * nbneg, 					 libxml2-xmlstring.html#xmlCharxmlChar  ** 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		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * 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		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * value, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * 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		( libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr  exec)Free the structures associated to a regular expression evaulation context.
exec: a regular expression evaulation context         
        
xmlRegFreeRegexp ()
void	xmlRegFreeRegexp		( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  regexp)Free a regexp
regexp: the regexp         
        
xmlRegNewExecCtxt ()
libxml2-xmlregexp.html#xmlRegExecCtxtPtrxmlRegExecCtxtPtr 	xmlRegNewExecCtxt	( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  comp, 						 libxml2-xmlregexp.html#xmlRegExecCallbacksxmlRegExecCallbacks  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 ()
libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr 	xmlRegexpCompile	(const libxml2-xmlstring.html#xmlCharxmlChar  * 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			( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  comp, 					 const libxml2-xmlstring.html#xmlCharxmlChar  * 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		( libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  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, 					 libxml2-xmlregexp.html#xmlRegexpPtrxmlRegexpPtr  regexp)Print the content of the compiled regular expression
output: the file for the output debug regexp: the compiled regexp         
      
    
  
