#define IN_LIBXML
#include "libxml.h"
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
#include <libxml/dict.h>
#include <libxml/xmlerror.h>
#include <libxml/parserInternals.h>
#include <libxml/pattern.h>
#ifdef LIBXML_PATTERN_ENABLED
#define ERROR(a, b, c, d)
#define ERROR5(a, b, c, d, e)
typedef enum {
XML_OP_END=0,
XML_OP_ROOT,
XML_OP_ELEM,
XML_OP_CHILD,
XML_OP_ATTR,
XML_OP_PARENT,
XML_OP_ANCESTOR,
XML_OP_NS,
XML_OP_ALL
} xmlPatOp;
typedef struct _xmlStepOp xmlStepOp;
typedef xmlStepOp *xmlStepOpPtr;
struct _xmlStepOp {
xmlPatOp op;
const xmlChar *value;
const xmlChar *value2;
};
struct _xmlPattern {
void *data;
struct _xmlPattern *next;
const xmlChar *pattern;
int nbStep;
int maxStep;
xmlStepOp steps[10];
};
typedef struct _xmlPatParserContext xmlPatParserContext;
typedef xmlPatParserContext *xmlPatParserContextPtr;
struct _xmlPatParserContext {
const xmlChar *cur;
const xmlChar *base;
int error;
xmlDictPtr dict;
xmlPatternPtr comp;
xmlNodePtr elem;
const xmlChar **namespaces;
int nb_namespaces;
};
static xmlPatternPtr
xmlNewPattern(void) {
xmlPatternPtr cur;
cur = (xmlPatternPtr) xmlMalloc(sizeof(xmlPattern));
if (cur == NULL) {
ERROR(NULL, NULL, NULL,
"xmlNewPattern : malloc failed\n");
return(NULL);
}
memset(cur, 0, sizeof(xmlPattern));
cur->maxStep = 10;
return(cur);
}
void
xmlFreePattern(xmlPatternPtr comp) {
xmlStepOpPtr op;
int i;
if (comp == NULL)
return;
if (comp->pattern != NULL)
xmlFree((xmlChar *)comp->pattern);
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);
}
memset(comp, -1, sizeof(xmlPattern));
xmlFree(comp);
}
void
xmlFreePatternList(xmlPatternPtr comp) {
xmlPatternPtr cur;
while (comp != NULL) {
cur = comp;
comp = comp->next;
xmlFreePattern(cur);
}
}
static xmlPatParserContextPtr
xmlNewPatParserContext(const xmlChar *pattern, xmlDictPtr dict,
const xmlChar **namespaces) {
xmlPatParserContextPtr cur;
if (pattern == NULL)
return(NULL);
cur = (xmlPatParserContextPtr) xmlMalloc(sizeof(xmlPatParserContext));
if (cur == NULL) {
ERROR(NULL, NULL, NULL,
"xmlNewPatParserContext : malloc failed\n");
return(NULL);
}
memset(cur, 0, sizeof(xmlPatParserContext));
cur->dict = dict;
cur->cur = pattern;
cur->base = pattern;
if (namespaces != NULL) {
int i;
for (i = 0;namespaces[2 * i] != NULL;i++);
cur->nb_namespaces = i;
} else {
cur->nb_namespaces = 0;
}
cur->namespaces = namespaces;
return(cur);
}
static void
xmlFreePatParserContext(xmlPatParserContextPtr ctxt) {
if (ctxt == NULL)
return;
memset(ctxt, -1, sizeof(xmlPatParserContext));
xmlFree(ctxt);
}
static int
xmlPatternAdd(xmlPatParserContextPtr ctxt ATTRIBUTE_UNUSED,
xmlPatternPtr comp,
xmlPatOp op, xmlChar * value, xmlChar * value2)
{
if (comp->nbStep >= 10) {
ERROR(ctxt, NULL, NULL,
"xmlPatternAdd: overflow\n");
return (-1);
}
comp->steps[comp->nbStep].op = op;
comp->steps[comp->nbStep].value = value;
comp->steps[comp->nbStep].value2 = value2;
comp->nbStep++;
return (0);
}
#if 0
static void
xsltSwapTopPattern(xmlPatternPtr comp) {
int i;
int j = comp->nbStep - 1;
if (j > 0) {
register const xmlChar *tmp;
register xmlPatOp op;
i = j - 1;
tmp = comp->steps[i].value;
comp->steps[i].value = comp->steps[j].value;
comp->steps[j].value = tmp;
tmp = comp->steps[i].value2;
comp->steps[i].value2 = comp->steps[j].value2;
comp->steps[j].value2 = tmp;
op = comp->steps[i].op;
comp->steps[i].op = comp->steps[j].op;
comp->steps[j].op = op;
}
}
#endif
static void
xmlReversePattern(xmlPatternPtr comp) {
int i = 0;
int j = comp->nbStep - 1;
while (j > i) {
register const xmlChar *tmp;
register xmlPatOp op;
tmp = comp->steps[i].value;
comp->steps[i].value = comp->steps[j].value;
comp->steps[j].value = tmp;
tmp = comp->steps[i].value2;
comp->steps[i].value2 = comp->steps[j].value2;
comp->steps[j].value2 = tmp;
op = comp->steps[i].op;
comp->steps[i].op = comp->steps[j].op;
comp->steps[j].op = op;
j--;
i++;
}
comp->steps[comp->nbStep++].op = XML_OP_END;
}
static int
xmlPatMatch(xmlPatternPtr comp, xmlNodePtr node) {
int i;
xmlStepOpPtr step;
if ((comp == NULL) || (node == NULL)) return(-1);
for (i = 0;i < comp->nbStep;i++) {
step = &comp->steps[i];
switch (step->op) {
case XML_OP_END:
return(1);
case XML_OP_ROOT:
if ((node->type == XML_DOCUMENT_NODE) ||
#ifdef LIBXML_DOCB_ENABLED
(node->type == XML_DOCB_DOCUMENT_NODE) ||
#endif
(node->type == XML_HTML_DOCUMENT_NODE))
continue;
return(0);
case XML_OP_ELEM:
if (node->type != XML_ELEMENT_NODE)
return(0);
if (step->value == NULL)
continue;
if (step->value[0] != node->name[0])
return(0);
if (!xmlStrEqual(step->value, node->name))
return(0);
if (node->ns == NULL) {
if (step->value2 != NULL)
return(0);
} else if (node->ns->href != NULL) {
if (step->value2 == NULL)
return(0);
if (!xmlStrEqual(step->value2, node->ns->href))
return(0);
}
continue;
case XML_OP_CHILD: {
xmlNodePtr lst;
if ((node->type != XML_ELEMENT_NODE) &&
(node->type != XML_DOCUMENT_NODE) &&
#ifdef LIBXML_DOCB_ENABLED
(node->type != XML_DOCB_DOCUMENT_NODE) &&
#endif
(node->type != XML_HTML_DOCUMENT_NODE))
return(0);
lst = node->children;
if (step->value != NULL) {
while (lst != NULL) {
if ((lst->type == XML_ELEMENT_NODE) &&
(step->value[0] == lst->name[0]) &&
(xmlStrEqual(step->value, lst->name)))
break;
lst = lst->next;
}
if (lst != NULL)
continue;
}
return(0);
}
case XML_OP_ATTR:
if (node->type != XML_ATTRIBUTE_NODE)
return(0);
if (step->value != NULL) {
if (step->value[0] != node->name[0])
return(0);
if (!xmlStrEqual(step->value, node->name))
return(0);
}
if (node->ns == NULL) {
if (step->value2 != NULL)
return(0);
} else if (step->value2 != NULL) {
if (!xmlStrEqual(step->value2, node->ns->href))
return(0);
}
continue;
case XML_OP_PARENT:
if ((node->type == XML_DOCUMENT_NODE) ||
(node->type == XML_HTML_DOCUMENT_NODE) ||
#ifdef LIBXML_DOCB_ENABLED
(node->type == XML_DOCB_DOCUMENT_NODE) ||
#endif
(node->type == XML_NAMESPACE_DECL))
return(0);
node = node->parent;
if (node == NULL)
return(0);
if (step->value == NULL)
continue;
if (step->value[0] != node->name[0])
return(0);
if (!xmlStrEqual(step->value, node->name))
return(0);
if (node->ns == NULL) {
if (step->value2 != NULL)
return(0);
} else if (node->ns->href != NULL) {
if (step->value2 == NULL)
return(0);
if (!xmlStrEqual(step->value2, node->ns->href))
return(0);
}
continue;
case XML_OP_ANCESTOR:
if (step->value == NULL) {
i++;
step = &comp->steps[i];
if (step->op == XML_OP_ROOT)
return(1);
if (step->op != XML_OP_ELEM)
return(0);
if (step->value == NULL)
return(-1);
}
if (node == NULL)
return(0);
if ((node->type == XML_DOCUMENT_NODE) ||
(node->type == XML_HTML_DOCUMENT_NODE) ||
#ifdef LIBXML_DOCB_ENABLED
(node->type == XML_DOCB_DOCUMENT_NODE) ||
#endif
(node->type == XML_NAMESPACE_DECL))
return(0);
node = node->parent;
while (node != NULL) {
if (node == NULL)
return(0);
if ((node->type == XML_ELEMENT_NODE) &&
(step->value[0] == node->name[0]) &&
(xmlStrEqual(step->value, node->name))) {
if (node->ns == NULL) {
if (step->value2 == NULL)
break;
} else if (node->ns->href != NULL) {
if ((step->value2 != NULL) &&
(xmlStrEqual(step->value2, node->ns->href)))
break;
}
}
node = node->parent;
}
if (node == NULL)
return(0);
continue;
case XML_OP_NS:
if (node->type != XML_ELEMENT_NODE)
return(0);
if (node->ns == NULL) {
if (step->value != NULL)
return(0);
} else if (node->ns->href != NULL) {
if (step->value == NULL)
return(0);
if (!xmlStrEqual(step->value, node->ns->href))
return(0);
}
break;
case XML_OP_ALL:
if (node->type != XML_ELEMENT_NODE)
return(0);
break;
}
}
return(1);
}
#define TODO \
xmlGenericError(xmlGenericErrorContext, \
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
#define CUR (*ctxt->cur)
#define SKIP(val) ctxt->cur += (val)
#define NXT(val) ctxt->cur[(val)]
#define CUR_PTR ctxt->cur
#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) \
if (xmlPatternAdd(ctxt, ctxt->comp, (op), (val), (val2))) goto error;
#define XSLT_ERROR(X) \
{ xsltError(ctxt, __FILE__, __LINE__, X); \
ctxt->error = (X); return; }
#define XSLT_ERROR0(X) \
{ xsltError(ctxt, __FILE__, __LINE__, X); \
ctxt->error = (X); return(0); }
#if 0
static xmlChar *
xmlPatScanLiteral(xmlPatParserContextPtr ctxt) {
const xmlChar *q, *cur;
xmlChar *ret = NULL;
int val, len;
SKIP_BLANKS;
if (CUR == '"') {
NEXT;
cur = q = CUR_PTR;
val = xmlStringCurrentChar(NULL, cur, &len);
while ((IS_CHAR(val)) && (val != '"')) {
cur += len;
val = xmlStringCurrentChar(NULL, cur, &len);
}
if (!IS_CHAR(val)) {
ctxt->error = 1;
return(NULL);
} else {
ret = xmlStrndup(q, cur - q);
}
cur += len;
CUR_PTR = cur;
} else if (CUR == '\'') {
NEXT;
cur = q = CUR_PTR;
val = xmlStringCurrentChar(NULL, cur, &len);
while ((IS_CHAR(val)) && (val != '\'')) {
cur += len;
val = xmlStringCurrentChar(NULL, cur, &len);
}
if (!IS_CHAR(val)) {
ctxt->error = 1;
return(NULL);
} else {
ret = xmlStrndup(q, cur - q);
}
cur += len;
CUR_PTR = cur;
} else {
ctxt->error = 1;
return(NULL);
}
return(ret);
}
#endif
static xmlChar *
xmlPatScanName(xmlPatParserContextPtr ctxt) {
const xmlChar *q, *cur;
xmlChar *ret = NULL;
int val, len;
SKIP_BLANKS;
cur = q = CUR_PTR;
val = xmlStringCurrentChar(NULL, cur, &len);
if (!IS_LETTER(val) && (val != '_') && (val != ':'))
return(NULL);
while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
(val == '.') || (val == '-') ||
(val == '_') ||
(IS_COMBINING(val)) ||
(IS_EXTENDER(val))) {
cur += len;
val = xmlStringCurrentChar(NULL, cur, &len);
}
ret = xmlStrndup(q, cur - q);
CUR_PTR = cur;
return(ret);
}
static xmlChar *
xmlPatScanNCName(xmlPatParserContextPtr ctxt) {
const xmlChar *q, *cur;
xmlChar *ret = NULL;
int val, len;
SKIP_BLANKS;
cur = q = CUR_PTR;
val = xmlStringCurrentChar(NULL, cur, &len);
if (!IS_LETTER(val) && (val != '_'))
return(NULL);
while ((IS_LETTER(val)) || (IS_DIGIT(val)) ||
(val == '.') || (val == '-') ||
(val == '_') ||
(IS_COMBINING(val)) ||
(IS_EXTENDER(val))) {
cur += len;
val = xmlStringCurrentChar(NULL, cur, &len);
}
ret = xmlStrndup(q, cur - q);
CUR_PTR = cur;
return(ret);
}
#if 0
static xmlChar *
xmlPatScanQName(xmlPatParserContextPtr ctxt, xmlChar **prefix) {
xmlChar *ret = NULL;
*prefix = NULL;
ret = xmlPatScanNCName(ctxt);
if (CUR == ':') {
*prefix = ret;
NEXT;
ret = xmlPatScanNCName(ctxt);
}
return(ret);
}
#endif
static void
xmlCompileStepPattern(xmlPatParserContextPtr ctxt) {
xmlChar *token = NULL;
xmlChar *name = NULL;
const xmlChar *URI = NULL;
xmlChar *URL = NULL;
SKIP_BLANKS;
if (CUR == '.') {
NEXT;
PUSH(XML_OP_ELEM, NULL, NULL);
return;
}
name = xmlPatScanNCName(ctxt);
if (name == NULL) {
if (CUR == '*') {
NEXT;
PUSH(XML_OP_ALL, NULL, NULL);
return;
} else {
ERROR(NULL, NULL, NULL,
"xmlCompileStepPattern : Name expected\n");
ctxt->error = 1;
return;
}
}
SKIP_BLANKS;
if (CUR == ':') {
NEXT;
if (CUR != ':') {
xmlChar *prefix = name;
xmlNsPtr ns;
token = xmlPatScanName(ctxt);
ns = xmlSearchNs(NULL, ctxt->elem, prefix);
if (ns == NULL) {
ERROR5(NULL, NULL, NULL,
"xmlCompileStepPattern : no namespace bound to prefix %s\n",
prefix);
ctxt->error = 1;
goto error;
} else {
URL = xmlStrdup(ns->href);
}
xmlFree(prefix);
if (token == NULL) {
if (CUR == '*') {
NEXT;
PUSH(XML_OP_NS, URL, NULL);
} else {
ERROR(NULL, NULL, NULL,
"xmlCompileStepPattern : Name expected\n");
ctxt->error = 1;
goto error;
}
} else {
PUSH(XML_OP_ELEM, token, URL);
}
} else {
NEXT;
if (xmlStrEqual(token, (const xmlChar *) "child")) {
xmlFree(token);
token = xmlPatScanName(ctxt);
if (token == NULL) {
if (CUR == '*') {
NEXT;
PUSH(XML_OP_ALL, token, NULL);
return;
} else {
ERROR(NULL, NULL, NULL,
"xmlCompileStepPattern : QName expected\n");
ctxt->error = 1;
goto error;
}
}
TODO
if (token == NULL) {
ctxt->error = 1;
goto error;
} else {
name = xmlStrdup(token);
if (URI != NULL)
URL = xmlStrdup(URI);
}
PUSH(XML_OP_CHILD, name, URL);
} else if (xmlStrEqual(token, (const xmlChar *) "attribute")) {
xmlFree(token);
token = xmlPatScanName(ctxt);
if (token == NULL) {
ERROR(NULL, NULL, NULL,
"xmlCompileStepPattern : QName expected\n");
ctxt->error = 1;
goto error;
}
TODO
if (token == NULL) {
ctxt->error = 1;
goto error;
} else {
name = xmlStrdup(token);
if (URI != NULL)
URL = xmlStrdup(URI);
}
PUSH(XML_OP_ATTR, name, URL);
} else {
ERROR(NULL, NULL, NULL,
"xmlCompileStepPattern : 'child' or 'attribute' expected\n");
ctxt->error = 1;
goto error;
}
xmlFree(token);
}
} else if (CUR == '*') {
NEXT;
PUSH(XML_OP_ALL, token, NULL);
} else {
if (name == NULL) {
ctxt->error = 1;
goto error;
}
PUSH(XML_OP_ELEM, name, NULL);
}
return;
error:
if (token != NULL)
xmlFree(token);
if (name != NULL)
xmlFree(name);
}
static void
xmlCompilePathPattern(xmlPatParserContextPtr ctxt) {
SKIP_BLANKS;
if ((CUR == '/') && (NXT(1) == '/')) {
NEXT;
NEXT;
} else if ((CUR == '.') && (NXT(1) == '/') && (NXT(2) == '/')) {
NEXT;
NEXT;
NEXT;
}
if (CUR == '@') {
TODO
} else {
xmlCompileStepPattern(ctxt);
SKIP_BLANKS;
while (CUR == '/') {
if ((CUR == '/') && (NXT(1) == '/')) {
PUSH(XML_OP_ANCESTOR, NULL, NULL);
NEXT;
NEXT;
SKIP_BLANKS;
xmlCompileStepPattern(ctxt);
} else {
PUSH(XML_OP_PARENT, NULL, NULL);
NEXT;
SKIP_BLANKS;
if ((CUR != 0) || (CUR == '|')) {
xmlCompileStepPattern(ctxt);
}
}
}
}
error:
return;
}
xmlPatternPtr
xmlPatterncompile(const xmlChar *pattern, xmlDict *dict,
int flags ATTRIBUTE_UNUSED,
const xmlChar **namespaces) {
xmlPatternPtr ret = NULL;
xmlPatParserContextPtr ctxt = NULL;
ctxt = xmlNewPatParserContext(pattern, dict, namespaces);
if (ctxt == NULL) goto error;
ret = xmlNewPattern();
if (ret == NULL) goto error;
ctxt->comp = ret;
xmlCompilePathPattern(ctxt);
xmlFreePatParserContext(ctxt);
xmlReversePattern(ret);
return(ret);
error:
if (ctxt != NULL) xmlFreePatParserContext(ctxt);
if (ret != NULL) xmlFreePattern(ret);
return(NULL);
}
int
xmlPatternMatch(xmlPatternPtr comp, xmlNodePtr node)
{
if ((comp == NULL) || (node == NULL))
return(-1);
return(xmlPatMatch(comp, node));
}
#endif