mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2025-10-21 14:53:44 +03:00
include: Stop using *Ptr typedefs in public headers
This commit is contained in:
Nick Wellnhofer
250
xmlregexp.c
250
xmlregexp.c
@@ -3542,8 +3542,8 @@ error:
|
||||
* @param data the context data associated to the callback in this context
|
||||
* @returns the new context
|
||||
*/
|
||||
xmlRegExecCtxtPtr
|
||||
xmlRegNewExecCtxt(xmlRegexpPtr comp, xmlRegExecCallbacks callback, void *data) {
|
||||
xmlRegExecCtxt *
|
||||
xmlRegNewExecCtxt(xmlRegexp *comp, xmlRegExecCallbacks callback, void *data) {
|
||||
xmlRegExecCtxtPtr exec;
|
||||
|
||||
if (comp == NULL)
|
||||
@@ -3600,7 +3600,7 @@ xmlRegNewExecCtxt(xmlRegexpPtr comp, xmlRegExecCallbacks callback, void *data) {
|
||||
* @param exec a regular expression evaluation context
|
||||
*/
|
||||
void
|
||||
xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec) {
|
||||
xmlRegFreeExecCtxt(xmlRegExecCtxt *exec) {
|
||||
if (exec == NULL)
|
||||
return;
|
||||
|
||||
@@ -4120,7 +4120,7 @@ progress:
|
||||
* a negative value in case of error.
|
||||
*/
|
||||
int
|
||||
xmlRegExecPushString(xmlRegExecCtxtPtr exec, const xmlChar *value,
|
||||
xmlRegExecPushString(xmlRegExecCtxt *exec, const xmlChar *value,
|
||||
void *data) {
|
||||
return(xmlRegExecPushStringInternal(exec, value, data, 0));
|
||||
}
|
||||
@@ -4136,7 +4136,7 @@ xmlRegExecPushString(xmlRegExecCtxtPtr exec, const xmlChar *value,
|
||||
* a negative value in case of error.
|
||||
*/
|
||||
int
|
||||
xmlRegExecPushString2(xmlRegExecCtxtPtr exec, const xmlChar *value,
|
||||
xmlRegExecPushString2(xmlRegExecCtxt *exec, const xmlChar *value,
|
||||
const xmlChar *value2, void *data) {
|
||||
xmlChar buf[150];
|
||||
int lenn, lenp, ret;
|
||||
@@ -4351,7 +4351,7 @@ xmlRegExecGetValues(xmlRegExecCtxtPtr exec, int err,
|
||||
* @returns 0 in case of success or -1 in case of error.
|
||||
*/
|
||||
int
|
||||
xmlRegExecNextValues(xmlRegExecCtxtPtr exec, int *nbval, int *nbneg,
|
||||
xmlRegExecNextValues(xmlRegExecCtxt *exec, int *nbval, int *nbneg,
|
||||
xmlChar **values, int *terminal) {
|
||||
return(xmlRegExecGetValues(exec, 0, nbval, nbneg, values, terminal));
|
||||
}
|
||||
@@ -4374,7 +4374,7 @@ xmlRegExecNextValues(xmlRegExecCtxtPtr exec, int *nbval, int *nbneg,
|
||||
* @returns 0 in case of success or -1 in case of error.
|
||||
*/
|
||||
int
|
||||
xmlRegExecErrInfo(xmlRegExecCtxtPtr exec, const xmlChar **string,
|
||||
xmlRegExecErrInfo(xmlRegExecCtxt *exec, const xmlChar **string,
|
||||
int *nbval, int *nbneg, xmlChar **values, int *terminal) {
|
||||
if (exec == NULL)
|
||||
return(-1);
|
||||
@@ -5330,7 +5330,7 @@ xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
|
||||
*/
|
||||
void
|
||||
xmlRegexpPrint(FILE *output ATTRIBUTE_UNUSED,
|
||||
xmlRegexpPtr regexp ATTRIBUTE_UNUSED) {
|
||||
xmlRegexp *regexp ATTRIBUTE_UNUSED) {
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -5341,7 +5341,7 @@ xmlRegexpPrint(FILE *output ATTRIBUTE_UNUSED,
|
||||
* @param regexp a regular expression string
|
||||
* @returns the compiled expression or NULL in case of error
|
||||
*/
|
||||
xmlRegexpPtr
|
||||
xmlRegexp *
|
||||
xmlRegexpCompile(const xmlChar *regexp) {
|
||||
xmlRegexpPtr ret = NULL;
|
||||
xmlRegParserCtxtPtr ctxt;
|
||||
@@ -5392,7 +5392,7 @@ error:
|
||||
* @returns 1 if it matches, 0 if not and a negative value in case of error
|
||||
*/
|
||||
int
|
||||
xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) {
|
||||
xmlRegexpExec(xmlRegexp *comp, const xmlChar *content) {
|
||||
if ((comp == NULL) || (content == NULL))
|
||||
return(-1);
|
||||
return(xmlFARegExec(comp, content));
|
||||
@@ -5405,7 +5405,7 @@ xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) {
|
||||
* @returns 1 if it yes, 0 if not and a negative value in case of error
|
||||
*/
|
||||
int
|
||||
xmlRegexpIsDeterminist(xmlRegexpPtr comp) {
|
||||
xmlRegexpIsDeterminist(xmlRegexp *comp) {
|
||||
xmlAutomataPtr am;
|
||||
int ret;
|
||||
|
||||
@@ -5444,7 +5444,7 @@ xmlRegexpIsDeterminist(xmlRegexpPtr comp) {
|
||||
* @param regexp the regexp
|
||||
*/
|
||||
void
|
||||
xmlRegFreeRegexp(xmlRegexpPtr regexp) {
|
||||
xmlRegFreeRegexp(xmlRegexp *regexp) {
|
||||
int i;
|
||||
if (regexp == NULL)
|
||||
return;
|
||||
@@ -5487,7 +5487,7 @@ xmlRegFreeRegexp(xmlRegexpPtr regexp) {
|
||||
*
|
||||
* @returns the new object or NULL in case of failure
|
||||
*/
|
||||
xmlAutomataPtr
|
||||
xmlAutomata *
|
||||
xmlNewAutomata(void) {
|
||||
xmlAutomataPtr ctxt;
|
||||
|
||||
@@ -5516,7 +5516,7 @@ xmlNewAutomata(void) {
|
||||
* @param am an automata
|
||||
*/
|
||||
void
|
||||
xmlFreeAutomata(xmlAutomataPtr am) {
|
||||
xmlFreeAutomata(xmlAutomata *am) {
|
||||
if (am == NULL)
|
||||
return;
|
||||
xmlRegFreeParserCtxt(am);
|
||||
@@ -5529,7 +5529,7 @@ xmlFreeAutomata(xmlAutomataPtr am) {
|
||||
* @param flags a set of internal flags
|
||||
*/
|
||||
void
|
||||
xmlAutomataSetFlags(xmlAutomataPtr am, int flags) {
|
||||
xmlAutomataSetFlags(xmlAutomata *am, int flags) {
|
||||
if (am == NULL)
|
||||
return;
|
||||
am->flags |= flags;
|
||||
@@ -5541,8 +5541,8 @@ xmlAutomataSetFlags(xmlAutomataPtr am, int flags) {
|
||||
* @param am an automata
|
||||
* @returns the initial state of the automata
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataGetInitState(xmlAutomataPtr am) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataGetInitState(xmlAutomata *am) {
|
||||
if (am == NULL)
|
||||
return(NULL);
|
||||
return(am->start);
|
||||
@@ -5556,7 +5556,7 @@ xmlAutomataGetInitState(xmlAutomataPtr am) {
|
||||
* @returns 0 or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlAutomataSetFinalState(xmlAutomataPtr am, xmlAutomataStatePtr state) {
|
||||
xmlAutomataSetFinalState(xmlAutomata *am, xmlAutomataState *state) {
|
||||
if ((am == NULL) || (state == NULL))
|
||||
return(-1);
|
||||
state->type = XML_REGEXP_FINAL_STATE;
|
||||
@@ -5575,9 +5575,9 @@ xmlAutomataSetFinalState(xmlAutomataPtr am, xmlAutomataStatePtr state) {
|
||||
* @param data data passed to the callback function if the transition is activated
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewTransition(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewTransition(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
|
||||
@@ -5616,9 +5616,9 @@ xmlAutomataNewTransition(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param data data passed to the callback function if the transition is activated
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewTransition2(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewTransition2(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
const xmlChar *token2, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
|
||||
@@ -5674,9 +5674,9 @@ xmlAutomataNewTransition2(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param data data passed to the callback function if the transition is activated
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewNegTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewNegTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
const xmlChar *token2, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
xmlChar err_msg[200];
|
||||
@@ -5739,9 +5739,9 @@ xmlAutomataNewNegTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param data data associated to the transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewCountTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewCountTrans2(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
const xmlChar *token2,
|
||||
int min, int max, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
@@ -5832,9 +5832,9 @@ error:
|
||||
* @param data data associated to the transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewCountTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewCountTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
int min, int max, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
int counter;
|
||||
@@ -5908,9 +5908,9 @@ error:
|
||||
* @param data data associated to the transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewOnceTrans2(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewOnceTrans2(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
const xmlChar *token2,
|
||||
int min, int max, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
@@ -5994,9 +5994,9 @@ error:
|
||||
* @param data data associated to the transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewOnceTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, const xmlChar *token,
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewOnceTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, const xmlChar *token,
|
||||
int min, int max, void *data) {
|
||||
xmlRegAtomPtr atom;
|
||||
int counter;
|
||||
@@ -6047,8 +6047,8 @@ error:
|
||||
* @param am an automata
|
||||
* @returns the new state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewState(xmlAutomataPtr am) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewState(xmlAutomata *am) {
|
||||
if (am == NULL)
|
||||
return(NULL);
|
||||
return(xmlRegStatePush(am));
|
||||
@@ -6064,9 +6064,9 @@ xmlAutomataNewState(xmlAutomataPtr am) {
|
||||
* @param to the target point of the transition or NULL
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewEpsilon(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewEpsilon(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to) {
|
||||
if ((am == NULL) || (from == NULL))
|
||||
return(NULL);
|
||||
xmlFAGenerateEpsilonTransition(am, from, to);
|
||||
@@ -6087,9 +6087,9 @@ xmlAutomataNewEpsilon(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param lax allow to transition if not all all transitions have been activated
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewAllTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, int lax) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewAllTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, int lax) {
|
||||
if ((am == NULL) || (from == NULL))
|
||||
return(NULL);
|
||||
xmlFAGenerateAllTransition(am, from, to, lax);
|
||||
@@ -6107,7 +6107,7 @@ xmlAutomataNewAllTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @returns the counter number or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
|
||||
xmlAutomataNewCounter(xmlAutomata *am, int min, int max) {
|
||||
int ret;
|
||||
|
||||
if (am == NULL)
|
||||
@@ -6132,9 +6132,9 @@ xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
|
||||
* @param counter the counter associated to that transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewCountedTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, int counter) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewCountedTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, int counter) {
|
||||
if ((am == NULL) || (from == NULL) || (counter < 0))
|
||||
return(NULL);
|
||||
xmlFAGenerateCountedEpsilonTransition(am, from, to, counter);
|
||||
@@ -6154,9 +6154,9 @@ xmlAutomataNewCountedTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param counter the counter associated to that transition
|
||||
* @returns the target state or NULL in case of error
|
||||
*/
|
||||
xmlAutomataStatePtr
|
||||
xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
xmlAutomataStatePtr to, int counter) {
|
||||
xmlAutomataState *
|
||||
xmlAutomataNewCounterTrans(xmlAutomata *am, xmlAutomataState *from,
|
||||
xmlAutomataState *to, int counter) {
|
||||
if ((am == NULL) || (from == NULL) || (counter < 0))
|
||||
return(NULL);
|
||||
xmlFAGenerateCountedTransition(am, from, to, counter);
|
||||
@@ -6172,8 +6172,8 @@ xmlAutomataNewCounterTrans(xmlAutomataPtr am, xmlAutomataStatePtr from,
|
||||
* @param am an automata
|
||||
* @returns the compiled regexp or NULL in case of error
|
||||
*/
|
||||
xmlRegexpPtr
|
||||
xmlAutomataCompile(xmlAutomataPtr am) {
|
||||
xmlRegexp *
|
||||
xmlAutomataCompile(xmlAutomata *am) {
|
||||
xmlRegexpPtr ret;
|
||||
|
||||
if ((am == NULL) || (am->error != 0)) return(NULL);
|
||||
@@ -6193,7 +6193,7 @@ xmlAutomataCompile(xmlAutomataPtr am) {
|
||||
* @returns 1 if true, 0 if not, and -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlAutomataIsDeterminist(xmlAutomataPtr am) {
|
||||
xmlAutomataIsDeterminist(xmlAutomata *am) {
|
||||
int ret;
|
||||
|
||||
if (am == NULL)
|
||||
@@ -6221,15 +6221,15 @@ typedef struct _xmlExpCtxt xmlExpCtxt;
|
||||
typedef xmlExpCtxt *xmlExpCtxtPtr;
|
||||
|
||||
XMLPUBFUN void
|
||||
xmlExpFreeCtxt (xmlExpCtxtPtr ctxt);
|
||||
XMLPUBFUN xmlExpCtxtPtr
|
||||
xmlExpFreeCtxt (xmlExpCtxt *ctxt);
|
||||
XMLPUBFUN xmlExpCtxt *
|
||||
xmlExpNewCtxt (int maxNodes,
|
||||
xmlDictPtr dict);
|
||||
xmlDict *dict);
|
||||
|
||||
XMLPUBFUN int
|
||||
xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt);
|
||||
xmlExpCtxtNbNodes(xmlExpCtxt *ctxt);
|
||||
XMLPUBFUN int
|
||||
xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt);
|
||||
xmlExpCtxtNbCons(xmlExpCtxt *ctxt);
|
||||
|
||||
/* Expressions are trees but the tree is opaque */
|
||||
typedef struct _xmlExpNode xmlExpNode;
|
||||
@@ -6255,67 +6255,67 @@ XMLPUBVAR xmlExpNodePtr emptyExp;
|
||||
* Expressions are reference counted internally
|
||||
*/
|
||||
XMLPUBFUN void
|
||||
xmlExpFree (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr);
|
||||
xmlExpFree (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr);
|
||||
XMLPUBFUN void
|
||||
xmlExpRef (xmlExpNodePtr expr);
|
||||
xmlExpRef (xmlExpNode *expr);
|
||||
|
||||
/*
|
||||
* constructors can be either manual or from a string
|
||||
*/
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpParse (xmlExpCtxtPtr ctxt,
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpParse (xmlExpCtxt *ctxt,
|
||||
const char *expr);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpNewAtom (xmlExpCtxtPtr ctxt,
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpNewAtom (xmlExpCtxt *ctxt,
|
||||
const xmlChar *name,
|
||||
int len);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpNewOr (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr left,
|
||||
xmlExpNodePtr right);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpNewSeq (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr left,
|
||||
xmlExpNodePtr right);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpNewRange (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr subset,
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpNewOr (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *left,
|
||||
xmlExpNode *right);
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpNewSeq (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *left,
|
||||
xmlExpNode *right);
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpNewRange (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *subset,
|
||||
int min,
|
||||
int max);
|
||||
/*
|
||||
* The really interesting APIs
|
||||
*/
|
||||
XMLPUBFUN int
|
||||
xmlExpIsNillable(xmlExpNodePtr expr);
|
||||
xmlExpIsNillable(xmlExpNode *expr);
|
||||
XMLPUBFUN int
|
||||
xmlExpMaxToken (xmlExpNodePtr expr);
|
||||
xmlExpMaxToken (xmlExpNode *expr);
|
||||
XMLPUBFUN int
|
||||
xmlExpGetLanguage(xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr,
|
||||
xmlExpGetLanguage(xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr,
|
||||
const xmlChar**langList,
|
||||
int len);
|
||||
XMLPUBFUN int
|
||||
xmlExpGetStart (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr,
|
||||
xmlExpGetStart (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr,
|
||||
const xmlChar**tokList,
|
||||
int len);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpStringDerive(xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr,
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpStringDerive(xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr,
|
||||
const xmlChar *str,
|
||||
int len);
|
||||
XMLPUBFUN xmlExpNodePtr
|
||||
xmlExpExpDerive (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr,
|
||||
xmlExpNodePtr sub);
|
||||
XMLPUBFUN xmlExpNode *
|
||||
xmlExpExpDerive (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr,
|
||||
xmlExpNode *sub);
|
||||
XMLPUBFUN int
|
||||
xmlExpSubsume (xmlExpCtxtPtr ctxt,
|
||||
xmlExpNodePtr expr,
|
||||
xmlExpNodePtr sub);
|
||||
xmlExpSubsume (xmlExpCtxt *ctxt,
|
||||
xmlExpNode *expr,
|
||||
xmlExpNode *sub);
|
||||
XMLPUBFUN void
|
||||
xmlExpDump (xmlBufferPtr buf,
|
||||
xmlExpNodePtr expr);
|
||||
xmlExpDump (xmlBuffer *buf,
|
||||
xmlExpNode *expr);
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
@@ -6343,8 +6343,8 @@ struct _xmlExpCtxt {
|
||||
* @param dict optional dictionary to use internally
|
||||
* @returns the context or NULL in case of error
|
||||
*/
|
||||
xmlExpCtxtPtr
|
||||
xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
|
||||
xmlExpCtxt *
|
||||
xmlExpNewCtxt(int maxNodes, xmlDict *dict) {
|
||||
xmlExpCtxtPtr ret;
|
||||
int size = 256;
|
||||
|
||||
@@ -6384,7 +6384,7 @@ xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
|
||||
* @param ctxt an expression context
|
||||
*/
|
||||
void
|
||||
xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
|
||||
xmlExpFreeCtxt(xmlExpCtxt *ctxt) {
|
||||
if (ctxt == NULL)
|
||||
return;
|
||||
xmlDictFree(ctxt->dict);
|
||||
@@ -6771,7 +6771,7 @@ xmlExpHashGetEntry(xmlExpCtxtPtr ctxt, xmlExpNodeType type,
|
||||
* @param exp the expression
|
||||
*/
|
||||
void
|
||||
xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
|
||||
xmlExpFree(xmlExpCtxt *ctxt, xmlExpNode *exp) {
|
||||
if ((exp == NULL) || (exp == forbiddenExp) || (exp == emptyExp))
|
||||
return;
|
||||
exp->ref--;
|
||||
@@ -6812,7 +6812,7 @@ xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
|
||||
* @param exp the expression
|
||||
*/
|
||||
void
|
||||
xmlExpRef(xmlExpNodePtr exp) {
|
||||
xmlExpRef(xmlExpNode *exp) {
|
||||
if (exp != NULL)
|
||||
exp->ref++;
|
||||
}
|
||||
@@ -6825,8 +6825,8 @@ xmlExpRef(xmlExpNodePtr exp) {
|
||||
* @param len the atom name length in byte (or -1);
|
||||
* @returns the node or NULL in case of error
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
|
||||
xmlExpNode *
|
||||
xmlExpNewAtom(xmlExpCtxt *ctxt, const xmlChar *name, int len) {
|
||||
if ((ctxt == NULL) || (name == NULL))
|
||||
return(NULL);
|
||||
name = xmlDictLookup(ctxt->dict, name, len);
|
||||
@@ -6846,8 +6846,8 @@ xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
|
||||
* @param right right expression
|
||||
* @returns the node or NULL in case of error
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
|
||||
xmlExpNode *
|
||||
xmlExpNewOr(xmlExpCtxt *ctxt, xmlExpNode *left, xmlExpNode *right) {
|
||||
if (ctxt == NULL)
|
||||
return(NULL);
|
||||
if ((left == NULL) || (right == NULL)) {
|
||||
@@ -6869,8 +6869,8 @@ xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
|
||||
* @param right right expression
|
||||
* @returns the node or NULL in case of error
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
|
||||
xmlExpNode *
|
||||
xmlExpNewSeq(xmlExpCtxt *ctxt, xmlExpNode *left, xmlExpNode *right) {
|
||||
if (ctxt == NULL)
|
||||
return(NULL);
|
||||
if ((left == NULL) || (right == NULL)) {
|
||||
@@ -6893,8 +6893,8 @@ xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
|
||||
* @param max the upper bound for the repetition, -1 means infinite
|
||||
* @returns the node or NULL in case of error
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
|
||||
xmlExpNode *
|
||||
xmlExpNewRange(xmlExpCtxt *ctxt, xmlExpNode *subset, int min, int max) {
|
||||
if (ctxt == NULL)
|
||||
return(NULL);
|
||||
if ((subset == NULL) || (min < 0) || (max < -1) ||
|
||||
@@ -6956,7 +6956,7 @@ tail:
|
||||
* -2 if there is more than `len` strings
|
||||
*/
|
||||
int
|
||||
xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
|
||||
xmlExpGetLanguage(xmlExpCtxt *ctxt, xmlExpNode *exp,
|
||||
const xmlChar**langList, int len) {
|
||||
if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
|
||||
return(-1);
|
||||
@@ -7022,7 +7022,7 @@ tail:
|
||||
* -2 if there is more than `len` strings
|
||||
*/
|
||||
int
|
||||
xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
|
||||
xmlExpGetStart(xmlExpCtxt *ctxt, xmlExpNode *exp,
|
||||
const xmlChar**tokList, int len) {
|
||||
if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
|
||||
return(-1);
|
||||
@@ -7036,7 +7036,7 @@ xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
|
||||
* @returns 1 if nillable, 0 if not and -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlExpIsNillable(xmlExpNodePtr exp) {
|
||||
xmlExpIsNillable(xmlExpNode *exp) {
|
||||
if (exp == NULL)
|
||||
return(-1);
|
||||
return(IS_NILLABLE(exp) != 0);
|
||||
@@ -7135,8 +7135,8 @@ xmlExpStringDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, const xmlChar *str)
|
||||
* @param len the string len in bytes if available
|
||||
* @returns the resulting expression or NULL in case of internal error
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpStringDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp,
|
||||
xmlExpNode *
|
||||
xmlExpStringDerive(xmlExpCtxt *ctxt, xmlExpNode *exp,
|
||||
const xmlChar *str, int len) {
|
||||
const xmlChar *input;
|
||||
|
||||
@@ -7594,8 +7594,8 @@ xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
||||
* @returns the resulting expression or NULL in case of internal error, the
|
||||
* result must be freed
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
||||
xmlExpNode *
|
||||
xmlExpExpDerive(xmlExpCtxt *ctxt, xmlExpNode *exp, xmlExpNode *sub) {
|
||||
if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
|
||||
return(NULL);
|
||||
|
||||
@@ -7621,7 +7621,7 @@ xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
||||
* @returns 1 if true 0 if false and -1 in case of failure.
|
||||
*/
|
||||
int
|
||||
xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
|
||||
xmlExpSubsume(xmlExpCtxt *ctxt, xmlExpNode *exp, xmlExpNode *sub) {
|
||||
xmlExpNodePtr tmp;
|
||||
|
||||
if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
|
||||
@@ -7820,8 +7820,8 @@ xmlExpParseExpr(xmlExpCtxtPtr ctxt) {
|
||||
* @param expr the 0 terminated string
|
||||
* @returns a new expression or NULL in case of failure
|
||||
*/
|
||||
xmlExpNodePtr
|
||||
xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr) {
|
||||
xmlExpNode *
|
||||
xmlExpParse(xmlExpCtxt *ctxt, const char *expr) {
|
||||
xmlExpNodePtr ret;
|
||||
|
||||
ctxt->expr = expr;
|
||||
@@ -7919,7 +7919,7 @@ xmlExpDumpInt(xmlBufferPtr buf, xmlExpNodePtr expr, int glob) {
|
||||
* @param expr the compiled expression
|
||||
*/
|
||||
void
|
||||
xmlExpDump(xmlBufferPtr buf, xmlExpNodePtr expr) {
|
||||
xmlExpDump(xmlBuffer *buf, xmlExpNode *expr) {
|
||||
if ((buf == NULL) || (expr == NULL))
|
||||
return;
|
||||
xmlExpDumpInt(buf, expr, 0);
|
||||
@@ -7932,7 +7932,7 @@ xmlExpDump(xmlBufferPtr buf, xmlExpNodePtr expr) {
|
||||
* @returns the maximum length or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlExpMaxToken(xmlExpNodePtr expr) {
|
||||
xmlExpMaxToken(xmlExpNode *expr) {
|
||||
if (expr == NULL)
|
||||
return(-1);
|
||||
return(expr->c_max);
|
||||
@@ -7945,7 +7945,7 @@ xmlExpMaxToken(xmlExpNodePtr expr) {
|
||||
* @returns the number of nodes in use or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
|
||||
xmlExpCtxtNbNodes(xmlExpCtxt *ctxt) {
|
||||
if (ctxt == NULL)
|
||||
return(-1);
|
||||
return(ctxt->nb_nodes);
|
||||
@@ -7958,7 +7958,7 @@ xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
|
||||
* @returns the number of nodes ever allocated or -1 in case of error
|
||||
*/
|
||||
int
|
||||
xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
|
||||
xmlExpCtxtNbCons(xmlExpCtxt *ctxt) {
|
||||
if (ctxt == NULL)
|
||||
return(-1);
|
||||
return(ctxt->nb_cons);
|
||||
|
||||
Reference in New Issue
Block a user