gecko-dev/extensions/xforms/nsXFormsXPathParser.cpp

920 строки
23 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla XForms support.
*
* The Initial Developer of the Original Code is
* Novell, Inc.
* Portions created by the Initial Developer are Copyright (C) 2004
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Allan Beaufour <abeaufour@novell.com>
* David Landwehr <dlandwehr@novell.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsXFormsXPathParser.h"
#include "nscore.h"
/*
* @todo GIANT hack. Without exceptions everything had to be rewritten, and
* that was to overdo it a bit, when the code probably does not survive... (XXX)
*/
void
XPathCompilerException(const char *aMsg,
const nsAString &aExpression,
PRInt32 aOffset = -1,
PRInt32 aLength = -1)
{
printf("XPathCompilerException: %s, %s [o: %d, l: %d]\n",
aMsg,
NS_ConvertUTF16toUTF8(aExpression).get(), aOffset, aLength);
printf("WARNING: Houston we have a problem, and unlike Apollo 13, we're not going to make it!\n");
NS_ABORT();
}
nsXFormsXPathParser::nsXFormsXPathParser()
: mUsesDynamicFunc(PR_FALSE), mHead(nsnull), mAnalyzeStackPointer(nsnull)
{
MOZ_COUNT_CTOR(nsXFormsXPathParser);
}
nsXFormsXPathParser::~nsXFormsXPathParser()
{
MOZ_COUNT_DTOR(nsXFormsXPathParser);
}
void
nsXFormsXPathParser::PushContext(PRInt32 aStartIndex)
{
mHead = new nsXFormsXPathNode(mHead);
if (aStartIndex == -100) {
mHead->mStartIndex = mScanner.Offset() + 1;
} else {
mHead->mStartIndex = aStartIndex;
}
mStack[++mAnalyzeStackPointer] = mHead;
mHead->mPredicate = mPredicateLevel != 0;
mHead->mLiteral = PR_FALSE;
}
void
nsXFormsXPathParser::PushContext(nsXFormsXPathNode* aNode)
{
mStack[++mAnalyzeStackPointer] = aNode;
mHead = aNode;
}
void
nsXFormsXPathParser::EndContext()
{
if (mHead) {
mHead->mEndIndex = mScanner.Offset() + 1;
}
}
void
nsXFormsXPathParser::RestartContext()
{
nsXFormsXPathNode* temp = new nsXFormsXPathNode(nsnull, PR_TRUE);
temp->mStartIndex = mScanner.Offset() + 1;
temp->mSibling = mHead->mChild;
temp->mPredicate = mPredicateLevel != 0;
mHead->mChild = temp;
mHead = temp;
mStack[mAnalyzeStackPointer] = mHead;
}
nsXFormsXPathNode*
nsXFormsXPathParser::JustContext()
{
nsXFormsXPathNode* t = mStack[mAnalyzeStackPointer];
mHead = mStack[--mAnalyzeStackPointer];
return t;
}
nsXFormsXPathNode*
nsXFormsXPathParser::PopContext()
{
if (mHead->mEndIndex == -100) {
mHead->mEndIndex = mScanner.Offset() + 1;
}
NS_ASSERTION(mHead->mStartIndex <= mHead->mEndIndex, "");
NS_ASSERTION(mAnalyzeStackPointer - 1 >= 0, "");
mHead = mStack[--mAnalyzeStackPointer];
return mHead;
}
void
nsXFormsXPathParser::AbbreviatedStep()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::DOT:
PopToken();
break;
case nsXFormsXPathScanner::DOTDOT:
PopToken();
break;
default:
XPathCompilerException("Expected . or ..", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
break;
}
}
void
nsXFormsXPathParser::AbsoluteLocationPath()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
nsXFormsXPathScanner::XPATHTOKEN r;
switch (t) {
case nsXFormsXPathScanner::SLASH:
PopToken();
r = PeekToken();
switch (r) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
RelativeLocationPath();
break;
default:
break;
}
break;
case nsXFormsXPathScanner::SLASHSLASH:
PopToken();
if (DoRelative()) {
RelativeLocationPath();
}
break;
default:
XPathCompilerException("Not an absolute location path", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
void
nsXFormsXPathParser::AdditiveExpression()
{
PRBool con = PR_TRUE;
MultiplicationExpr();
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::PLUS:
PopToken();
MultiplicationExpr();
break;
case nsXFormsXPathScanner::MINUS:
PopToken();
MultiplicationExpr();
break;
default:
con = PR_FALSE;
}
}
}
void
nsXFormsXPathParser::AndExpr()
{
EqualityExpr();
if (PeekToken() == nsXFormsXPathScanner::AND) {
PopToken();
AndExpr();
}
}
void
nsXFormsXPathParser::AxisSpecifier()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
PopToken();
case nsXFormsXPathScanner::AT:
PopToken();
break;
default:
XPathCompilerException("Not a axis specifier", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
break;
}
}
PRBool
nsXFormsXPathParser::DoRelative()
{
PRBool ret = PR_FALSE;
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
ret = PR_TRUE;
break;
default:
break;
}
return ret;
}
void
nsXFormsXPathParser::EqualityExpr()
{
RelationalExpression();
PRBool con = PR_TRUE;
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::EQUAL:
PopToken();
RelationalExpression();
break;
case nsXFormsXPathScanner::NOTEQUAL:
PopToken();
RelationalExpression();
break;
default:
con = PR_FALSE;
}
}
}
void
nsXFormsXPathParser::Expr()
{
OrExpr();
}
void
nsXFormsXPathParser::FilterExpr()
{
if (PrimaryExpr() && PeekToken() == nsXFormsXPathScanner::LBRACK) {
Predicate();
}
}
void
nsXFormsXPathParser::FunctionCall()
{
nsDependentSubstring fname = Substring(mScanner.Expression(),
mScanner.Offset() + 1,
mScanner.Length());
if (!mUsesDynamicFunc && fname.Equals(NS_LITERAL_STRING("now"))) {
mUsesDynamicFunc = PR_TRUE;
}
PopToken();
PopToken();
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
PRBool con = t == nsXFormsXPathScanner::RPARAN ? PR_FALSE : PR_TRUE;
while (con) {
if (t == nsXFormsXPathScanner::XPATHEOF) {
XPathCompilerException("Expected ) got EOF",
mScanner.Expression(),
mScanner.Offset(),
mScanner.Length());
}
nsXFormsXPathNode* c = JustContext();
Expr();
if (fname.Equals(NS_LITERAL_STRING("index"))) {
c->mIsIndex = PR_TRUE;
}
PushContext(c);
t = PeekToken();
con = (t == nsXFormsXPathScanner::COMMA);
if (con) {
PopToken(); // Another Argument
}
}
if (t != nsXFormsXPathScanner::RPARAN) {
XPathCompilerException("Expected )", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
PopToken();
}
void
nsXFormsXPathParser::LocationPath()
{
if (DoRelative()) {
PushContext();
RelativeLocationPath();
PopContext();
} else {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::SLASH:
case nsXFormsXPathScanner::SLASHSLASH:
PushContext();
AbsoluteLocationPath();
PopContext();
break;
default:
XPathCompilerException("Not a location path", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
}
void
nsXFormsXPathParser::MultiplicationExpr()
{
UnaryExpr();
PRBool con = PR_TRUE;
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::MULTIPLYOPERATOR:
case nsXFormsXPathScanner::DIV:
case nsXFormsXPathScanner::MOD:
PopToken();
UnaryExpr();
break;
default:
con = PR_FALSE;
}
}
}
void
nsXFormsXPathParser::NameTest()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
PopToken();
break;
default:
XPathCompilerException("NodeTest error", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
void
nsXFormsXPathParser::NodeTest()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
NameTest();
break;
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
NodeType();
break;
default:
XPathCompilerException("Not a node test", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
void
nsXFormsXPathParser::NodeType()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::COMMENT:
PopToken();
PopToken();
PopToken();
break;
case nsXFormsXPathScanner::TEXT:
PopToken();
PopToken();
PopToken();
break;
case nsXFormsXPathScanner::PI:
PopToken();
if ((t = PeekToken()) == nsXFormsXPathScanner::LPARAN) {
PopToken();
PopToken();
PopToken();
}
break;
case nsXFormsXPathScanner::NODE:
PopToken();
PopToken();
PopToken();
break;
default:
XPathCompilerException("Not a valid NodeType", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
void
nsXFormsXPathParser::OrExpr()
{
AndExpr();
if (PeekToken() == nsXFormsXPathScanner::OR) {
PopToken();
OrExpr();
}
}
void
nsXFormsXPathParser::PathExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
case nsXFormsXPathScanner::SLASH:
case nsXFormsXPathScanner::SLASHSLASH:
LocationPath();
break;
default:
PushContext();
FilterExpr();
t = PeekToken();
if (t == nsXFormsXPathScanner::SLASH || t == nsXFormsXPathScanner::SLASHSLASH) {
PopToken();
if (DoRelative()) {
RelativeLocationPath();
} else {
XPathCompilerException("After / in a filter expression it is required to have a reletive path expression", EmptyString());
}
}
PopContext();
}
}
nsXFormsXPathScanner::XPATHTOKEN
nsXFormsXPathParser::PeekToken()
{
return mPeek;
}
nsXFormsXPathScanner::XPATHTOKEN
nsXFormsXPathParser::PopToken()
{
nsXFormsXPathScanner::XPATHTOKEN temp = mPeek;
mPeek = mScanner.NextToken();
if (mPeek == nsXFormsXPathScanner::WHITESPACE) { // Skip whitespaces
mPeek = mScanner.NextToken();
}
NS_WARN_IF_FALSE(mPeek != nsXFormsXPathScanner::ERRORXPATHTOKEN,
"Scanner returned ERROR token!");
return temp;
}
void
nsXFormsXPathParser::Predicate()
{
EndContext();
mPredicateLevel++;
while (PeekToken() == nsXFormsXPathScanner::LBRACK) {
PopToken();
Expr();
nsXFormsXPathScanner::XPATHTOKEN t = PopToken();
if (t != nsXFormsXPathScanner::RBRACK) {
XPathCompilerException("Expected ]", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
mPredicateLevel--;
RestartContext();
}
PRBool
nsXFormsXPathParser::PrimaryExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::VARIABLE:
PopToken();
break;
case nsXFormsXPathScanner::LPARAN: {
PopToken();
nsXFormsXPathNode* c = JustContext();
Expr();
PushContext(c);
if (PeekToken() == nsXFormsXPathScanner::RPARAN) {
PopToken();
} else {
XPathCompilerException("Expected )", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
break;
case nsXFormsXPathScanner::LITERAL:
mHead->mLiteral = PR_TRUE;
PopToken();
break;
case nsXFormsXPathScanner::NUMBER:
mHead->mLiteral = PR_TRUE;
PopToken();
break;
case nsXFormsXPathScanner::FUNCTIONNAME:
FunctionCall();
return PeekToken() == nsXFormsXPathScanner::SLASH || PeekToken() == nsXFormsXPathScanner::SLASHSLASH || PeekToken() == nsXFormsXPathScanner::LBRACK;
break;
default:
XPathCompilerException("Not a primary expression", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
return PR_FALSE;
}
void
nsXFormsXPathParser::RelationalExpression()
{
AdditiveExpression();
PRBool con = PR_TRUE;
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::LESS:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::LEQUAL:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::GREATER:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::GEQUAL:
PopToken();
AdditiveExpression();
break;
default:
con = PR_FALSE;
}
}
}
void
nsXFormsXPathParser::RelativeLocationPath()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
Step();
break;
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
AbbreviatedStep();
break;
default:
XPathCompilerException("Not a relative location path ", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
t = PeekToken();
if (t == nsXFormsXPathScanner::SLASH || t == nsXFormsXPathScanner::SLASHSLASH) {
PopToken();
if (DoRelative()) {
RelativeLocationPath();
}
}
}
void
nsXFormsXPathParser::Step()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
AxisSpecifier();
break;
default:
break;
}
t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
NodeTest();
break;
default:
XPathCompilerException("Expected a NodeTest expression", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
t = PeekToken();
if (t == nsXFormsXPathScanner::LBRACK) {
Predicate(); // set the predicates
}
}
void
nsXFormsXPathParser::UnaryExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::MINUS:
PopToken();
UnaryExpr();
break;
default:
UnionExpr();
}
}
void
nsXFormsXPathParser::UnionExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
case nsXFormsXPathScanner::SLASH:
case nsXFormsXPathScanner::SLASHSLASH:
PathExpr();
t = PeekToken();
if (t == nsXFormsXPathScanner::UNION) {
PopToken();
UnionExpr();
}
break;
case nsXFormsXPathScanner::VARIABLE:
case nsXFormsXPathScanner::LPARAN:
case nsXFormsXPathScanner::LITERAL:
case nsXFormsXPathScanner::NUMBER:
case nsXFormsXPathScanner::FUNCTIONNAME:
PathExpr();
t = PeekToken();
if (t == nsXFormsXPathScanner::UNION) {
PopToken();
UnionExpr();
}
break;
default:
XPathCompilerException("Unexpected union token", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
nsXFormsXPathNode*
nsXFormsXPathParser::Parse(const nsAString& aExpression)
{
#ifdef DEBUG_XF_PARSER
printf("=====================================\n");
printf("Parsing: %s\n", NS_ConvertUTF16toUTF8(aExpression).get());
printf("=====================================\n");
#endif
mScanner.Init(aExpression);
mAnalyzeStackPointer = 0;
mPredicateLevel = 0;
mHead = nsnull;
PopToken();
PushContext();
nsXFormsXPathNode* root = mHead;
Expr();
PopContext();
#ifdef DEBUG_XF_PARSER
Dump(root);
printf("-------------------------------------\n");
#endif
return root;
}
PRBool
nsXFormsXPathParser::UsesDynamicFunc() const {
return mUsesDynamicFunc;
}
#ifdef DEBUG_XF_PARSER
void
nsXFormsXPathParser::Dump(nsXFormsXPathNode* aNode)
{
DumpWithLevel(aNode->mChild, 0);
}
void
nsXFormsXPathParser::DumpWithLevel(nsXFormsXPathNode* aNode, PRInt32 aLevel)
{
while (aNode) {
if (aNode->mStartIndex < aNode->mEndIndex) {
for (int i = 0; i < aLevel; i++) {
printf(" ");
}
if (aNode->mCon) {
printf("(+)");
} else {
printf("(|)");
}
OutputSubExpression(aNode->mStartIndex, aNode->mEndIndex);
}
DumpWithLevel(aNode->mChild, aLevel + 2);
aNode = aNode->mSibling;
}
}
void
nsXFormsXPathParser::OutputSubExpression(PRInt32 aOffset, PRInt32 aEndOffset)
{
const nsDependentSubstring expr = Substring(mScanner.Expression(), aOffset, aEndOffset - aOffset);
printf("%s\n", NS_ConvertUTF16toUTF8(expr).get());
}
#endif