locationPath

relativeLocationPath absoluteLocationPath

absoluteLocationPath

'/'


      $$ = PyObject_CallFunction(ParsedAbsoluteLocationPath, "O", Py_None);


      $$ = ParsedAbsoluteLocationPath(None)

'/' relativeLocationPath


      $$ = PyObject_CallFunction(ParsedAbsoluteLocationPath, "O", $2);


      $$ = ParsedAbsoluteLocationPath($2)

abbreviatedAbsoluteLocationPath

relativeLocationPath

step relativeLocationPath '/' step


      $$ = PyObject_CallFunction(ParsedRelativeLocationPath, "OO", $1, $3);


      $$ = ParsedRelativeLocationPath($1, $3)

abbreviatedRelativeLocationPath

step

axisSpecifier nodeTest


      $$ = PyObject_CallFunction(ParsedStep, "OO", $1, $2);


      $$ = ParsedStep($1, $2)

axisSpecifier nodeTest predicateList


      $$ = PyObject_CallFunction(ParsedStep, "OOO", $1, $2, $3);


      $$ = ParsedStep($1, $2, $3)

abbreviatedStep

predicateList

predicate


      PyObject *pred_list = PyList_New(1);
      /* Steals a reference */
      PyList_SET_ITEM(pred_list, 0, $1);
      Py_INCREF($1);
      $$ = PyObject_CallFunction(ParsedPredicateList, "O", pred_list);
      Py_DECREF(pred_list);


      $$ = ParsedPredicateList([$1])

predicateList predicate


      PyObject_CallMethod($1, "append", "O", $2);
      Py_INCREF($1);
      $$ = $1;


      $1.append($2)
      $$ = $1

axisSpecifier

AXIS_NAME DOUBLE_COLON


      $$ = PyObject_CallFunction(ParsedAxisSpecifier, "O", $1);


      $$ = ParsedAxisSpecifier($1)

abbreviatedAxisSpecifier

nodeTest

WILDCARD_NAME


      $$ = PyObject_CallFunction(ParsedNameTest, "O", $1);


      $$ = ParsedNameTest($1)

NODE_TYPE '(' ')'


      $$ = PyObject_CallFunction(ParsedNodeTest, "O", $1);


      $$ = ParsedNodeTest($1)

NODE_TYPE '(' LITERAL ')'


      $$ = PyObject_CallFunction(ParsedNodeTest, "OO", $1, $3);


      $$ = ParsedNodeTest($1, $3)

predicate

'[' predicateExpr ']'


      Py_INCREF($2);
      $$ = $2;


      $$ = $2

predicateExpr

expr

abbreviatedAbsoluteLocationPath

DOUBLE_SLASH relativeLocationPath


      $$ = PyObject_CallFunction(ParsedAbbreviatedAbsoluteLocationPath,
                                 "O", $2);


      $$ = ParsedAbbreviatedAbsoluteLocationPath($2)

abbreviatedRelativeLocationPath

relativeLocationPath DOUBLE_SLASH step


      $$ = PyObject_CallFunction(ParsedAbbreviatedRelativeLocationPath,
                                 "OO", $1, $3);


      $$ = ParsedAbbreviatedRelativeLocationPath($1, $3)

abbreviatedStep

'.'


      $$ = PyObject_CallFunction(ParsedAbbreviatedStep, "i", 0);


      $$ = ParsedAbbreviatedStep(0)

DOUBLE_DOT


      $$ = PyObject_CallFunction(ParsedAbbreviatedStep, "i", 1);


      $$ = ParsedAbbreviatedStep(1)

abbreviatedAxisSpecifier

'@'


      $$ = PyObject_CallFunction(ParsedAxisSpecifier, "s", "attribute");


      $$ = ParsedAxisSpecifier("attribute")


      $$ = PyObject_CallFunction(ParsedAxisSpecifier, "s", "child");


      $$ = ParsedAxisSpecifier("child")

expr

orExpr

primaryExpr

VARIABLE_REFERENCE


      $$ = PyObject_CallFunction(ParsedVariableReferenceExpr, "O", $1);


      $$ = ParsedVariableReferenceExpr($1)

'(' expr ')'


      $$ = $2;
      Py_INCREF($2);


      $$ = $2

LITERAL


      $$ = PyObject_CallFunction(ParsedLiteralExpr, "O", $1);


      $$ = ParsedLiteralExpr($1)

NLITERAL


      $$ = PyObject_CallFunction(ParsedNLiteralExpr, "O", $1);


      $$ = ParsedNLiteralExpr($1)

functionCall

FUNCTION_NAME '(' ')'


      PyObject *arg_list = PyList_New(0);
      $$ = PyObject_CallFunction(ParsedFunctionCallExpr, "OO", $1, arg_list);
      Py_DECREF(arg_list);


      $$ = ParsedFunctionCallExpr($1, [])

FUNCTION_NAME '(' argumentList ')'


      $$ = PyObject_CallFunction(ParsedFunctionCallExpr, "OO", $1, $3);


      $$ = ParsedFunctionCallExpr($1, $3)

argumentList

argument


      $$ = PyList_New(1);
      /* Steals a reference */
      PyList_SET_ITEM($$, 0, $1);
      Py_INCREF($1);


      $$ = [$1]

argumentList ',' argument


      PyList_Append($1, $3);
      Py_INCREF($1);
      $$ = $1;


      $1.append($3)
      $$ = $1

argument

expr

unionExpr

pathExpr unionExpr '|' pathExpr


      $$ = PyObject_CallFunction(ParsedUnionExpr, "OO", $1, $3);


      $$ = ParsedUnionExpr($1, $3)

pathExpr

locationPath filterExpr filterExpr '/' relativeLocationPath


      $$ = PyObject_CallFunction(ParsedPathExpr, "iOO", 0, $1, $3);


      $$ = ParsedPathExpr($2, $1, $3)

filterExpr DOUBLE_SLASH relativeLocationPath


      $$ = PyObject_CallFunction(ParsedPathExpr, "iOO", 1, $1, $3);


      $$ = ParsedPathExpr($2, $1, $3)

filterExpr

primaryExpr primaryExpr predicateList


      $$ = PyObject_CallFunction(ParsedFilterExpr, "OO", $1, $2);


      $$ = ParsedFilterExpr($1, $2)

orExpr

andExpr orExpr OR andExpr


      $$ = PyObject_CallFunction(ParsedOrExpr, "OO", $1, $3);


      $$ = ParsedOrExpr($1, $3)

andExpr

equalityExpr andExpr AND equalityExpr


      $$ = PyObject_CallFunction(ParsedAndExpr, "OO", $1, $3);


      $$ = ParsedAndExpr($1, $3)

equalityExpr

relationalExpr equalityExpr EQUALITY_OP relationalExpr


      $$ = PyObject_CallFunction(ParsedEqualityExpr, "OOO", $2, $1, $3);


      $$ = ParsedEqualityExpr($2, $1, $3)

relationalExpr

additiveExpr relationalExpr RELATIONAL_OP additiveExpr


      char *op = PyString_AsString($2);
      if (op[0] == '<') {
        if (op[1] == '=') {
          /* less than or equal to */
          $$ = PyObject_CallFunction(ParsedRelationalExpr, "lOO", 1, $1, $3);
        } else {
          /* less than */
          $$ = PyObject_CallFunction(ParsedRelationalExpr, "lOO", 0, $1, $3);
        }
      } else if (op[1] == '=') {
        /* greater than or equal to */
        $$ = PyObject_CallFunction(ParsedRelationalExpr, "lOO", 3, $1, $3);
      } else {
        /* greater than */
        $$ = PyObject_CallFunction(ParsedRelationalExpr, "lOO", 2, $1, $3);
      }


      ops = {'<' : 0,
             '>' : 2,
             '<=' : 1,
             '>=' : 3,
             }
      $$ = ParsedRelationalExpr(ops[$2], $1, $3)

additiveExpr

multiplicativeExpr additiveExpr '+' multiplicativeExpr


      $$ = PyObject_CallFunction(ParsedAdditiveExpr, "iOO", 1, $1, $3);


      $$ = ParsedAdditiveExpr(1, $1, $3)

additiveExpr '-' multiplicativeExpr


      $$ = PyObject_CallFunction(ParsedAdditiveExpr, "iOO", -1, $1, $3);


      $$ = ParsedAdditiveExpr(-1, $1, $3)

multiplicativeExpr

unaryExpr multiplicativeExpr MULTIPLY_OPERATOR unaryExpr


      char *op = PyString_AsString($2);
      switch (*op) {
        case '*': {
          $$ = PyObject_CallFunction(ParsedMultiplicativeExpr, "lOO", 0, $1, $3);
          break;
        }
        case 'd': {
          $$ = PyObject_CallFunction(ParsedMultiplicativeExpr, "lOO", 1, $1, $3);
          break;
        }
        case 'm': {
          $$ = PyObject_CallFunction(ParsedMultiplicativeExpr, "lOO", 2, $1, $3);
          break;
        }
      }


      ops = {'*' : 0,
             'div' : 1,
             'mod' : 2,
             }
      $$ = ParsedMultiplicativeExpr(ops[$2], $1, $3)

unaryExpr

unionExpr '-' unionExpr


      $$ = PyObject_CallFunction(ParsedUnaryExpr, "O", $2);


      $$ = ParsedUnaryExpr($2)