*
* Reference:
* http://www.w3.org/TR/2001/REC-xmlschema-1-20010502/
- * to some extent
+ * to some extent
* http://www.w3.org/TR/1999/REC-xml-19991116
*
* See Copyright for the status of this software.
/* #define DEBUG_STREAMING */
+#ifdef ERROR
+#undef ERROR
+#endif
#define ERROR(a, b, c, d)
#define ERROR5(a, b, c, d, e)
* NOTE: Those private flags (XML_STREAM_xxx) are used
* in _xmlStreamCtxt->flag. They extend the public
* xmlPatternFlags, so be carefull not to interfere with the
-* reserved values for xmlPatternFlags.
+* reserved values for xmlPatternFlags.
*/
#define XML_STREAM_FINAL_IS_ANY_NODE 1<<14
#define XML_STREAM_FROM_ROOT 1<<15
#define PAT_FROM_CUR (1<<9)
struct _xmlPattern {
- void *data; /* the associated template */
+ void *data; /* the associated template */
xmlDictPtr dict; /* the optional dictionary */
struct _xmlPattern *next; /* next pattern if | is used */
const xmlChar *pattern; /* the pattern */
int error; /* error code */
xmlDictPtr dict; /* the dictionary if any */
xmlPatternPtr comp; /* the result */
- xmlNodePtr elem; /* the current node if any */
+ xmlNodePtr elem; /* the current node if any */
const xmlChar **namespaces; /* the namespaces definitions */
int nb_namespaces; /* the number of namespaces */
};
/************************************************************************
- * *
- * Type functions *
- * *
+ * *
+ * Type functions *
+ * *
************************************************************************/
/**
cur->base = pattern;
if (namespaces != NULL) {
int i;
- for (i = 0;namespaces[2 * i] != NULL;i++);
+ for (i = 0;namespaces[2 * i] != NULL;i++)
+ ;
cur->nb_namespaces = i;
} else {
cur->nb_namespaces = 0;
static void
xmlFreePatParserContext(xmlPatParserContextPtr ctxt) {
if (ctxt == NULL)
- return;
+ return;
memset(ctxt, -1, sizeof(xmlPatParserContext));
xmlFree(ctxt);
}
}
/************************************************************************
- * *
- * The interpreter for the precompiled patterns *
- * *
+ * *
+ * The interpreter for the precompiled patterns *
+ * *
************************************************************************/
static int
* *
************************************************************************/
-#define TODO \
+#define TODO \
xmlGenericError(xmlGenericErrorContext, \
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
#define PEEKPREV(val) ctxt->cur[-(val)]
#define CUR_PTR ctxt->cur
-#define SKIP_BLANKS \
+#define SKIP_BLANKS \
while (IS_BLANK_CH(CUR)) NEXT
#define CURRENT (*ctxt->cur)
#define NEXT ((*ctxt->cur) ? ctxt->cur++: ctxt->cur)
-#define PUSH(op, val, val2) \
+#define PUSH(op, val, val2) \
if (xmlPatternAdd(ctxt, ctxt->comp, (op), (val), (val2))) goto error;
#define XSLT_ERROR(X) \
if (ctxt->dict)
ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
else
- ret = xmlStrndup(q, cur - q);
+ ret = xmlStrndup(q, cur - q);
}
cur += len;
CUR_PTR = cur;
if (ctxt->dict)
ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
else
- ret = xmlStrndup(q, cur - q);
+ ret = xmlStrndup(q, cur - q);
}
cur += len;
CUR_PTR = cur;
* xmlPatScanName:
* @ctxt: the XPath Parser context
*
- * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' |
+ * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' |
* CombiningChar | Extender
*
* [5] Name ::= (Letter | '_' | ':') (NameChar)*
while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
(val == '.') || (val == '-') ||
- (val == '_') ||
+ (val == '_') ||
(IS_COMBINING(val)) ||
(IS_EXTENDER(val))) {
cur += len;
if (ctxt->dict)
ret = (xmlChar *) xmlDictLookup(ctxt->dict, q, cur - q);
else
- ret = xmlStrndup(q, cur - q);
+ ret = xmlStrndup(q, cur - q);
CUR_PTR = cur;
return(ret);
}
xmlChar *token = NULL;
xmlChar *name = NULL;
xmlChar *URL = NULL;
-
+
SKIP_BLANKS;
name = xmlPatScanNCName(ctxt);
if (name == NULL) {
if (CUR == ':') {
int i;
xmlChar *prefix = name;
-
+
NEXT;
- if (IS_BLANK_CH(CUR)) {
+ if (IS_BLANK_CH(CUR)) {
ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
XML_PAT_FREE_STRING(ctxt, prefix);
ctxt->error = 1;
(prefix[2] == 'l') &&
(prefix[3] == 0))
{
- XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE);
+ XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE);
} else {
for (i = 0;i < ctxt->nb_namespaces;i++) {
if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
- XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
+ XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
break;
}
}
ERROR5(NULL, NULL, NULL,
"xmlCompileAttributeTest : no namespace bound to prefix %s\n",
prefix);
- ctxt->error = 1;
+ ctxt->error = 1;
goto error;
}
}
"xmlCompileAttributeTest : Name expected\n");
ctxt->error = 1;
goto error;
- }
+ }
} else {
PUSH(XML_OP_ATTR, token, URL);
}
return;
error:
if (URL != NULL)
- XML_PAT_FREE_STRING(ctxt, URL)
+ XML_PAT_FREE_STRING(ctxt, URL)
if (token != NULL)
XML_PAT_FREE_STRING(ctxt, token);
}
* form suitable for fast matching.
*
* [3] Step ::= '.' | NameTest
- * [4] NameTest ::= QName | '*' | NCName ':' '*'
+ * [4] NameTest ::= QName | '*' | NCName ':' '*'
*/
static void
}
NEXT;
xmlCompileAttributeTest(ctxt);
- if (ctxt->error != 0)
+ if (ctxt->error != 0)
goto error;
return;
}
NEXT;
if (CUR != ':') {
xmlChar *prefix = name;
- int i;
+ int i;
if (hasBlanks || IS_BLANK_CH(CUR)) {
ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
}
}
XML_PAT_FREE_STRING(ctxt, prefix);
+ name = NULL;
if (token == NULL) {
if (CUR == '*') {
NEXT;
}
} else {
NEXT;
- if (xmlStrEqual(name, (const xmlChar *) "child")) {
+ if (xmlStrEqual(name, (const xmlChar *) "child")) {
XML_PAT_FREE_STRING(ctxt, name);
name = xmlPatScanName(ctxt);
if (name == NULL) {
if (CUR == ':') {
xmlChar *prefix = name;
int i;
-
+
NEXT;
if (IS_BLANK_CH(CUR)) {
ERROR5(NULL, NULL, NULL, "Invalid QName.\n", NULL);
(prefix[2] == 'l') &&
(prefix[3] == 0))
{
- XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)
+ XML_PAT_COPY_NSNAME(ctxt, URL, XML_XML_NAMESPACE)
} else {
for (i = 0;i < ctxt->nb_namespaces;i++) {
if (xmlStrEqual(ctxt->namespaces[2 * i + 1], prefix)) {
- XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
+ XML_PAT_COPY_NSNAME(ctxt, URL, ctxt->namespaces[2 * i])
break;
}
}
}
}
XML_PAT_FREE_STRING(ctxt, prefix);
+ name = NULL;
if (token == NULL) {
if (CUR == '*') {
NEXT;
"The 'element' or 'attribute' axis is expected.\n", NULL);
ctxt->error = 1;
goto error;
- }
+ }
}
} else if (CUR == '*') {
if (name != NULL) {
return;
error:
if (URL != NULL)
- XML_PAT_FREE_STRING(ctxt, URL)
+ XML_PAT_FREE_STRING(ctxt, URL)
if (token != NULL)
XML_PAT_FREE_STRING(ctxt, token)
if (name != NULL)
* Compile the Path Pattern and generates a precompiled
* form suitable for fast matching.
*
- * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
+ * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
*/
static void
xmlCompilePathPattern(xmlPatParserContextPtr ctxt) {
} else if ((CUR == '.') || (ctxt->comp->flags & XML_PATTERN_NOTPATTERN)) {
ctxt->comp->flags |= PAT_FROM_CUR;
}
-
+
if ((CUR == '/') && (NXT(1) == '/')) {
PUSH(XML_OP_ANCESTOR, NULL, NULL);
NEXT;
ERROR5(NULL, NULL, NULL,
"Incomplete expression '%s'.\n", ctxt->base);
ctxt->error = 1;
- goto error;
+ goto error;
}
xmlCompileStepPattern(ctxt);
if (ctxt->error != 0)
* Compile the Path Pattern and generates a precompiled
* form suitable for fast matching.
*
- * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
+ * [5] Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest )
*/
static void
xmlCompileIDCXPathPath(xmlPatParserContextPtr ctxt) {
*/
do {
xmlCompileStepPattern(ctxt);
- if (ctxt->error != 0)
+ if (ctxt->error != 0)
goto error;
SKIP_BLANKS;
if (CUR != '/')
}
if (CUR == 0)
goto error_unfinished;
-
+
} while (CUR != 0);
if (CUR != 0) {
error_unfinished:
ctxt->error = 1;
ERROR5(NULL, NULL, NULL,
- "Unfinished expression '%s'.\n", ctxt->base);
+ "Unfinished expression '%s'.\n", ctxt->base);
return;
}
/**
* xmlStreamCompile:
* @comp: the precompiled pattern
- *
+ *
* Tries to stream compile a pattern
*
* Returns -1 in case of failure and 0 in case of success.
xmlDictReference(stream->dict);
}
- i = 0;
+ i = 0;
if (comp->flags & PAT_FROM_ROOT)
stream->flags |= XML_STREAM_FROM_ROOT;
break;
case XML_OP_NS:
s = xmlStreamCompAddStep(stream, NULL, step.value,
- XML_ELEMENT_NODE, flags);
+ XML_ELEMENT_NODE, flags);
if (s < 0)
goto error;
prevs = s;
- flags = 0;
- break;
+ flags = 0;
+ break;
case XML_OP_ATTR:
flags |= XML_STREAM_STEP_ATTR;
prevs = -1;
if (s < 0)
goto error;
break;
- case XML_OP_ELEM:
+ case XML_OP_ELEM:
if ((step.value == NULL) && (step.value2 == NULL)) {
/*
* We have a "." or "self::node()" here.
if (comp->nbStep == i + 1) {
stream->flags |= XML_STREAM_FINAL_IS_ANY_NODE;
}
- flags |= XML_STREAM_STEP_NODE;
+ flags |= XML_STREAM_STEP_NODE;
s = xmlStreamCompAddStep(stream, NULL, NULL,
XML_STREAM_ANY_NODE, flags);
if (s < 0)
stream->steps[prevs].flags |= XML_STREAM_STEP_IN_SET;
prevs = -1;
}
- break;
+ break;
} else {
/* Just skip this one. */
continue;
}
}
- /* An element node. */
+ /* An element node. */
s = xmlStreamCompAddStep(stream, step.value, step.value2,
- XML_ELEMENT_NODE, flags);
+ XML_ELEMENT_NODE, flags);
if (s < 0)
goto error;
prevs = s;
- flags = 0;
- break;
+ flags = 0;
+ break;
case XML_OP_CHILD:
/* An element node child. */
s = xmlStreamCompAddStep(stream, step.value, step.value2,
- XML_ELEMENT_NODE, flags);
+ XML_ELEMENT_NODE, flags);
if (s < 0)
goto error;
prevs = s;
flags = 0;
- break;
+ break;
case XML_OP_ALL:
s = xmlStreamCompAddStep(stream, NULL, NULL,
- XML_ELEMENT_NODE, flags);
+ XML_ELEMENT_NODE, flags);
if (s < 0)
goto error;
prevs = s;
flags = 0;
break;
- case XML_OP_PARENT:
+ case XML_OP_PARENT:
break;
case XML_OP_ANCESTOR:
/* Skip redundant continuations. */
stream->flags |= XML_STREAM_DESC;
break;
}
- }
+ }
if ((! root) && (comp->flags & XML_PATTERN_NOTPATTERN) == 0) {
/*
* If this should behave like a real pattern, we will mark
if (stream->nbStep > 0) {
if ((stream->steps[0].flags & XML_STREAM_STEP_DESC) == 0)
- stream->steps[0].flags |= XML_STREAM_STEP_DESC;
+ stream->steps[0].flags |= XML_STREAM_STEP_DESC;
}
}
if (stream->nbStep <= s)
if ((nodeType != XML_ATTRIBUTE_NODE) &&
(((stream->flags & XML_PATTERN_NOTPATTERN) == 0) ||
(stream->level == 0))) {
- ret = 1;
+ ret = 1;
}
stream->level++;
goto stream_next;
/*
* Skip blocked expressions.
*/
- stream->level++;
+ stream->level++;
goto stream_next;
}
* If there are "//", then we need to process every "//"
* occuring in the states, plus any other state for this
* level.
- */
+ */
stepNr = stream->states[2 * i];
/* TODO: should not happen anymore: dead states */
if ((tmp < stream->level) && (!desc))
goto next_state;
}
- /*
+ /*
* Check for correct node-type.
*/
step = comp->steps[stepNr];
goto next_state;
} else if (step.nodeType != XML_STREAM_ANY_NODE)
goto next_state;
- }
+ }
/*
* Compare local/namespace-name.
*/
xmlStrEqual(step.name, name) &&
((step.ns == ns) || xmlStrEqual(step.ns, ns)))
{
- match = 1;
- }
-#if 0
+ match = 1;
+ }
+#if 0
/*
* TODO: Pointer comparison won't work, since not guaranteed that the given
* values are in the same dict; especially if it's the namespace name,
} else {
match = ((step.name == name) && (step.ns == ns));
}
-#endif /* if 0 ------------------------------------------------------- */
- if (match) {
+#endif /* if 0 ------------------------------------------------------- */
+ if (match) {
final = step.flags & XML_STREAM_STEP_FINAL;
if (desc) {
if (final) {
*/
ret = 1;
}
- }
+ }
if (((comp->flags & XML_STREAM_DESC) == 0) &&
((! match) || final)) {
/*
* Re/enter the expression if it is a "descendant" one,
* or if we are at the 1st level of evaluation.
*/
-
+
if (stream->level == 1) {
if (XML_STREAM_XS_IDC(stream)) {
/*
goto stream_next;
} else
goto compare;
- }
+ }
/*
* A "//" is always reentrant.
*/
/*
* XS-IDC: Process the 2nd level, since the missing
* "self::node()" is responsible for the 2nd level being
- * the real start level.
- */
+ * the real start level.
+ */
if ((stream->level == 2) && XML_STREAM_XS_IDC(stream))
goto compare;
goto stream_next;
}
-
+
compare:
/*
* Check expected node-type.
if (nodeType == XML_ATTRIBUTE_NODE)
goto stream_next;
else if (step.nodeType != XML_STREAM_ANY_NODE)
- goto stream_next;
+ goto stream_next;
}
/*
* Compare local/namespace-name.
xmlStrEqual(step.name, name) &&
((step.ns == ns) || xmlStrEqual(step.ns, ns)))
{
- match = 1;
- }
+ match = 1;
+ }
final = step.flags & XML_STREAM_STEP_FINAL;
- if (match) {
+ if (match) {
if (final)
ret = 1;
else
stream_next:
stream = stream->next;
} /* while stream != NULL */
-
+
if (err > 0)
ret = -1;
#ifdef DEBUG_STREAMING
int
xmlStreamPop(xmlStreamCtxtPtr stream) {
int i, lev;
-
+
if (stream == NULL)
return(-1);
while (stream != NULL) {
if (stream->blockLevel == stream->level)
stream->blockLevel = -1;
- stream->level--;
- if (stream->level < 0)
- return(-1);
+ /*
+ * stream->level can be zero when XML_FINAL_IS_ANY_NODE is set
+ * (see the thread at
+ * http://mail.gnome.org/archives/xslt/2008-July/msg00027.html)
+ */
+ if (stream->level)
+ stream->level--;
/*
* Check evolution of existing states
- */
+ */
for (i = stream->nbState -1; i >= 0; i--) {
/* discard obsoleted states */
lev = stream->states[(2 * i) + 1];
*/
int
xmlStreamWantsAnyNode(xmlStreamCtxtPtr streamCtxt)
-{
+{
if (streamCtxt == NULL)
return(-1);
while (streamCtxt != NULL) {
- if (streamCtxt->comp->flags & XML_STREAM_FINAL_IS_ANY_NODE)
+ if (streamCtxt->comp->flags & XML_STREAM_FINAL_IS_ANY_NODE)
return(1);
streamCtxt = streamCtxt->next;
}
}
or++;
}
- if (ctxt == NULL) goto error;
+ if (ctxt == NULL) goto error;
cur = xmlNewPattern();
if (cur == NULL) goto error;
/*
* Assign string dict.
*/
- if (dict) {
+ if (dict) {
cur->dict = dict;
xmlDictReference(dict);
}
* part of the set.
*
* Returns -1 in case of error otherwise the depth,
- *
+ *
*/
int
xmlPatternMinDepth(xmlPatternPtr comp) {
projects / platform / upstream / gettext.git / blobdiff