From 2fc6df95cc021fb16debe942697eda86eeba39ae Mon Sep 17 00:00:00 2001 From: Daniel Veillard Date: Sun, 30 Jan 2005 18:42:55 +0000 Subject: [PATCH] added a streaming pattern detector for a subset of XPath, should help * pattern.c include/libxml/pattern.h xmllint.c: added a streaming pattern detector for a subset of XPath, should help Kasimier for identity constraints * python/generator.py: applied Stephane Bidoul patch to find paths without breaking. Daniel --- ChangeLog | 8 + include/libxml/pattern.h | 14 + pattern.c | 543 ++++++++++++++++++++++++++++++++++++++- python/generator.py | 15 +- xmllint.c | 102 ++++++-- 5 files changed, 652 insertions(+), 30 deletions(-) diff --git a/ChangeLog b/ChangeLog index 458670d2..23d96d26 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,11 @@ +Sun Jan 30 19:27:23 CET 2005 Daniel Veillard + + * pattern.c include/libxml/pattern.h xmllint.c: added a + streaming pattern detector for a subset of XPath, should + help Kasimier for identity constraints + * python/generator.py: applied Stephane Bidoul patch to find + paths without breaking. + Fri Jan 28 18:53:40 CET 2005 Daniel Veillard * xmlschemas.c: fixed an untested pointer dereference and a & vs && diff --git a/include/libxml/pattern.h b/include/libxml/pattern.h index 02c833b8..9b85f9c2 100644 --- a/include/libxml/pattern.h +++ b/include/libxml/pattern.h @@ -44,6 +44,20 @@ XMLPUBFUN int XMLCALL xmlPatternMatch (xmlPatternPtr comp, xmlNodePtr node); +/* streaming interfaces */ +typedef struct _xmlStreamCtxt xmlStreamCtxt; +typedef xmlStreamCtxt *xmlStreamCtxtPtr; + +XMLPUBFUN xmlStreamCtxtPtr XMLCALL + xmlPatternGetStreamCtxt (xmlPatternPtr comp); +XMLPUBFUN void XMLCALL + xmlFreeStreamCtxt (xmlStreamCtxtPtr stream); +XMLPUBFUN int XMLCALL + xmlStreamPush (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN int XMLCALL + xmlStreamPop (xmlStreamCtxtPtr stream); #ifdef __cplusplus } #endif diff --git a/pattern.c b/pattern.c index 74985a81..47b4f22c 100644 --- a/pattern.c +++ b/pattern.c @@ -25,9 +25,42 @@ #ifdef LIBXML_PATTERN_ENABLED +#define DEBUG_STREAMING + #define ERROR(a, b, c, d) #define ERROR5(a, b, c, d, e) +#define XML_STREAM_STEP_DESC 1 +#define XML_STREAM_STEP_FINAL 2 +#define XML_STREAM_STEP_ROOT 4 + +typedef struct _xmlStreamStep xmlStreamStep; +typedef xmlStreamStep *xmlStreamStepPtr; +struct _xmlStreamStep { + int flags; /* properties of that step */ + const xmlChar *name; /* first string value if NULL accept all */ + const xmlChar *ns; /* second string value */ +}; + +typedef struct _xmlStreamComp xmlStreamComp; +typedef xmlStreamComp *xmlStreamCompPtr; +struct _xmlStreamComp { + xmlDict *dict; /* the dictionnary if any */ + int nbStep; /* number of steps in the automata */ + int maxStep; /* allocated number of steps */ + xmlStreamStepPtr steps; /* the array of steps */ +}; + +struct _xmlStreamCtxt { + xmlStreamCompPtr comp; /* the compiled stream */ + int nbState; /* number of state in the automata */ + int maxState; /* allocated number of state */ + int level; /* how deep are we ? */ + int *states; /* the array of step indexes */ +}; + +static void xmlFreeStreamComp(xmlStreamCompPtr comp); + /* * Types are private: */ @@ -55,12 +88,14 @@ struct _xmlStepOp { struct _xmlPattern { void *data; /* the associated template */ - struct _xmlPattern *next; /* siblings */ + xmlDictPtr dict; /* the optional dictionnary */ + struct _xmlPattern *next; /* siblings */ const xmlChar *pattern; /* the pattern */ int nbStep; int maxStep; xmlStepOpPtr steps; /* ops for computation */ + xmlStreamCompPtr stream; /* the streaming data if any */ }; typedef struct _xmlPatParserContext xmlPatParserContext; @@ -124,18 +159,25 @@ xmlFreePattern(xmlPatternPtr comp) { if (comp == NULL) return; + if (comp->stream != NULL) + xmlFreeStreamComp(comp->stream); if (comp->pattern != NULL) xmlFree((xmlChar *)comp->pattern); if (comp->steps != NULL) { - for (i = 0;i < comp->nbStep;i++) { - op = &comp->steps[i]; - if (op->value != NULL) - xmlFree((xmlChar *) op->value); - if (op->value2 != NULL) - xmlFree((xmlChar *) op->value2); + if (comp->dict == NULL) { + for (i = 0;i < comp->nbStep;i++) { + op = &comp->steps[i]; + if (op->value != NULL) + xmlFree((xmlChar *) op->value); + if (op->value2 != NULL) + xmlFree((xmlChar *) op->value2); + } } xmlFree(comp->steps); } + if (comp->dict != NULL) + xmlDictFree(comp->dict); + memset(comp, -1, sizeof(xmlPattern)); xmlFree(comp); } @@ -161,7 +203,8 @@ xmlFreePatternList(xmlPatternPtr comp) { * xmlNewPatParserContext: * @pattern: the pattern context * @dict: the inherited dictionnary or NULL - * @namespaces: the prefix definitions, array of [URI, prefix] or NULL + * @namespaces: the prefix definitions, array of [URI, prefix] terminated + * with [NULL, NULL] or NULL if no namespace is used * * Create a new XML pattern parser context * @@ -347,6 +390,9 @@ xmlPatMatch(xmlPatternPtr comp, xmlNodePtr node) { case XML_OP_END: return(1); case XML_OP_ROOT: + if (node->type == XML_NAMESPACE_DECL) + return(0); + node = node->parent; if ((node->type == XML_DOCUMENT_NODE) || #ifdef LIBXML_DOCB_ENABLED (node->type == XML_DOCB_DOCUMENT_NODE) || @@ -883,6 +929,10 @@ xmlCompilePathPattern(xmlPatParserContextPtr ctxt) { if (CUR == '@') { TODO } else { + if (CUR == '/') { + PUSH(XML_OP_ROOT, NULL, NULL); + NEXT; + } xmlCompileStepPattern(ctxt); SKIP_BLANKS; while (CUR == '/') { @@ -905,6 +955,465 @@ xmlCompilePathPattern(xmlPatParserContextPtr ctxt) { error: return; } + +/************************************************************************ + * * + * The streaming code * + * * + ************************************************************************/ + +#ifdef DEBUG_STREAMING +static void +xmlDebugStreamComp(xmlStreamCompPtr stream) { + int i; + + if (stream == NULL) { + printf("Stream: NULL\n"); + return; + } + printf("Stream: %d steps\n", stream->nbStep); + for (i = 0;i < stream->nbStep;i++) { + if (stream->steps[i].ns != NULL) { + printf("{%s}", stream->steps[i].ns); + } + if (stream->steps[i].name == NULL) { + printf("* "); + } else { + printf("%s ", stream->steps[i].name); + } + if (stream->steps[i].flags & XML_STREAM_STEP_ROOT) + printf("root "); + if (stream->steps[i].flags & XML_STREAM_STEP_DESC) + printf("// "); + if (stream->steps[i].flags & XML_STREAM_STEP_FINAL) + printf("final "); + printf("\n"); + } +} +static void +xmlDebugStreamCtxt(xmlStreamCtxtPtr ctxt, int match) { + int i; + + if (ctxt == NULL) { + printf("Stream: NULL\n"); + return; + } + printf("Stream: level %d, %d states: ", ctxt->level, ctxt->nbState); + if (match) + printf("matches\n"); + else + printf("\n"); + for (i = 0;i < ctxt->nbState;i++) { + if (ctxt->states[2 * i] < 0) + printf(" %d: free\n", i); + else { + printf(" %d: step %d, level %d", i, ctxt->states[2 * i], + ctxt->states[(2 * i) + 1]); + if (ctxt->comp->steps[ctxt->states[2 * i]].flags & + XML_STREAM_STEP_DESC) + printf(" //\n"); + else + printf("\n"); + } + printf("\n"); + } +} +#endif +/** + * xmlNewStreamComp: + * @size: the number of expected steps + * + * build a new compiled pattern for streaming + * + * Returns the new structure or NULL in case of error. + */ +static xmlStreamCompPtr +xmlNewStreamComp(int size) { + xmlStreamCompPtr cur; + + if (size < 4) + size = 4; + + cur = (xmlStreamCompPtr) xmlMalloc(sizeof(xmlStreamComp)); + if (cur == NULL) { + ERROR(NULL, NULL, NULL, + "xmlNewStreamComp: malloc failed\n"); + return(NULL); + } + memset(cur, 0, sizeof(xmlStreamComp)); + cur->steps = (xmlStreamStepPtr) xmlMalloc(size * sizeof(xmlStreamStep)); + if (cur->steps == NULL) { + xmlFree(cur); + ERROR(NULL, NULL, NULL, + "xmlNewStreamComp: malloc failed\n"); + return(NULL); + } + cur->nbStep = 0; + cur->maxStep = size; + return(cur); +} + +/** + * xmlFreeStreamComp: + * @comp: the compiled pattern for streaming + * + * Free the compiled pattern for streaming + */ +static void +xmlFreeStreamComp(xmlStreamCompPtr comp) { + if (comp != NULL) { + if (comp->steps != NULL) + xmlFree(comp->steps); + if (comp->dict != NULL) + xmlDictFree(comp->dict); + xmlFree(comp); + } +} + +/** + * xmlStreamCompAddStep: + * @comp: the compiled pattern for streaming + * @name: the first string, the name, or NULL for * + * @ns: the second step, the namespace name + * @flags: the flags for that step + * + * Add a new step to the compiled pattern + * + * Returns -1 in case of error or the step index if successful + */ +static int +xmlStreamCompAddStep(xmlStreamCompPtr comp, const xmlChar *name, + const xmlChar *ns, int flags) { + xmlStreamStepPtr cur; + + if (comp->nbStep >= comp->maxStep) { + cur = (xmlStreamStepPtr) xmlRealloc(comp->steps, + comp->maxStep * 2 * sizeof(xmlStreamStep)); + if (cur == NULL) { + ERROR(NULL, NULL, NULL, + "xmlNewStreamComp: malloc failed\n"); + return(-1); + } + comp->steps = cur; + comp->maxStep *= 2; + } + cur = &comp->steps[comp->nbStep++]; + cur->flags = flags; + cur->name = name; + cur->ns = ns; + return(comp->nbStep - 1); +} + +/** + * xmlStreamCompile: + * @comp: the precompiled pattern + * + * Tries to stream compile a pattern + * + * Returns -1 in case of failure and 0 in case of success. + */ +static int +xmlStreamCompile(xmlPatternPtr comp) { + xmlStreamCompPtr stream; + int i, s = 0, root = 0, desc = 0; + + if ((comp == NULL) || (comp->steps == NULL)) + return(-1); + stream = xmlNewStreamComp((comp->nbStep / 2) + 1); + if (stream == NULL) + return(-1); + if (comp->dict != NULL) { + stream->dict = comp->dict; + xmlDictReference(stream->dict); + } + for (i = 0;i < comp->nbStep;i++) { + switch (comp->steps[i].op) { + case XML_OP_END: + break; + case XML_OP_ROOT: + if (i != 0) + goto error; + root = 1; + break; + case XML_OP_CHILD: + case XML_OP_ATTR: + case XML_OP_NS: + goto error; + case XML_OP_ELEM: + s = xmlStreamCompAddStep(stream, comp->steps[i].value, + comp->steps[i].value2, desc); + desc = 0; + if (s < 0) + goto error; + break; + case XML_OP_ALL: + s = xmlStreamCompAddStep(stream, NULL, NULL, desc); + desc = 0; + if (s < 0) + goto error; + break; + case XML_OP_PARENT: + break; + case XML_OP_ANCESTOR: + desc = XML_STREAM_STEP_DESC; + break; + } + } + stream->steps[s].flags |= XML_STREAM_STEP_FINAL; + if (root) + stream->steps[0].flags |= XML_STREAM_STEP_ROOT; +#ifdef DEBUG_STREAMING + xmlDebugStreamComp(stream); +#endif + comp->stream = stream; + return(0); +error: + xmlFreeStreamComp(stream); + return(0); +} + +/** + * xmlNewStreamCtxt: + * @size: the number of expected states + * + * build a new stream context + * + * Returns the new structure or NULL in case of error. + */ +static xmlStreamCtxtPtr +xmlNewStreamCtxt(xmlStreamCompPtr stream) { + xmlStreamCtxtPtr cur; + + cur = (xmlStreamCtxtPtr) xmlMalloc(sizeof(xmlStreamCtxt)); + if (cur == NULL) { + ERROR(NULL, NULL, NULL, + "xmlNewStreamCtxt: malloc failed\n"); + return(NULL); + } + memset(cur, 0, sizeof(xmlStreamCtxt)); + cur->states = (int *) xmlMalloc(4 * 2 * sizeof(int)); + if (cur->states == NULL) { + xmlFree(cur); + ERROR(NULL, NULL, NULL, + "xmlNewStreamCtxt: malloc failed\n"); + return(NULL); + } + cur->nbState = 0; + cur->maxState = 4; + cur->level = 0; + cur->comp = stream; + return(cur); +} + +/** + * xmlFreeStreamCtxt: + * @stream: the stream context + * + * Free the stream context + */ +void +xmlFreeStreamCtxt(xmlStreamCtxtPtr stream) { + if (stream != NULL) { + if (stream->states != NULL) + xmlFree(stream->states); + xmlFree(stream); + } +} + +/** + * xmlStreamCtxtAddState: + * @comp: the stream context + * @idx: the step index for that streaming state + * + * Add a new state to the stream context + * + * Returns -1 in case of error or the state index if successful + */ +static int +xmlStreamCtxtAddState(xmlStreamCtxtPtr comp, int idx, int level) { + int i; + for (i = 0;i < comp->nbState;i++) { + if (comp->states[2 * i] < 0) { + comp->states[2 * i] = idx; + comp->states[2 * i + 1] = level; + return(i); + } + } + if (comp->nbState >= comp->maxState) { + int *cur; + + cur = (int *) xmlRealloc(comp->states, + comp->maxState * 4 * sizeof(int)); + if (cur == NULL) { + ERROR(NULL, NULL, NULL, + "xmlNewStreamCtxt: malloc failed\n"); + return(-1); + } + comp->states = cur; + comp->maxState *= 2; + } + comp->states[2 * comp->nbState] = idx; + comp->states[2 * comp->nbState++ + 1] = level; + return(comp->nbState - 1); +} + +/** + * xmlStreamPush: + * @stream: the stream context + * @name: the current name + * @ns: the namespace name + * + * push new data onto the stream. NOTE: if the call xmlPatterncompile() + * indicated a dictionnary, then strings for name and ns will be expected + * to come from the dictionary. + * Both @name and @ns being NULL means the / i.e. the root of the document. + * This can also act as a reset. + * + * Returns: -1 in case of error, 1 if the current state in the stream is a + * match and 0 otherwise. + */ +int +xmlStreamPush(xmlStreamCtxtPtr stream, + const xmlChar *name, const xmlChar *ns) { + int ret = 0, tmp, i, m, match, step; + xmlStreamCompPtr comp; + + if ((stream == NULL) || (stream->nbState < 0)) + return(-1); + comp = stream->comp; + if ((name == NULL) && (ns == NULL)) { + stream->nbState = 0; + stream->level = 0; + if (comp->steps[0].flags & XML_STREAM_STEP_ROOT) { + tmp = xmlStreamCtxtAddState(stream, 0, 0); + if (tmp < 0) + return(-1); + if (comp->steps[tmp].flags & XML_STREAM_STEP_FINAL) + return(1); + } + return(0); + } + /* + * Check evolution of existing states + */ + m = stream->nbState; + for (i = 0;i < m;i++) { + match = 0; + step = stream->states[2 * i]; + /* dead states */ + if (step < 0) continue; + /* skip new states just added */ + if (stream->states[(2 * i) + 1] > stream->level) continue; + + /* discard old states */ + /* something needed about old level discarded */ + + if (comp->dict) { + if (comp->steps[step].name == NULL) { + if (comp->steps[step].ns == NULL) + match = 1; + else + match = (comp->steps[step].ns == ns); + } else { + match = ((comp->steps[step].name == name) && + (comp->steps[step].ns == ns)); + } + } else { + if (comp->steps[step].name == NULL) { + if (comp->steps[step].ns == NULL) + match = 1; + else + match = xmlStrEqual(comp->steps[step].ns, ns); + } else { + match = ((xmlStrEqual(comp->steps[step].name, name)) && + (xmlStrEqual(comp->steps[step].ns, ns))); + } + } + if (match) { + if (comp->steps[step].flags & XML_STREAM_STEP_DESC) { + if (comp->steps[step].flags & XML_STREAM_STEP_FINAL) { + ret = 1; + } else { + /* descending match create a new state */ + xmlStreamCtxtAddState(stream, step + 1, stream->level + 1); + } + } else { + if (comp->steps[step].flags & XML_STREAM_STEP_FINAL) { + ret = 1; + stream->states[2 * i] = -1; + } else { + stream->states[2 * i] = step + 1; + stream->states[2 * i + 1] = stream->level + 1; + } + } + } else if (!(comp->steps[step].flags & XML_STREAM_STEP_DESC)) { + /* didn't match, discard */ + printf("discard %d\n", i); + stream->states[2 * i] = -1; + } + } + + /* + * Check creating a new state. + */ + stream->level++; + if (!(comp->steps[0].flags & XML_STREAM_STEP_ROOT)) { + match = 0; + if (comp->dict) { + if (comp->steps[0].name == NULL) { + if (comp->steps[0].ns == NULL) + match = 1; + else + match = (comp->steps[0].ns == ns); + } else { + match = ((comp->steps[0].name == name) && + (comp->steps[0].ns == ns)); + } + } else { + if (comp->steps[0].name == NULL) { + if (comp->steps[0].ns == NULL) + match = 1; + else + match = xmlStrEqual(comp->steps[0].ns, ns); + } else { + match = ((xmlStrEqual(comp->steps[0].name, name)) && + (xmlStrEqual(comp->steps[0].ns, ns))); + } + } + if (match) { + if (comp->steps[0].flags & XML_STREAM_STEP_FINAL) + ret = 1; + else + xmlStreamCtxtAddState(stream, 1, stream->level); + } + } + +#ifdef DEBUG_STREAMING + xmlDebugStreamCtxt(stream, ret); +#endif + return(ret); +} + +/** + * xmlStreamPop: + * @stream: the stream context + * + * push one level from the stream. + * + * Returns: -1 in case of error, 0 otherwise. + */ +int +xmlStreamPop(xmlStreamCtxtPtr stream) { + if (stream == NULL) + return(-1); + stream->level--; + if (stream->level < 0) + return(-1); + + /* something is certainly needed here */ + return(0); +} + /************************************************************************ * * * The public interfaces * @@ -938,6 +1447,7 @@ xmlPatterncompile(const xmlChar *pattern, xmlDict *dict, xmlCompilePathPattern(ctxt); xmlFreePatParserContext(ctxt); + xmlStreamCompile(ret); if (xmlReversePattern(ret) < 0) goto error; return(ret); @@ -964,4 +1474,21 @@ xmlPatternMatch(xmlPatternPtr comp, xmlNodePtr node) return(xmlPatMatch(comp, node)); } +/** + * xmlPatternGetStreamCtxt: + * @comp: the precompiled pattern + * + * Get a streaming context for that pattern + * Use xmlFreeStreamCtxt to free the context. + * + * Returns a pointer to the context or NULL in case of failure + */ +xmlStreamCtxtPtr +xmlPatternGetStreamCtxt(xmlPatternPtr comp) +{ + if ((comp == NULL) || (comp->stream == NULL)) + return(NULL); + return(xmlNewStreamCtxt(comp->stream)); +} + #endif /* LIBXML_PATTERN_ENABLED */ diff --git a/python/generator.py b/python/generator.py index 0b09b9a2..f2c79392 100755 --- a/python/generator.py +++ b/python/generator.py @@ -6,13 +6,16 @@ functions = {} enums = {} # { enumType: { enumConstant: enumValue } } +import os import sys import string -if len(sys.argv) > 1: - srcPref = sys.argv[1] + '/' +if __name__ == "__main__": + # launched as a script + srcPref = os.path.dirname(sys.argv[0]) else: - srcPref = '' + # imported + srcPref = os.path.dirname(__file__) ####################################################################### # @@ -596,14 +599,14 @@ def buildStubs(): global unknown_types try: - f = open(srcPref + "libxml2-api.xml") + f = open(os.path.join(srcPref,"libxml2-api.xml")) data = f.read() (parser, target) = getparser() parser.feed(data) parser.close() except IOError, msg: try: - f = open(srcPref + "../doc/libxml2-api.xml") + f = open(os.path.join(srcPref,"..","doc","libxml2-api.xml")) data = f.read() (parser, target) = getparser() parser.feed(data) @@ -617,7 +620,7 @@ def buildStubs(): py_types['pythonObject'] = ('O', "pythonObject", "pythonObject", "pythonObject") try: - f = open(srcPref + "libxml2-python-api.xml") + f = open(os.path.join(srcPref,"libxml2-python-api.xml")) data = f.read() (parser, target) = getparser() parser.feed(data) diff --git a/xmllint.c b/xmllint.c index 2f77607b..993c8816 100644 --- a/xmllint.c +++ b/xmllint.c @@ -186,6 +186,7 @@ static int sax1 = 0; #ifdef LIBXML_PATTERN_ENABLED static const char *pattern = NULL; static xmlPatternPtr patternc = NULL; +static xmlStreamCtxtPtr patstream = NULL; #endif static int options = 0; @@ -805,28 +806,78 @@ static void myClose(FILE *f) { ************************************************************************/ static void processNode(xmlTextReaderPtr reader) { const xmlChar *name, *value; + int type; - name = xmlTextReaderConstName(reader); - if (name == NULL) - name = BAD_CAST "--"; + type = xmlTextReaderNodeType(reader); - value = xmlTextReaderConstValue(reader); + if (debug) { + name = xmlTextReaderConstName(reader); + if (name == NULL) + name = BAD_CAST "--"; - printf("%d %d %s %d %d", - xmlTextReaderDepth(reader), - xmlTextReaderNodeType(reader), - name, - xmlTextReaderIsEmptyElement(reader), - xmlTextReaderHasValue(reader)); - if (value == NULL) - printf("\n"); - else { - printf(" %s\n", value); + value = xmlTextReaderConstValue(reader); + + + printf("%d %d %s %d %d", + xmlTextReaderDepth(reader), + type, + name, + xmlTextReaderIsEmptyElement(reader), + xmlTextReaderHasValue(reader)); + if (value == NULL) + printf("\n"); + else { + printf(" %s\n", value); + } } #ifdef LIBXML_PATTERN_ENABLED if (patternc) { - if (xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader)) == 1) { - printf("Node matches pattern %s\n", pattern); + xmlChar *path = NULL; + int match = -1; + + if (type == XML_READER_TYPE_ELEMENT) { + /* do the check only on element start */ + match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader)); + + if (match) { + path = xmlGetNodePath(xmlTextReaderCurrentNode(reader)); + printf("Node %s matches pattern %s\n", path, pattern); + } + } + if (patstream != NULL) { + int ret; + + if (type == XML_READER_TYPE_ELEMENT) { + ret = xmlStreamPush(patstream, + xmlTextReaderConstLocalName(reader), + xmlTextReaderConstNamespaceUri(reader)); + if (ret < 0) { + fprintf(stderr, "xmlStreamPush() failure\n"); + xmlFreeStreamCtxt(patstream); + patstream = NULL; + } else if (ret != match) { + if (path == NULL) { + path = xmlGetNodePath( + xmlTextReaderCurrentNode(reader)); + } + fprintf(stderr, + "xmlPatternMatch and xmlStreamPush disagree\n"); + fprintf(stderr, + " pattern %s node %s\n", + pattern, path); + if (path != NULL) + xmlFree(path); + } + + + } else if (type == XML_READER_TYPE_END_ELEMENT) { + ret = xmlStreamPop(patstream); + if (ret < 0) { + fprintf(stderr, "xmlStreamPop() failure\n"); + xmlFreeStreamCtxt(patstream); + patstream = NULL; + } + } } } #endif @@ -855,6 +906,19 @@ static void streamFile(char *filename) { } else #endif reader = xmlReaderForFile(filename, NULL, options); +#ifdef LIBXML_PATTERN_ENABLED + if (patternc != NULL) { + patstream = xmlPatternGetStreamCtxt(patternc); + if (patstream != NULL) { + ret = xmlStreamPush(patstream, NULL, NULL); + if (ret < 0) { + fprintf(stderr, "xmlStreamPush() failure\n"); + xmlFreeStreamCtxt(patstream); + patstream = NULL; + } + } + } +#endif if (reader != NULL) { @@ -943,6 +1007,12 @@ static void streamFile(char *filename) { fprintf(stderr, "Unable to open %s\n", filename); progresult = XMLLINT_ERR_UNCLASS; } +#ifdef LIBXML_PATTERN_ENABLED + if (patstream != NULL) { + xmlFreeStreamCtxt(patstream); + patstream = NULL; + } +#endif #ifdef HAVE_SYS_MMAN_H if (memory) { xmlFreeParserInputBuffer(input);