![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: cf66e50)
raw | patch | inline | side by side (parent: cf66e50)
| author | ishmal <ishmal@users.sourceforge.net> | |
| Fri, 7 Jul 2006 01:26:05 +0000 (01:26 +0000) | ||
| committer | ishmal <ishmal@users.sourceforge.net> | |
| Fri, 7 Jul 2006 01:26:05 +0000 (01:26 +0000) |
diff --git a/src/dom/Makefile.mingw b/src/dom/Makefile.mingw
index e1842ec112951e072b8c7fb69b864937656a1822..58fdf1b5eacd1ee6aa85ee33514426bcfeff1c7b 100644 (file)
--- a/src/dom/Makefile.mingw
+++ b/src/dom/Makefile.mingw
# NATIVE COMPILER SETTINGS
##########################################################################
-CC = mingw32-gcc
-CXX = mingw32-g++
+CC = i686-pc-mingw32-gcc
+CXX = i686-pc-mingw32-g++
AS = as
AR = mingw32-ar
RANLIB = ranlib
io/socket.o \
odf/odfdocument.o \
svg/svgimpl.o \
-svg/svglsimpl.o \
svg/svgparser.o \
util/thread.o \
util/ziptool.o
index f0617795e7d19f44e74b44003651a23b9f1a75ce..2c7c85d83b23443aac7f83d2f43c79ac7774747d 100644 (file)
--- a/src/dom/xpathparser.cpp
+++ b/src/dom/xpathparser.cpp
//#########################################################################
-void XPathParser::tokAdd(Token *tok)
+void XPathParser::tokAdd(const Token &tok)
{
tokens.add(tok);
}
int p2 = getAbsoluteLocationPath(p, depth+1);
if (p2 > p)
{
- tokens.add(new TokAbsolute());
+ tokens.add(Token::create(Token::TOK_ABSOLUTE));
return p2;
}
p2 = getRelativeLocationPath(p, depth+1);
if (p2 > p)
{
- tokens.add(new TokRelative());
+ tokens.add(Token::create(Token::TOK_RELATIVE));
return p2;
}
{
p++;
// a '//' is an abbreviation for /descendant-or-self:node()/
- tokAdd(new TokAxisDescendantOrSelf());
+ tokAdd(Token::create(Token::TOK_AXIS_DESCENDANT_OR_SELF));
p2 = getRelativeLocationPath(p, depth+1);
if (p2 < 0)
{
switch (axisType)
{
case ANCESTOR_OR_SELF:
- tokAdd(new TokAxisAncestorOrSelf());
+ tokAdd(Token::create(Token::TOK_AXIS_ANCESTOR_OR_SELF));
case ANCESTOR:
- tokAdd(new TokAxisAncestor());
+ tokAdd(Token::create(Token::TOK_AXIS_ANCESTOR));
case ATTRIBUTE:
- tokAdd(new TokAxisAttribute());
+ tokAdd(Token::create(Token::TOK_AXIS_ATTRIBUTE));
case CHILD:
- tokAdd(new TokAxisChild());
+ tokAdd(Token::create(Token::TOK_AXIS_CHILD));
case DESCENDANT_OR_SELF:
- tokAdd(new TokAxisDescendantOrSelf());
+ tokAdd(Token::create(Token::TOK_AXIS_DESCENDANT_OR_SELF));
case DESCENDANT:
- tokAdd(new TokAxisDescendant());
+ tokAdd(Token::create(Token::TOK_AXIS_DESCENDANT));
case FOLLOWING_SIBLING:
- tokAdd(new TokAxisFollowingSibling());
+ tokAdd(Token::create(Token::TOK_AXIS_FOLLOWING_SIBLING));
case FOLLOWING:
- tokAdd(new TokAxisFollowing());
+ tokAdd(Token::create(Token::TOK_AXIS_FOLLOWING));
case NAMESPACE:
- tokAdd(new TokAxisNamespace());
+ tokAdd(Token::create(Token::TOK_AXIS_NAMESPACE));
case PARENT:
- tokAdd(new TokAxisParent());
+ tokAdd(Token::create(Token::TOK_AXIS_PARENT));
case PRECEDING_SIBLING:
- tokAdd(new TokAxisPrecedingSibling());
+ tokAdd(Token::create(Token::TOK_AXIS_PRECEDING_SIBLING));
case PRECEDING:
- tokAdd(new TokAxisPreceding());
+ tokAdd(Token::create(Token::TOK_AXIS_PRECEDING));
case SELF:
- tokAdd(new TokAxisSelf());
+ tokAdd(Token::create(Token::TOK_AXIS_SELF));
default:
{
error("unknown axis type %d", axisType);
if (t.getType() == NAME_TEST)
{
p++;
- tokAdd(new TokNameTest(t.getStringValue()));
+ tokAdd(Token::create(Token::TOK_NAME_TEST, t.getStringValue()));
return p;
}
if (t.getType() == NODE_TYPE)
if (lexTokType(p) == LITERAL)
{
- tokens.add(new TokStr(lexTok(p).getStringValue()));
+ tokens.add(Token::create(Token::TOK_STR,
+ lexTok(p).getStringValue()));
p++;
return p;
}
if (lexTokType(p) == NUMBER)
{
- tokens.add(new TokFloat(lexTok(p).getDoubleValue()));
+ tokens.add(Token::create(Token::TOK_FLOAT,
+ lexTok(p).getDoubleValue()));
p++;
return p;
}
// Function names from http://www.w3.org/TR/xpath#NT-FunctionName
if (name == "last")
- tokens.add(new TokFuncLast());
+ tokens.add(Token::create(Token::TOK_FUNC_LAST));
else if (name == "position")
- tokens.add(new TokFuncPosition());
+ tokens.add(Token::create(Token::TOK_FUNC_POSITION));
else if (name == "count")
- tokens.add(new TokFuncCount());
+ tokens.add(Token::create(Token::TOK_FUNC_COUNT));
else if (name == "id")
- tokens.add(new TokFuncId());
+ tokens.add(Token::create(Token::TOK_FUNC_ID));
else if (name == "local-name")
- tokens.add(new TokFuncLocalName());
+ tokens.add(Token::create(Token::TOK_FUNC_LOCAL_NAME));
else if (name == "namespace-uri")
- tokens.add(new TokFuncNamespaceUri());
+ tokens.add(Token::create(Token::TOK_FUNC_NAMESPACE_URI));
else if (name == "name")
- tokens.add(new TokFuncName());
+ tokens.add(Token::create(Token::TOK_FUNC_NAME));
else if (name == "string")
- tokens.add(new TokFuncString());
+ tokens.add(Token::create(Token::TOK_FUNC_STRING));
else if (name == "concat")
- tokens.add(new TokFuncConcat());
+ tokens.add(Token::create(Token::TOK_FUNC_CONCAT));
else if (name == "starts-with")
- tokens.add(new TokFuncStartsWith());
+ tokens.add(Token::create(Token::TOK_FUNC_STARTS_WITH));
else if (name == "contains")
- tokens.add(new TokFuncContains());
+ tokens.add(Token::create(Token::TOK_FUNC_CONTAINS));
else if (name == "substring-before")
- tokens.add(new TokFuncSubstringBefore());
+ tokens.add(Token::create(Token::TOK_FUNC_SUBSTRING_BEFORE));
else if (name == "substring-after")
- tokens.add(new TokFuncSubstringAfter());
+ tokens.add(Token::create(Token::TOK_FUNC_SUBSTRING_AFTER));
else if (name == "substring")
- tokens.add(new TokFuncSubstring());
+ tokens.add(Token::create(Token::TOK_FUNC_SUBSTRING));
else if (name == "string-length")
- tokens.add(new TokFuncStringLength());
+ tokens.add(Token::create(Token::TOK_FUNC_STRING_LENGTH));
else if (name == "normalize-space")
- tokens.add(new TokFuncNormalizeSpace());
+ tokens.add(Token::create(Token::TOK_FUNC_NORMALIZE_SPACE));
else if (name == "translate")
- tokens.add(new TokFuncTranslate());
+ tokens.add(Token::create(Token::TOK_FUNC_TRANSLATE));
else if (name == "boolean")
- tokens.add(new TokFuncBoolean());
+ tokens.add(Token::create(Token::TOK_FUNC_BOOLEAN));
else if (name == "not")
- tokens.add(new TokFuncNot());
+ tokens.add(Token::create(Token::TOK_FUNC_NOT));
else if (name == "true")
- tokens.add(new TokFuncTrue());
+ tokens.add(Token::create(Token::TOK_FUNC_TRUE));
else if (name == "false")
- tokens.add(new TokFuncFalse());
+ tokens.add(Token::create(Token::TOK_FUNC_FALSE));
else if (name == "lang")
- tokens.add(new TokFuncLang());
+ tokens.add(Token::create(Token::TOK_FUNC_LANG));
else if (name == "number")
- tokens.add(new TokFuncNumber());
+ tokens.add(Token::create(Token::TOK_FUNC_NUMBER));
else if (name == "sum")
- tokens.add(new TokFuncSum());
+ tokens.add(Token::create(Token::TOK_FUNC_SUM));
else if (name == "floor")
- tokens.add(new TokFuncFloor());
+ tokens.add(Token::create(Token::TOK_FUNC_FLOOR));
else if (name == "ceiling")
- tokens.add(new TokFuncCeiling());
+ tokens.add(Token::create(Token::TOK_FUNC_CEILING));
else if (name == "round")
- tokens.add(new TokFuncRound());
+ tokens.add(Token::create(Token::TOK_FUNC_ROUND));
else
{
error("unknown function name:'%s'", name.c_str());
error("OR (|) requires union expression on the left");
return -1;
}
- tokens.add(new TokUnion());
+ tokens.add(Token::create(Token::TOK_UNION));
p = p2;
}
return p;
p = p2;
return p;
}
- tokens.add(new TokOr());
+ tokens.add(Token::create(Token::TOK_OR));
return p;
}
p = p2;
return p;
}
- tokens.add(new TokAnd());
+ tokens.add(Token::create(Token::TOK_AND));
return p;
}
error("Equality expression expected after ==");
return -1;
}
- tokens.add(new TokEquals());
+ tokens.add(Token::create(Token::TOK_EQUALS));
p = p2;
return p;
}
error("Equality expression expected after !=");
return -1;
}
- tokens.add(new TokNotEquals());
+ tokens.add(Token::create(Token::TOK_NOT_EQUALS));
p = p2;
return p;
}
error("Relational expression after '>'");
return -1;
}
- tokens.add(new TokGreaterThan());
+ tokens.add(Token::create(Token::TOK_GREATER_THAN));
p = p2;
return p;
}
error("Relational expression after '<'");
return -1;
}
- tokens.add(new TokLessThan());
+ tokens.add(Token::create(Token::TOK_LESS_THAN));
p = p2;
return p;
}
error("Relational expression after '>='");
return -1;
}
- tokens.add(new TokGreaterThanEquals());
+ tokens.add(Token::create(Token::TOK_GREATER_THAN_EQUALS));
p = p2;
return p;
}
error("Relational expression after '<='");
return -1;
}
- tokens.add(new TokLessThanEquals());
+ tokens.add(Token::create(Token::TOK_LESS_THAN_EQUALS));
p = p2;
return p;
}
error("Additive expression after '+'");
return -1;
}
- tokens.add(new TokPlus());
+ tokens.add(Token::create(Token::TOK_PLUS));
p = p2;
return p;
}
error("Additive expression after '-'");
return -1;
}
- tokens.add(new TokMinus());
+ tokens.add(Token::create(Token::TOK_MINUS));
p = p2;
return p;
}
error("Multiplicative expression after '*'");
return -1;
}
- tokens.add(new TokMul());
+ tokens.add(Token::create(Token::TOK_MUL));
p = p2;
return p;
}
error("Multiplicative expression after 'div'");
return -1;
}
- tokens.add(new TokDiv());
+ tokens.add(Token::create(Token::TOK_DIV));
p = p2;
return p;
}
error("Multiplicative expression after 'mod'");
return -1;
}
- tokens.add(new TokMod());
+ tokens.add(Token::create(Token::TOK_MOD));
p = p2;
return p;
}
error("Unary expression after '-'");
return -1;
}
- tokens.add(new TokNeg());
+ tokens.add(Token::create(Token::TOK_NEG));
p = p2;
return p;
}
diff --git a/src/dom/xpathparser.h b/src/dom/xpathparser.h
index 25001016e64bfa4dae5c3a7e4f8907a75059b106..4bf19b72fc79fa92741bbadcc965b977338e119e 100644 (file)
--- a/src/dom/xpathparser.h
+++ b/src/dom/xpathparser.h
/**
* Add a newly derived token to the token list;
*/
- void tokAdd(Token *token);
+ void tokAdd(const Token &token);
/**
* The grammar definitions marked [1]-[39] are directly
diff --git a/src/dom/xpathtoken.cpp b/src/dom/xpathtoken.cpp
index 41b7ad39da5b94974c6fcafc9e1b8723a1398a14..cf51bf9ba9d384711ef7e650cc93a94e1848a12b 100644 (file)
--- a/src/dom/xpathtoken.cpp
+++ b/src/dom/xpathtoken.cpp
namespace xpath
{
+
+
//########################################################################
//# X P A T H T O K E N
//########################################################################
-typedef struct
+//########################################################################
+//# X P A T H T O K E N T Y P E S
+//########################################################################
+
+
+
+//###########################
+//# V A L U E S
+//###########################
+
+static bool tokStr(Token &tok, TokenExecutor &exec)
{
- int ival;
- char *sval;
-} TokenStringPair;
-
-static TokenStringPair tokenStrings[] =
-{
- //primitives
- { Token::TOK_NOP, "nop" },
- { Token::TOK_STR, "str" },
- { Token::TOK_INT, "int" },
- { Token::TOK_FLOAT, "float" },
- //operators
- { Token::TOK_AND, "and" },
- { Token::TOK_OR, "or" },
- { Token::TOK_MOD, "mod" },
- { Token::TOK_DIV, "div" },
- { Token::TOK_MULTIPLY, "multiply" },
- { Token::TOK_DOUBLE_SLASH, "double-slash" },
- { Token::TOK_SLASH, "slash" },
- { Token::TOK_PIPE, "pipe" },
- { Token::TOK_PLUS, "plus" },
- { Token::TOK_MINUS, "minus" },
- { Token::TOK_NEG, "neg" },
- { Token::TOK_EQUALS, "equals" },
- { Token::TOK_NOT_EQUALS, "not-equals" },
- { Token::TOK_LESS_THAN_EQUALS, "less-than-equals" },
- { Token::TOK_LESS_THAN, "less-than" },
- { Token::TOK_GREATER_THAN_EQUALS, "greater-than-equals" },
- { Token::TOK_GREATER_THAN, "greater-than" },
- //path types
- { Token::TOK_ABSOLUTE, "absolute" },
- { Token::TOK_RELATIVE, "relative" },
- { Token::TOK_STEP, "step" },
- { Token::TOK_NAME_TEST, "name-test" },
- { Token::TOK_EXPR, "expr" },
- { Token::TOK_UNION, "union" },
- //axis types
- { Token::TOK_AXIS_ANCESTOR_OR_SELF, "axis-ancestor-or-self" },
- { Token::TOK_AXIS_ANCESTOR, "axis-ancestor" },
- { Token::TOK_AXIS_ATTRIBUTE, "axis-attribute" },
- { Token::TOK_AXIS_CHILD, "axis-child" },
- { Token::TOK_AXIS_DESCENDANT_OR_SELF, "axis-descendant-or-self" },
- { Token::TOK_AXIS_DESCENDANT, "axis-descendant" },
- { Token::TOK_AXIS_FOLLOWING_SIBLING, "axis-following-sibling" },
- { Token::TOK_AXIS_FOLLOWING, "axis-following" },
- { Token::TOK_AXIS_NAMESPACE, "axis-namespace" },
- { Token::TOK_AXIS_PARENT, "axis-parent" },
- { Token::TOK_AXIS_PRECEDING_SIBLING, "axis-preceding-sibling" },
- { Token::TOK_AXIS_PRECEDING, "axis-preceding" },
- { Token::TOK_AXIS_SELF, "axis-self" },
- //function types
- { Token::TOK_FUNC_LAST, "func-last" },
- { Token::TOK_FUNC_POSITION, "func-position" },
- { Token::TOK_FUNC_COUNT, "func-count" },
- { Token::TOK_FUNC_ID, "func-id" },
- { Token::TOK_FUNC_LOCAL_NAME, "func-local-name" },
- { Token::TOK_FUNC_NAMESPACE_URI, "func-namespace-uri" },
- { Token::TOK_FUNC_NAME, "func-name" },
- { Token::TOK_FUNC_STRING, "func-string" },
- { Token::TOK_FUNC_CONCAT, "func-concat" },
- { Token::TOK_FUNC_STARTS_WITH, "func-starts-with" },
- { Token::TOK_FUNC_CONTAINS, "func-contains" },
- { Token::TOK_FUNC_SUBSTRING_BEFORE, "func-substring-before" },
- { Token::TOK_FUNC_SUBSTRING_AFTER, "func-substring-after" },
- { Token::TOK_FUNC_SUBSTRING, "func-substring" },
- { Token::TOK_FUNC_STRING_LENGTH, "func-string-length" },
- { Token::TOK_FUNC_NORMALIZE_SPACE, "func-normalize-space" },
- { Token::TOK_FUNC_TRANSLATE, "func-translate" },
- { Token::TOK_FUNC_BOOLEAN, "func-boolean" },
- { Token::TOK_FUNC_NOT, "func-not" },
- { Token::TOK_FUNC_TRUE, "func-true" },
- { Token::TOK_FUNC_FALSE, "func-false" },
- { Token::TOK_FUNC_LANG, "func-lang" },
- { Token::TOK_FUNC_NUMBER, "func-number" },
- { Token::TOK_FUNC_SUM, "func-sum" },
- { Token::TOK_FUNC_FLOOR, "func-floor" },
- { Token::TOK_FUNC_CEILING, "func-ceiling" },
- { Token::TOK_FUNC_ROUND, "func-round" },
- { -1, (char *)0 }
-};
+ StackItem item;
+ item.sval = tok.sval;
+ exec.push(item);
+ return true;
+}
+static bool tokFloat(Token &tok, TokenExecutor &exec)
+{
+ StackItem item;
+ item.dval = tok.dval;
+ exec.push(item);
+ return true;
+}
-/**
- * Return the string TokenType of this token
- * (in the .cpp file)
- */
-DOMString Token::getTypeString()
+static bool tokInt(Token &tok, TokenExecutor &exec)
{
- DOMString ret = "unknown";
- for (TokenStringPair *pair = tokenStrings ; pair->sval ; pair++)
- {
- if (pair->ival == type)
- {
- ret = pair->sval;
- break;
- }
- }
- return ret;
+ StackItem item;
+ item.ival = tok.ival;
+ exec.push(item);
+ return true;
}
+static bool tokAnd(Token &tok, TokenExecutor &exec)
+{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = item1.ival && item2.ival;
+ exec.push(item1);
+ return true;
+}
+static bool tokOr(Token &tok, TokenExecutor &exec)
+{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = item1.ival || item2.ival;
+ exec.push(item1);
+ return true;
+}
-//########################################################################
-//# X P A T H A X I S
-//########################################################################
+static bool tokMod(Token &tok, TokenExecutor &exec)
+{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.dval = fmod(item1.dval, item2.dval);
+ exec.push(item1);
+ return true;
+}
-/**
- *
- */
-Axis::Axis()
+
+static bool tokDiv(Token &tok, TokenExecutor &exec)
{
- init();
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.dval /= item2.dval;
+ exec.push(item1);
+ return true;
}
+static bool tokMul(Token &tok, TokenExecutor &exec)
+{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.dval *= item2.dval;
+ exec.push(item1);
+ return true;
+}
-/**
- *
- */
-Axis::Axis(int tokPos)
+static bool tokPlus(Token &tok, TokenExecutor &exec)
{
- init();
- tokenPosition = tokPos;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.dval += item2.dval;
+ exec.push(item1);
+ return true;
}
+static bool tokMinus(Token &tok, TokenExecutor &exec)
+{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.dval -= item2.dval;
+ exec.push(item1);
+ return true;
+}
-/**
- *
- */
-Axis::Axis(const Axis &other)
+
+static bool tokNeg(Token &tok, TokenExecutor &exec)
{
- init();
- assign(other);
+ StackItem item = exec.pop();
+ item.dval = -item.dval;
+ item.ival = -item.ival;
+ exec.push(item);
+ return true;
}
-/**
- *
- */
-Axis::~Axis()
+static bool tokEquals(Token &tok, TokenExecutor &exec)
{
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval == item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-Axis &Axis::operator=(const Axis &other)
+static bool tokNotEquals(Token &tok, TokenExecutor &exec)
{
- assign(other);
- return *this;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval != item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-void Axis::init()
+
+static bool tokLessThan(Token &tok, TokenExecutor &exec)
{
- tokenPosition = 0;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval < item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-void Axis::assign(const Axis &other)
+
+static bool tokLessThanEquals(Token &tok, TokenExecutor &exec)
{
- tokenPosition = other.tokenPosition;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval <= item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-void Axis::setPosition(unsigned int val)
+
+static bool tokGreaterThanEquals(Token &tok, TokenExecutor &exec)
{
- tokenPosition = val;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval >= item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-unsigned int Axis::getPosition()
+
+static bool tokGreaterThan(Token &tok, TokenExecutor &exec)
{
- return tokenPosition;
+ StackItem item1 = exec.pop();
+ StackItem item2 = exec.pop();
+ item1.ival = (item1.dval > item2.dval);
+ exec.push(item1);
+ return true;
}
-/**
- *
- */
-void Axis::setNode(const Node *val)
+
+
+
+
+
+//###########################
+//# X P A T H I T E M S
+//###########################
+
+static bool tokAbsolute(Token &tok, TokenExecutor &exec)
{
- node = (Node *)val;
+ return true;
}
-/**
- *
- */
-Node *Axis::getNode()
+static bool tokRelative(Token &tok, TokenExecutor &exec)
{
- return node;
+ return true;
}
-//########################################################################
-//# X P A T H S T A C K I T E M
-//########################################################################
+static bool tokStep(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
-/**
- *
- */
-StackItem::StackItem()
+static bool tokNameTest(Token &tok, TokenExecutor &exec)
{
- ival = 0L;
- dval = 0.0;
+ return true;
}
+static bool tokExpr(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
-/**
- *
- */
-StackItem::StackItem(const StackItem &other)
+static bool tokUnion(Token &tok, TokenExecutor &exec)
{
- assign(other);
+ return true;
}
-/**
- *
- */
-StackItem::~StackItem()
+
+
+//###########################
+//# A X I S
+//###########################
+
+
+static bool tokAxisAncestorOrSelf(Token &tok, TokenExecutor &exec)
{
+ return true;
}
-/**
- *
- */
-StackItem &StackItem::operator=(const StackItem &other)
+static bool tokAxisAncestor(Token &tok, TokenExecutor &exec)
{
- assign(other);
- return *this;
+ return true;
}
-/**
- *
- */
-void StackItem::assign(const StackItem &other)
+
+static bool tokAxisAttribute(Token &tok, TokenExecutor &exec)
{
- sval = other.sval;
- ival = other.ival;
- dval = other.dval;
+ return true;
}
-//########################################################################
-//# T O K E N L I S T
-//########################################################################
+static bool tokAxisChild(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
-/**
- *
- */
-TokenList::TokenList()
+
+static bool tokAxisDescendantOrSelf(Token &tok, TokenExecutor &exec)
{
+ return true;
}
-/**
- *
- */
-TokenList::TokenList(const TokenList &other)
+static bool tokAxisDescendant(Token &tok, TokenExecutor &exec)
{
- assign(other);
+ return true;
}
-/**
- *
- */
-TokenList &TokenList::operator=(const TokenList &other)
+
+static bool tokAxisFollowingSibling(Token &tok, TokenExecutor &exec)
{
- assign(other);
- return *this;
+ return true;
}
-/**
- *
- */
-void TokenList::assign(const TokenList &other)
+
+static bool tokAxisFollowing(Token &tok, TokenExecutor &exec)
{
- tokens = other.tokens;
+ return true;
}
-/**
- *
- */
-TokenList::~TokenList()
+
+static bool tokAxisNamespace(Token &tok, TokenExecutor &exec)
{
- clear();
+ return true;
}
-/**
- *
- */
-void TokenList::clear()
+
+static bool tokAxisParent(Token &tok, TokenExecutor &exec)
{
- std::vector<Token *>::iterator iter;
- for (iter = tokens.begin() ; iter!= tokens.end() ; iter++)
- {
- delete (*iter);
- }
- tokens.clear();
+ return true;
}
-/**
- *
- */
-void TokenList::add(Token *tok)
+
+static bool tokAxisPrecedingSibling(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokAxisPreceding(Token &tok, TokenExecutor &exec)
{
- tokens.push_back(tok);
+ return true;
}
+static bool tokAxisSelf(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+
+//###########################
+//# F U N C T I O N S
+//###########################
+
+
+static bool tokFuncLast(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncPosition(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncCount(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncId(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncLocalName(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncNamespaceUri(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncName(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncString(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncConcat(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncStartsWith(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncContains(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncSubstringBefore(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncSubstringAfter(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncSubstring(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncStringLength(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncNormalizeSpace(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncTranslate(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncBoolean(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncNot(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncTrue(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncFalse(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncLang(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncNumber(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncSum(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncFloor(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncCeiling(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+static bool tokFuncRound(Token &tok, TokenExecutor &exec)
+{
+ return true;
+}
+
+
+
+
+
+typedef struct
+{
+ int ival;
+ char *sval;
+ TokenFunc tokenFunc;
+} TokenTableEntry;
+
+static TokenTableEntry tokenTable[] =
+{
+ //### primitives
+ {
+ Token::TOK_NOP,
+ "nop",
+ NULL
+ },
+ {
+ Token::TOK_STR,
+ "str",
+ tokStr
+ },
+ {
+ Token::TOK_INT,
+ "int",
+ tokInt
+ },
+ {
+ Token::TOK_FLOAT,
+ "float",
+ tokFloat
+ },
+
+ //### operators
+ {
+ Token::TOK_AND,
+ "and",
+ tokAnd
+ },
+ {
+ Token::TOK_OR,
+ "or",
+ tokOr
+ },
+ {
+ Token::TOK_MOD,
+ "mod",
+ tokMod
+ },
+ {
+ Token::TOK_DIV,
+ "div",
+ tokDiv
+ },
+ {
+ Token::TOK_MUL,
+ "multiply",
+ tokMul
+ },
+ {
+ Token::TOK_DOUBLE_SLASH,
+ "double-slash",
+ NULL
+ },
+ {
+ Token::TOK_SLASH,
+ "slash",
+ NULL
+ },
+ {
+ Token::TOK_PIPE,
+ "pipe",
+ NULL
+ },
+ {
+ Token::TOK_PLUS,
+ "plus",
+ tokPlus
+ },
+ {
+ Token::TOK_MINUS,
+ "minus",
+ tokMinus
+ },
+ {
+ Token::TOK_NEG,
+ "neg",
+ tokNeg
+ },
+ {
+ Token::TOK_EQUALS,
+ "equals",
+ tokEquals
+ },
+ {
+ Token::TOK_NOT_EQUALS,
+ "not-equals",
+ tokNotEquals
+ },
+ {
+ Token::TOK_LESS_THAN_EQUALS,
+ "less-than-equals",
+ tokLessThanEquals
+ },
+ {
+ Token::TOK_LESS_THAN,
+ "less-than",
+ tokLessThan
+ },
+ {
+ Token::TOK_GREATER_THAN_EQUALS,
+ "greater-than-equals",
+ tokGreaterThanEquals
+ },
+ {
+ Token::TOK_GREATER_THAN,
+ "greater-than",
+ tokGreaterThan
+ },
+
+ //### path types
+ {
+ Token::TOK_ABSOLUTE,
+ "absolute",
+ tokAbsolute
+ },
+ {
+ Token::TOK_RELATIVE,
+ "relative",
+ tokRelative
+ },
+ {
+ Token::TOK_STEP,
+ "step",
+ tokStep
+ },
+ {
+ Token::TOK_NAME_TEST,
+ "name-test",
+ tokNameTest
+ },
+ {
+ Token::TOK_EXPR,
+ "expr",
+ tokExpr
+ },
+ {
+ Token::TOK_UNION,
+ "union",
+ tokUnion
+ },
+
+ //### axis types
+ {
+ Token::TOK_AXIS_ANCESTOR_OR_SELF,
+ "axis-ancestor-or-self",
+ tokAxisAncestorOrSelf
+ },
+ {
+ Token::TOK_AXIS_ANCESTOR,
+ "axis-ancestor",
+ tokAxisAncestor
+ },
+ {
+ Token::TOK_AXIS_ATTRIBUTE,
+ "axis-attribute",
+ tokAxisAttribute
+ },
+ {
+ Token::TOK_AXIS_CHILD,
+ "axis-child",
+ tokAxisChild
+ },
+ {
+ Token::TOK_AXIS_DESCENDANT_OR_SELF,
+ "axis-descendant-or-self",
+ tokAxisDescendantOrSelf
+ },
+ {
+ Token::TOK_AXIS_DESCENDANT,
+ "axis-descendant",
+ tokAxisDescendant
+ },
+ {
+ Token::TOK_AXIS_FOLLOWING_SIBLING,
+ "axis-following-sibling",
+ tokAxisFollowingSibling
+ },
+ {
+ Token::TOK_AXIS_FOLLOWING,
+ "axis-following",
+ tokAxisFollowing
+ },
+ {
+ Token::TOK_AXIS_NAMESPACE,
+ "axis-namespace",
+ tokAxisNamespace
+ },
+ {
+ Token::TOK_AXIS_PARENT,
+ "axis-parent",
+ tokAxisParent
+ },
+ {
+ Token::TOK_AXIS_PRECEDING_SIBLING,
+ "axis-preceding-sibling",
+ tokAxisPrecedingSibling
+ },
+ {
+ Token::TOK_AXIS_PRECEDING,
+ "axis-preceding",
+ tokAxisPreceding
+ },
+ {
+ Token::TOK_AXIS_SELF,
+ "axis-self",
+ tokAxisSelf
+ },
+
+ //### function types
+ {
+ Token::TOK_FUNC_LAST,
+ "func-last",
+ tokFuncLast
+ },
+ {
+ Token::TOK_FUNC_POSITION,
+ "func-position",
+ tokFuncPosition
+ },
+ {
+ Token::TOK_FUNC_COUNT,
+ "func-count",
+ tokFuncCount
+ },
+ {
+ Token::TOK_FUNC_ID,
+ "func-id",
+ tokFuncId
+ },
+ {
+ Token::TOK_FUNC_LOCAL_NAME,
+ "func-local-name",
+ tokFuncLocalName
+ },
+ {
+ Token::TOK_FUNC_NAMESPACE_URI,
+ "func-namespace-uri",
+ tokFuncNamespaceUri
+ },
+ {
+ Token::TOK_FUNC_NAME,
+ "func-name",
+ tokFuncName
+ },
+ {
+ Token::TOK_FUNC_STRING,
+ "func-string",
+ tokFuncString
+ },
+ {
+ Token::TOK_FUNC_CONCAT,
+ "func-concat",
+ tokFuncConcat
+ },
+ {
+ Token::TOK_FUNC_STARTS_WITH,
+ "func-starts-with",
+ tokFuncStartsWith
+ },
+ {
+ Token::TOK_FUNC_CONTAINS,
+ "func-contains",
+ tokFuncContains
+ },
+ {
+ Token::TOK_FUNC_SUBSTRING_BEFORE,
+ "func-substring-before",
+ tokFuncSubstringBefore
+ },
+ {
+ Token::TOK_FUNC_SUBSTRING_AFTER,
+ "func-substring-after",
+ tokFuncSubstringAfter
+ },
+ {
+ Token::TOK_FUNC_SUBSTRING,
+ "func-substring",
+ tokFuncSubstring
+ },
+ {
+ Token::TOK_FUNC_STRING_LENGTH,
+ "func-string-length",
+ tokFuncStringLength
+ },
+ {
+ Token::TOK_FUNC_NORMALIZE_SPACE,
+ "func-normalize-space",
+ tokFuncNormalizeSpace
+ },
+ {
+ Token::TOK_FUNC_TRANSLATE,
+ "func-translate",
+ tokFuncTranslate
+ },
+ {
+ Token::TOK_FUNC_BOOLEAN,
+ "func-boolean",
+ tokFuncBoolean
+ },
+ {
+ Token::TOK_FUNC_NOT,
+ "func-not",
+ tokFuncNot
+ },
+ {
+ Token::TOK_FUNC_TRUE,
+ "func-true",
+ tokFuncTrue
+ },
+ {
+ Token::TOK_FUNC_FALSE,
+ "func-false",
+ tokFuncFalse
+ },
+ {
+ Token::TOK_FUNC_LANG,
+ "func-lang",
+ tokFuncLang
+ },
+ {
+ Token::TOK_FUNC_NUMBER,
+ "func-number",
+ tokFuncNumber
+ },
+ {
+ Token::TOK_FUNC_SUM,
+ "func-sum",
+ tokFuncSum
+ },
+ {
+ Token::TOK_FUNC_FLOOR,
+ "func-floor",
+ tokFuncFloor
+ },
+ {
+ Token::TOK_FUNC_CEILING,
+ "func-ceiling",
+ tokFuncCeiling
+ },
+ {
+ Token::TOK_FUNC_ROUND,
+ "func-round",
+ tokFuncRound
+ },
+
+ { -1,
+ (char *)0,
+ NULL
+ }
+};
+
+
/**
- *
+ * Return the string TokenType of this token
+ * (in the .cpp file)
*/
-unsigned int TokenList::size() const
+DOMString Token::getTypeString()
{
- return (unsigned int)tokens.size();
+ DOMString ret = "unknown";
+ for (TokenTableEntry *entry = tokenTable ; entry->sval ; entry++)
+ {
+ if (entry->ival == type)
+ {
+ ret = entry->sval;
+ break;
+ }
+ }
+ return ret;
}
/**
- *
+ * Create a token of the given type, giving it
+ * the data and personalities it needs
*/
-void TokenList::dump()
+Token Token::create(int type, long ival,
+ double dval, const DOMString &sval)
{
- std::vector<Token *>::iterator iter;
- printf("############# TOKENS\n");
- for (iter = tokens.begin() ; iter != tokens.end() ; iter++)
+ Token tok(type, ival, dval, sval);
+ for (TokenTableEntry *entry = tokenTable ; entry->sval ; entry++)
{
- Token *tok = *iter;
- tok->dump();
+ if (entry->ival == type)
+ {
+ tok.tokenFunc = entry->tokenFunc;
+ break;
+ }
}
+
+ return tok;
}
+
+
+
+
+
+
//########################################################################
//# X P A T H E X E C U T O R
//########################################################################
*/
void TokenExecutor::assign(const TokenExecutor &other)
{
- axis = other.axis;
- axisStack = other.axisStack;
- stackSize = other.stackSize;
- for (int i=0 ; i<stackSize ; i++)
- stack[i] = other.stack[i];
+ tokenList = other.tokenList;
+ stack = other.stack;
}
*/
void TokenExecutor::reset()
{
- axis.setPosition(0);
- axis.setNode(NULL);
- stackSize = 0;
+ stack.clear();
}
NodeList TokenExecutor::execute(const TokenList &tokens, const Node *node)
{
- axis.setPosition(0);
- axis.setNode(node);
-
nodeList.clear();
- while (axis.getPosition() < tokens.size())
- {
- }
-
return nodeList;
}
*/
void TokenExecutor::push(StackItem &item)
{
- if (stackSize>=STACK_SIZE)
- {
- return;
- }
- stack[stackSize++] = item;
+ stack.push_back(item);
}
/**
*/
StackItem TokenExecutor::pop()
{
- if (stackSize<1)
+ if (stack.size()<1)
{
StackItem item;
return item;
}
- return stack[--stackSize];
+ std::vector<StackItem>::iterator iter = stack.end()-1;
+ StackItem item = *iter;
+ stack.erase(iter);
+ return item;
}
diff --git a/src/dom/xpathtoken.h b/src/dom/xpathtoken.h
index 6c44e639d7f8f155db97402c82ecd80456bf2ea6..26aee60f82f040f6be7aca23b945b62fc571169a 100644 (file)
--- a/src/dom/xpathtoken.h
+++ b/src/dom/xpathtoken.h
typedef org::w3c::dom::DOMString DOMString;
-class Axis
-{
-public:
- /**
- * Constructor
- */
- Axis();
-
- /**
- * Constructor
- */
- Axis(int tokPos);
-
- /**
- * Copy constructor
- */
- Axis(const Axis &other);
-
- /**
- * Destructor
- */
- virtual ~Axis();
-
- /**
- *
- */
- Axis &operator=(const Axis &other);
-
- /**
- *
- */
- void init();
-
- /**
- *
- */
- void assign(const Axis &other);
-
- /**
- *
- */
- void setPosition(unsigned int val);
-
- /**
- *
- */
- unsigned int getPosition();
-
- /**
- *
- */
- void setNode(const Node *node);
-
- /**
- *
- */
- Node *getNode();
-private:
+class TokenExecutor;
- int tokenPosition;
- Node *node;
-};
+//########################################################################
+//# S T A C K I T E M
+//########################################################################
/**
/**
* Constructor
*/
- StackItem();
+ StackItem()
+ { init(); }
/**
* Copy constructor
*/
- StackItem(const StackItem &other);
+ StackItem(const StackItem &other)
+ { assign(other); }
/**
* Destructor
*/
- virtual ~StackItem();
-
- /**
- *
- */
- StackItem &operator=(const StackItem &other);
+ virtual ~StackItem()
+ {}
/**
*
*/
- void assign(const StackItem &other);
-
+ StackItem &operator=(const StackItem &other)
+ { assign(other); return *this; }
//treat the stack item like an union of string, integer, and double
*/
double dval;
-};
-
-class TokenList;
-
-//########################################################################
-//# T O K E N E X E C U T O R
-//########################################################################
-
-#define STACK_SIZE 1024
-
-/**
- * A token evaluator, with stack and axis context
- */
-class TokenExecutor
-{
-public:
-
- /**
- * Constructor
- */
- TokenExecutor();
-
- /**
- * Copy constructor
- */
- TokenExecutor(const TokenExecutor &other);
-
- /**
- * Destructor
- */
- virtual ~TokenExecutor();
-
- /**
- * Assign our values to those of the other
- */
- virtual void assign(const TokenExecutor &other);
-
- /**
- * Reset the stack to its original settings
- */
- virtual void reset();
-
- /**
- * Push a stack item onto the stack
- */
- virtual void push(StackItem &item);
-
- /**
- * Pop a stack item from the stack
- */
- virtual StackItem pop();
-
- /**
- * Execute a token list on the stack
- */
- NodeList execute(const TokenList &list, const Node *node);
-
- /**
- *
- */
- Axis axis;
-
- /**
- *
- */
- std::vector<Axis> axisStack;
private:
- /**
- * Contains the StackItem stack;
- */
- StackItem stack[STACK_SIZE];
+ void init()
+ {
+ sval = "";
+ ival = 0;
+ dval = 0.0;
+ }
- /**
- * Marks the head of the stack, for push() and pop()
- */
- int stackSize;
+ void assign(const StackItem &other)
+ {
+ sval = other.sval;
+ ival = other.ival;
+ dval = other.dval;
+ }
- /**
- * Current list of nodes found by the expression
- */
- NodeList nodeList;
+};
-};
+/**
+ * Contains the StackItem stack;
+ */
+typedef std::vector<StackItem> Stack;
//########################################################################
//# X P A T H T O K E N
//########################################################################
+class Token;
+class TokenExecutor;
+
+typedef bool (*TokenFunc)(Token &tok, TokenExecutor &exec);
/**
TOK_OR,
TOK_MOD,
TOK_DIV,
- TOK_MULTIPLY,
+ TOK_MUL,
TOK_DOUBLE_SLASH,
TOK_SLASH,
TOK_PIPE,
* Constructor with a NOP default type
*/
Token()
- {
- type = TOK_NOP;
- ival = 0L;
- dval = 0.0;
+ { init(); }
+
+ /**
+ * Constructor with a NOP default type
+ */
+ Token(int typeArg)
+ { init(); type = typeArg; }
+
+ /**
+ * Constructor with a NOP default type
+ */
+ Token(int typeArg,
+ long ivalArg, double dvalArg, const DOMString &svalArg)
+ {
+ init();
+ type = typeArg,
+ ival = ivalArg;
+ dval = dvalArg;
+ sval = svalArg;
}
/**
* Copy constructor
*/
Token(const Token &other)
- {
- type = other.type;
- sval = other.sval;
- ival = other.ival;
- dval = other.dval;
- }
+ { assign(other); }
+
+ /**
+ * Assignment
+ */
+ Token &operator=(const Token &other)
+ { assign(other); return *this; }
/**
* Destructor
* Let this token execute itself on the given stack,
* possibly adding Nodes to the node list.
*/
- virtual bool execute(TokenExecutor &stack)
- { return true; }
+ virtual bool execute(TokenExecutor &exec)
+ {
+ if (tokenFunc)
+ return tokenFunc(*this, exec);
+ return false;
+ }
/**
* Print the contents of this token
*/
double dval;
-protected:
+ /**
+ *
+ */
+ static Token create(int type, long ival,
+ double dval, const DOMString &sval);
/**
- * The enmerated token type
+ *
*/
- int type;
+ static Token create(int type)
+ { return create(type, 0, 0.0, ""); }
+
+ /**
+ *
+ */
+ static Token create(int type, long val)
+ { return create(type, val, 0.0, ""); }
+ /**
+ *
+ */
+ static Token create(int type, double val)
+ { return create(type, 0, val, ""); }
-private:
+ /**
+ *
+ */
+ static Token create(int type, const DOMString &val)
+ { return create(type, 0, 0.0, val); }
-};
+protected:
-//########################################################################
-//# X P A T H T O K E N T Y P E S
-//########################################################################
+ /**
+ * The enmerated token type
+ */
+ int type;
+ /**
+ * The function that defines the behaviour of this token
+ */
+ TokenFunc tokenFunc;
-//###########################
-//# V A L U E S
-//###########################
+private:
-class TokStr : public Token
-{
-public:
- TokStr(const DOMString &val)
+ void init()
{
- type = TOK_STR;
- sval = val;
+ tokenFunc = NULL;
+ type = TOK_NOP;
+ ival = 0L;
+ dval = 0.0;
}
- virtual bool execute(TokenExecutor &exec)
+
+ void assign(const Token &other)
{
- StackItem item;
- item.sval = sval;
- exec.push(item);
- return true;
+ tokenFunc = other.tokenFunc;
+ type = other.type;
+ sval = other.sval;
+ ival = other.ival;
+ dval = other.dval;
}
+
+
};
-class TokFloat : public Token
+
+//########################################################################
+//# C O N T E X T
+//########################################################################
+
+/**
+ *
+ */
+class Context
{
public:
- TokFloat(double val)
- {
- type = TOK_FLOAT;
- dval = val;
- }
- virtual bool execute(TokenExecutor &exec)
+
+ //# From 2.3, principal type of child axes
+ typedef enum
{
- StackItem item;
- item.dval = dval;
- exec.push(item);
- return true;
- }
-};
+ AXIS_ATTRIBUTE,
+ AXIS_NAMESPACE,
+ AXIS_ELEMENT
+ } PrincipalNodeType;
-class TokInt : public Token
-{
-public:
- TokInt(long val)
+ /**
+ * Constructor
+ */
+ Context()
+ { init(); }
+
+ /**
+ * Constructor
+ */
+ Context(int principalNodeTypeArg)
+ { init(); principalNodeType = principalNodeTypeArg; }
+
+ /**
+ * Copy constructor
+ */
+ Context(const Context &other)
+ { assign(other); }
+
+ /**
+ * Destructor
+ */
+ virtual ~Context()
+ {}
+
+ /**
+ *
+ */
+ Context &operator=(const Context &other)
+ { assign(other); return *this; }
+
+ /**
+ *
+ */
+ std::vector<Token> &getTokens()
+ { return tokens; }
+
+ /**
+ *
+ */
+ void setTokens(const std::vector<Token> &tokensArg)
+ { tokens = tokensArg; }
+
+ /**
+ *
+ */
+ void add(const Token &token)
+ { tokens.push_back(token); }
+
+ /**
+ *
+ */
+ virtual void dump()
{
- type = TOK_INT;
- ival = val;
+ for (unsigned int i=0 ; i<tokens.size() ; i++)
+ {
+ Token token = tokens[i];
+ token.dump();
+ }
}
- virtual bool execute(TokenExecutor &exec)
+
+ /**
+ *
+ */
+ virtual void clear()
{
- StackItem item;
- item.ival = ival;
- exec.push(item);
- return true;
+ tokens.clear();
}
-};
-class TokAnd : public Token
-{
-public:
- TokAnd()
+private:
+
+ void init()
{
- type = TOK_AND;
+ principalNodeType = AXIS_ELEMENT;
}
- virtual bool execute(TokenExecutor &exec)
+
+ void assign(const Context &other)
{
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = item1.ival && item2.ival;
- exec.push(item1);
- return true;
+ principalNodeType = other.principalNodeType;
+ tokens = other.tokens;
}
+
+ int principalNodeType;
+
+ std::vector<Token> tokens;
+
};
-class TokOr : public Token
-{
-public:
- TokOr()
- {
- type = TOK_OR;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = item1.ival || item2.ival;
- exec.push(item1);
- return true;
- }
-};
-
-class TokMod : public Token
-{
-public:
- TokMod()
- {
- type = TOK_MOD;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.dval = fmod(item1.dval, item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokDiv : public Token
-{
-public:
- TokDiv()
- {
- type = TOK_DIV;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.dval /= item2.dval;
- exec.push(item1);
- return true;
- }
-};
-
-class TokMul : public Token
-{
-public:
- TokMul()
- {
- type = TOK_MULTIPLY;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.dval *= item2.dval;
- exec.push(item1);
- return true;
- }
-};
-
-class TokPlus : public Token
-{
-public:
- TokPlus()
- {
- type = TOK_PLUS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.dval += item2.dval;
- exec.push(item1);
- return true;
- }
-};
-
-class TokMinus : public Token
-{
-public:
- TokMinus()
- {
- type = TOK_MINUS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.dval -= item2.dval;
- exec.push(item1);
- return true;
- }
-};
-
-class TokNeg : public Token
-{
-public:
- TokNeg()
- {
- type = TOK_NEG;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item = exec.pop();
- item.dval = -item.dval;
- item.ival = -item.ival;
- exec.push(item);
- return true;
- }
-};
-
-class TokEquals : public Token
-{
-public:
- TokEquals()
- {
- type = TOK_EQUALS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval == item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokNotEquals : public Token
-{
-public:
- TokNotEquals()
- {
- type = TOK_NOT_EQUALS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval != item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokLessThanEquals : public Token
-{
-public:
- TokLessThanEquals()
- {
- type = TOK_LESS_THAN_EQUALS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval <= item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokLessThan : public Token
-{
-public:
- TokLessThan()
- {
- type = TOK_LESS_THAN;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval < item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokGreaterThanEquals : public Token
-{
-public:
- TokGreaterThanEquals()
- {
- type = TOK_GREATER_THAN_EQUALS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval >= item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-class TokGreaterThan : public Token
-{
-public:
- TokGreaterThan()
- {
- type = TOK_GREATER_THAN;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- StackItem item1 = exec.pop();
- StackItem item2 = exec.pop();
- item1.ival = (item1.dval > item2.dval);
- exec.push(item1);
- return true;
- }
-};
-
-
-//###########################
-//# X P A T H I T E M S
-//###########################
-
-class TokAbsolute : public Token
-{
-public:
- TokAbsolute()
- {
- type = TOK_ABSOLUTE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- Node *n = exec.axis.getNode();
- while (n->getParentNode())
- n = n->getParentNode();
- exec.axis.setNode(n);
- return true;
- }
-};
-
-class TokRelative : public Token
-{
-public:
- TokRelative()
- {
- type = TOK_RELATIVE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- ///exec.axis.currentNode = stack.rootNode;
- return true;
- }
-};
-
-class TokStep : public Token
-{
-public:
- TokStep()
- {
- type = TOK_STEP;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokNameTest : public Token
-{
-public:
- TokNameTest(const DOMString &name)
- {
- type = TOK_NAME_TEST;
- sval = name;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokExpr : public Token
-{
-public:
- TokExpr()
- {
- type = TOK_EXPR;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokUnion : public Token
-{
-public:
- TokUnion()
- {
- type = TOK_UNION;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-
-
-
-//###########################
-//# A X I S
-//###########################
-
-
-class TokAxisAncestorOrSelf : public Token
-{
-public:
- TokAxisAncestorOrSelf()
- {
- type = TOK_AXIS_ANCESTOR_OR_SELF;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisAncestor : public Token
-{
-public:
- TokAxisAncestor()
- {
- type = TOK_AXIS_ANCESTOR;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisAttribute : public Token
-{
-public:
- TokAxisAttribute()
- {
- type = TOK_AXIS_ATTRIBUTE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisChild : public Token
-{
-public:
- TokAxisChild()
- {
- type = TOK_AXIS_CHILD;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisDescendantOrSelf : public Token
-{
-public:
- TokAxisDescendantOrSelf()
- {
- type = TOK_AXIS_DESCENDANT_OR_SELF;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisDescendant : public Token
-{
-public:
- TokAxisDescendant()
- {
- type = TOK_AXIS_DESCENDANT;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisFollowingSibling : public Token
-{
-public:
- TokAxisFollowingSibling()
- {
- type = TOK_AXIS_FOLLOWING_SIBLING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisFollowing : public Token
-{
-public:
- TokAxisFollowing()
- {
- type = TOK_AXIS_FOLLOWING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisNamespace : public Token
-{
-public:
- TokAxisNamespace()
- {
- type = TOK_AXIS_NAMESPACE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisParent : public Token
-{
-public:
- TokAxisParent()
- {
- type = TOK_AXIS_PARENT;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisPrecedingSibling : public Token
-{
-public:
- TokAxisPrecedingSibling()
- {
- type = TOK_AXIS_PRECEDING_SIBLING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisPreceding : public Token
-{
-public:
- TokAxisPreceding()
- {
- type = TOK_AXIS_PRECEDING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokAxisSelf : public Token
-{
-public:
- TokAxisSelf()
- {
- type = TOK_AXIS_SELF;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-
-
-//###########################
-//# F U N C T I O N S
-//###########################
-
-class TokFuncLast : public Token
-{
-public:
- TokFuncLast()
- {
- type = TOK_FUNC_LAST;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncPosition : public Token
-{
-public:
- TokFuncPosition()
- {
- type = TOK_FUNC_POSITION;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncCount : public Token
-{
-public:
- TokFuncCount()
- {
- type = TOK_FUNC_COUNT;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncId : public Token
-{
-public:
- TokFuncId()
- {
- type = TOK_FUNC_ID;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncLocalName : public Token
-{
-public:
- TokFuncLocalName()
- {
- type = TOK_FUNC_LOCAL_NAME;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncNamespaceUri : public Token
-{
-public:
- TokFuncNamespaceUri()
- {
- type = TOK_FUNC_NAMESPACE_URI;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncName : public Token
-{
-public:
- TokFuncName()
- {
- type = TOK_FUNC_NAME;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncString : public Token
-{
-public:
- TokFuncString()
- {
- type = TOK_FUNC_STRING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-
-class TokFuncConcat : public Token
-{
-public:
- TokFuncConcat()
- {
- type = TOK_FUNC_CONCAT;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-class TokFuncStartsWith : public Token
-{
-public:
- TokFuncStartsWith()
- {
- type = TOK_FUNC_STARTS_WITH;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+//########################################################################
+//# T O K E N L I S T
+//########################################################################
-class TokFuncContains : public Token
+/**
+ *
+ */
+class TokenList
{
public:
- TokFuncContains()
- {
- type = TOK_FUNC_CONTAINS;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-class TokFuncSubstringBefore : public Token
-{
-public:
- TokFuncSubstringBefore()
- {
- type = TOK_FUNC_SUBSTRING_BEFORE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ TokenList()
+ { init(); }
-class TokFuncSubstringAfter : public Token
-{
-public:
- TokFuncSubstringAfter()
- {
- type = TOK_FUNC_SUBSTRING_AFTER;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ TokenList(const TokenList &other)
+ { assign(other); }
-class TokFuncSubstring : public Token
-{
-public:
- TokFuncSubstring()
- {
- type = TOK_FUNC_SUBSTRING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ TokenList &operator=(const TokenList &other)
+ { assign(other); return *this; }
-class TokFuncStringLength : public Token
-{
-public:
- TokFuncStringLength()
- {
- type = TOK_FUNC_STRING_LENGTH;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ virtual ~TokenList()
+ { }
-class TokFuncNormalizeSpace : public Token
-{
-public:
- TokFuncNormalizeSpace()
- {
- type = TOK_FUNC_NORMALIZE_SPACE;
- }
- virtual bool execute(TokenExecutor &exec)
+ /**
+ *
+ */
+ virtual void add(const Context &contextArg)
{
- return true;
+ contexts.push_back(currentContext);
+ currentContext=contextArg;
}
-};
-class TokFuncTranslate : public Token
-{
-public:
- TokFuncTranslate()
- {
- type = TOK_FUNC_TRANSLATE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ virtual void add(const Token &token)
+ { currentContext.add(token); }
-class TokFuncBoolean : public Token
-{
-public:
- TokFuncBoolean()
- {
- type = TOK_FUNC_BOOLEAN;
- }
- virtual bool execute(TokenExecutor &exec)
+ /**
+ *
+ */
+ virtual void dump()
{
- return true;
+ for (unsigned int i=0 ; i<contexts.size() ; i++)
+ {
+ Context context = contexts[i];
+ context.dump();
+ }
}
-};
-class TokFuncNot : public Token
-{
-public:
- TokFuncNot()
- {
- type = TOK_FUNC_NOT;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ /**
+ *
+ */
+ virtual void clear()
+ {
+ currentContext.clear();
+ contexts.clear();
+ }
-class TokFuncTrue : public Token
-{
-public:
- TokFuncTrue()
- {
- type = TOK_FUNC_TRUE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+private:
-class TokFuncFalse : public Token
-{
-public:
- TokFuncFalse()
- {
- type = TOK_FUNC_FALSE;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-class TokFuncLang : public Token
-{
-public:
- TokFuncLang()
- {
- type = TOK_FUNC_LANG;
- }
- virtual bool execute(TokenExecutor &exec)
+ void init()
{
- return true;
+ clear();
}
-};
-class TokFuncNumber : public Token
-{
-public:
- TokFuncNumber()
- {
- type = TOK_FUNC_NUMBER;
- }
- virtual bool execute(TokenExecutor &exec)
+ void assign(const TokenList &other)
{
- return true;
+ currentContext = other.currentContext;
+ contexts = other.contexts;
}
-};
-class TokFuncSum : public Token
-{
-public:
- TokFuncSum()
- {
- type = TOK_FUNC_SUM;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ Context currentContext;
-class TokFuncFloor : public Token
-{
-public:
- TokFuncFloor()
- {
- type = TOK_FUNC_FLOOR;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
+ std::vector<Context> contexts;
-class TokFuncCeiling : public Token
-{
-public:
- TokFuncCeiling()
- {
- type = TOK_FUNC_CEILING;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
-};
-class TokFuncRound : public Token
-{
-public:
- TokFuncRound()
- {
- type = TOK_FUNC_ROUND;
- }
- virtual bool execute(TokenExecutor &exec)
- {
- return true;
- }
};
-
-
//########################################################################
-//# T O K E N L I S T
+//# T O K E N E X E C U T O R
//########################################################################
+
/**
- *
+ * A token evaluator, with stack and axis context
*/
-class TokenList
+class TokenExecutor
{
public:
/**
- *
+ * Constructor
*/
- TokenList();
+ TokenExecutor();
/**
- *
+ * Copy constructor
*/
- TokenList(const TokenList &other);
+ TokenExecutor(const TokenExecutor &other);
/**
- *
+ * Destructor
*/
- TokenList &operator=(const TokenList &other);
+ virtual ~TokenExecutor();
/**
- *
+ * Assign our values to those of the other
*/
- void assign(const TokenList &other);
+ virtual void assign(const TokenExecutor &other);
/**
- *
+ * Reset the stack to its original settings
*/
- virtual ~TokenList();
+ virtual void reset();
/**
- *
+ * Push a stack item onto the stack
*/
- virtual void clear();
+ virtual void push(StackItem &item);
/**
- *
+ * Pop a stack item from the stack
*/
- virtual void add(Token *tok);
+ virtual StackItem pop();
/**
- *
+ * Execute a token list on the stack
*/
- virtual unsigned int size() const;
+ NodeList execute(const TokenList &list, const Node *node);
+
+private:
/**
- *
+ * Contains the StackItem stack;
*/
- virtual void dump();
+ Stack stack;
-private:
+ /**
+ *
+ */
+ TokenList tokenList;
- std::vector<Token *> tokens;
+ /**
+ *
+ */
+ NodeList nodeList;
};
-
-
-
} // namespace xpath
} // namespace dom
} // namespace w3c