Annotation of embedaddon/libxml2/include/libxml/xmlregexp.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Summary: regular expressions handling
                      3:  * Description: basic API for libxml regular expressions handling used
                      4:  *              for XML Schemas and validation.
                      5:  *
                      6:  * Copy: See Copyright for the status of this software.
                      7:  *
                      8:  * Author: Daniel Veillard
                      9:  */
                     10: 
                     11: #ifndef __XML_REGEXP_H__
                     12: #define __XML_REGEXP_H__
                     13: 
                     14: #include <libxml/xmlversion.h>
                     15: 
                     16: #ifdef LIBXML_REGEXP_ENABLED
                     17: 
                     18: #ifdef __cplusplus
                     19: extern "C" {
                     20: #endif
                     21: 
                     22: /**
                     23:  * xmlRegexpPtr:
                     24:  *
                     25:  * A libxml regular expression, they can actually be far more complex
                     26:  * thank the POSIX regex expressions.
                     27:  */
                     28: typedef struct _xmlRegexp xmlRegexp;
                     29: typedef xmlRegexp *xmlRegexpPtr;
                     30: 
                     31: /**
                     32:  * xmlRegExecCtxtPtr:
                     33:  *
                     34:  * A libxml progressive regular expression evaluation context
                     35:  */
                     36: typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
                     37: typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
                     38: 
                     39: #ifdef __cplusplus
                     40: }
                     41: #endif
                     42: #include <libxml/tree.h>
                     43: #include <libxml/dict.h>
                     44: #ifdef __cplusplus
                     45: extern "C" {
                     46: #endif
                     47: 
                     48: /*
                     49:  * The POSIX like API
                     50:  */
                     51: XMLPUBFUN xmlRegexpPtr XMLCALL
                     52:                    xmlRegexpCompile    (const xmlChar *regexp);
                     53: XMLPUBFUN void XMLCALL                  xmlRegFreeRegexp(xmlRegexpPtr regexp);
                     54: XMLPUBFUN int XMLCALL
                     55:                    xmlRegexpExec       (xmlRegexpPtr comp,
                     56:                                         const xmlChar *value);
                     57: XMLPUBFUN void XMLCALL
                     58:                    xmlRegexpPrint      (FILE *output,
                     59:                                         xmlRegexpPtr regexp);
                     60: XMLPUBFUN int XMLCALL
                     61:                    xmlRegexpIsDeterminist(xmlRegexpPtr comp);
                     62: 
                     63: /**
                     64:  * xmlRegExecCallbacks:
                     65:  * @exec: the regular expression context
                     66:  * @token: the current token string
                     67:  * @transdata: transition data
                     68:  * @inputdata: input data
                     69:  *
                     70:  * Callback function when doing a transition in the automata
                     71:  */
                     72: typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
                     73:                                     const xmlChar *token,
                     74:                                     void *transdata,
                     75:                                     void *inputdata);
                     76: 
                     77: /*
                     78:  * The progressive API
                     79:  */
                     80: XMLPUBFUN xmlRegExecCtxtPtr XMLCALL
                     81:                    xmlRegNewExecCtxt   (xmlRegexpPtr comp,
                     82:                                         xmlRegExecCallbacks callback,
                     83:                                         void *data);
                     84: XMLPUBFUN void XMLCALL
                     85:                    xmlRegFreeExecCtxt  (xmlRegExecCtxtPtr exec);
                     86: XMLPUBFUN int XMLCALL
                     87:                    xmlRegExecPushString(xmlRegExecCtxtPtr exec,
                     88:                                         const xmlChar *value,
                     89:                                         void *data);
                     90: XMLPUBFUN int XMLCALL
                     91:                    xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
                     92:                                         const xmlChar *value,
                     93:                                         const xmlChar *value2,
                     94:                                         void *data);
                     95: 
                     96: XMLPUBFUN int XMLCALL
                     97:                    xmlRegExecNextValues(xmlRegExecCtxtPtr exec,
                     98:                                         int *nbval,
                     99:                                         int *nbneg,
                    100:                                         xmlChar **values,
                    101:                                         int *terminal);
                    102: XMLPUBFUN int XMLCALL
                    103:                    xmlRegExecErrInfo   (xmlRegExecCtxtPtr exec,
                    104:                                         const xmlChar **string,
                    105:                                         int *nbval,
                    106:                                         int *nbneg,
                    107:                                         xmlChar **values,
                    108:                                         int *terminal);
                    109: #ifdef LIBXML_EXPR_ENABLED
                    110: /*
                    111:  * Formal regular expression handling
                    112:  * Its goal is to do some formal work on content models
                    113:  */
                    114: 
                    115: /* expressions are used within a context */
                    116: typedef struct _xmlExpCtxt xmlExpCtxt;
                    117: typedef xmlExpCtxt *xmlExpCtxtPtr;
                    118: 
                    119: XMLPUBFUN void XMLCALL
                    120:                        xmlExpFreeCtxt  (xmlExpCtxtPtr ctxt);
                    121: XMLPUBFUN xmlExpCtxtPtr XMLCALL
                    122:                        xmlExpNewCtxt   (int maxNodes,
                    123:                                         xmlDictPtr dict);
                    124: 
                    125: XMLPUBFUN int XMLCALL
                    126:                        xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt);
                    127: XMLPUBFUN int XMLCALL
                    128:                        xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt);
                    129: 
                    130: /* Expressions are trees but the tree is opaque */
                    131: typedef struct _xmlExpNode xmlExpNode;
                    132: typedef xmlExpNode *xmlExpNodePtr;
                    133: 
                    134: typedef enum {
                    135:     XML_EXP_EMPTY = 0,
                    136:     XML_EXP_FORBID = 1,
                    137:     XML_EXP_ATOM = 2,
                    138:     XML_EXP_SEQ = 3,
                    139:     XML_EXP_OR = 4,
                    140:     XML_EXP_COUNT = 5
                    141: } xmlExpNodeType;
                    142: 
                    143: /*
                    144:  * 2 core expressions shared by all for the empty language set
                    145:  * and for the set with just the empty token
                    146:  */
                    147: XMLPUBVAR xmlExpNodePtr forbiddenExp;
                    148: XMLPUBVAR xmlExpNodePtr emptyExp;
                    149: 
                    150: /*
                    151:  * Expressions are reference counted internally
                    152:  */
                    153: XMLPUBFUN void XMLCALL
                    154:                        xmlExpFree      (xmlExpCtxtPtr ctxt,
                    155:                                         xmlExpNodePtr expr);
                    156: XMLPUBFUN void XMLCALL
                    157:                        xmlExpRef       (xmlExpNodePtr expr);
                    158: 
                    159: /*
                    160:  * constructors can be either manual or from a string
                    161:  */
                    162: XMLPUBFUN xmlExpNodePtr XMLCALL
                    163:                        xmlExpParse     (xmlExpCtxtPtr ctxt,
                    164:                                         const char *expr);
                    165: XMLPUBFUN xmlExpNodePtr XMLCALL
                    166:                        xmlExpNewAtom   (xmlExpCtxtPtr ctxt,
                    167:                                         const xmlChar *name,
                    168:                                         int len);
                    169: XMLPUBFUN xmlExpNodePtr XMLCALL
                    170:                        xmlExpNewOr     (xmlExpCtxtPtr ctxt,
                    171:                                         xmlExpNodePtr left,
                    172:                                         xmlExpNodePtr right);
                    173: XMLPUBFUN xmlExpNodePtr XMLCALL
                    174:                        xmlExpNewSeq    (xmlExpCtxtPtr ctxt,
                    175:                                         xmlExpNodePtr left,
                    176:                                         xmlExpNodePtr right);
                    177: XMLPUBFUN xmlExpNodePtr XMLCALL
                    178:                        xmlExpNewRange  (xmlExpCtxtPtr ctxt,
                    179:                                         xmlExpNodePtr subset,
                    180:                                         int min,
                    181:                                         int max);
                    182: /*
                    183:  * The really interesting APIs
                    184:  */
                    185: XMLPUBFUN int XMLCALL
                    186:                        xmlExpIsNillable(xmlExpNodePtr expr);
                    187: XMLPUBFUN int XMLCALL
                    188:                        xmlExpMaxToken  (xmlExpNodePtr expr);
                    189: XMLPUBFUN int XMLCALL
                    190:                        xmlExpGetLanguage(xmlExpCtxtPtr ctxt,
                    191:                                         xmlExpNodePtr expr,
                    192:                                         const xmlChar**langList,
                    193:                                         int len);
                    194: XMLPUBFUN int XMLCALL
                    195:                        xmlExpGetStart  (xmlExpCtxtPtr ctxt,
                    196:                                         xmlExpNodePtr expr,
                    197:                                         const xmlChar**tokList,
                    198:                                         int len);
                    199: XMLPUBFUN xmlExpNodePtr XMLCALL
                    200:                        xmlExpStringDerive(xmlExpCtxtPtr ctxt,
                    201:                                         xmlExpNodePtr expr,
                    202:                                         const xmlChar *str,
                    203:                                         int len);
                    204: XMLPUBFUN xmlExpNodePtr XMLCALL
                    205:                        xmlExpExpDerive (xmlExpCtxtPtr ctxt,
                    206:                                         xmlExpNodePtr expr,
                    207:                                         xmlExpNodePtr sub);
                    208: XMLPUBFUN int XMLCALL
                    209:                        xmlExpSubsume   (xmlExpCtxtPtr ctxt,
                    210:                                         xmlExpNodePtr expr,
                    211:                                         xmlExpNodePtr sub);
                    212: XMLPUBFUN void XMLCALL
                    213:                        xmlExpDump      (xmlBufferPtr buf,
                    214:                                         xmlExpNodePtr expr);
                    215: #endif /* LIBXML_EXPR_ENABLED */
                    216: #ifdef __cplusplus
                    217: }
                    218: #endif
                    219: 
                    220: #endif /* LIBXML_REGEXP_ENABLED */
                    221: 
                    222: #endif /*__XML_REGEXP_H__ */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>