< prev index next >

src/java.xml/share/classes/com/sun/org/apache/xalan/internal/xsltc/compiler/XPathParser.java

Print this page

        

@@ -1309,11 +1309,11 @@
           case 123: // QName ::= QNAME
             {
               QName RESULT = null;
                 int qnameleft = (parser_stack.get(parser_top-0)).left;
                 int qnameright = (parser_stack.get(parser_top-0)).right;
-                String qname = (String)((Symbol) parser_stack.get(parser_top-0)).value;
+                String qname = (String)(parser_stack.get(parser_top-0)).value;
                  RESULT = parser.getQNameIgnoreDefaultNs(qname);
               parser_result = new Symbol(37/*QName*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1321,11 +1321,11 @@
           case 122: // NameTest ::= QName
             {
               Object RESULT = null;
                 int qnleft = (parser_stack.get(parser_top-0)).left;
                 int qnright = (parser_stack.get(parser_top-0)).right;
-                QName qn = (QName)((Symbol) parser_stack.get(parser_top-0)).value;
+                QName qn = (QName)(parser_stack.get(parser_top-0)).value;
                  RESULT = qn;
               parser_result = new Symbol(26/*NameTest*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1351,11 +1351,11 @@
           case 119: // NodeTest ::= PIPARAM LPAREN Literal RPAREN
             {
               Object RESULT = null;
                 int lleft = (parser_stack.get(parser_top-1)).left;
                 int lright = (parser_stack.get(parser_top-1)).right;
-                String l = (String)((Symbol) parser_stack.get(parser_top-1)).value;
+                String l = (String)(parser_stack.get(parser_top-1)).value;
 
            QName name = parser.getQNameIgnoreDefaultNs("name");
            Expression exp = new EqualityExpr(Operators.EQ,
                                              new NameCall(name),
                                              new LiteralExpr(l));

@@ -1398,11 +1398,11 @@
           case 115: // NodeTest ::= NameTest
             {
               Object RESULT = null;
                 int ntleft = (parser_stack.get(parser_top-0)).left;
                 int ntright = (parser_stack.get(parser_top-0)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object nt = parser_stack.get(parser_top-0).value;
                  RESULT = nt;
               parser_result = new Symbol(25/*NodeTest*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1410,11 +1410,11 @@
           case 114: // Argument ::= Expr
             {
               Expression RESULT = null;
                 int exleft = (parser_stack.get(parser_top-0)).left;
                 int exright = (parser_stack.get(parser_top-0)).right;
-                Expression ex = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ex = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ex;
               parser_result = new Symbol(3/*Argument*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1422,11 +1422,11 @@
           case 113: // VariableName ::= QName
             {
               QName RESULT = null;
                 int vnameleft = (parser_stack.get(parser_top-0)).left;
                 int vnameright = (parser_stack.get(parser_top-0)).right;
-                QName vname = (QName)((Symbol) parser_stack.get(parser_top-0)).value;
+                QName vname = (QName)(parser_stack.get(parser_top-0)).value;
 
             RESULT = vname;
 
               parser_result = new Symbol(39/*VariableName*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -1436,11 +1436,11 @@
           case 112: // FunctionName ::= QName
             {
               QName RESULT = null;
                 int fnameleft = (parser_stack.get(parser_top-0)).left;
                 int fnameright = (parser_stack.get(parser_top-0)).right;
-                QName fname = (QName)((Symbol) parser_stack.get(parser_top-0)).value;
+                QName fname = (QName)(parser_stack.get(parser_top-0)).value;
 
             RESULT = fname;
 
               parser_result = new Symbol(38/*FunctionName*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -1450,15 +1450,15 @@
           case 111: // NonemptyArgumentList ::= Argument COMMA NonemptyArgumentList
             {
                 List<Expression> RESULT = null;
                 int argleft = (parser_stack.get(parser_top-2)).left;
                 int argright = (parser_stack.get(parser_top-2)).right;
-                Expression arg = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression arg = (Expression)(parser_stack.get(parser_top-2)).value;
                 int arglleft = (parser_stack.get(parser_top-0)).left;
                 int arglright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Expression> argl = (ArrayList<Expression>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Expression> argl = (ArrayList<Expression>)(parser_stack.get(parser_top-0)).value;
                 argl.add(0, arg);
                 RESULT = argl;
               parser_result = new Symbol(36/*NonemptyArgumentList*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;

@@ -1467,11 +1467,11 @@
           case 110: // NonemptyArgumentList ::= Argument
             {
               List<Expression> RESULT = null;
                 int argleft = (parser_stack.get(parser_top-0)).left;
                 int argright = (parser_stack.get(parser_top-0)).right;
-                Expression arg = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression arg = (Expression)(parser_stack.get(parser_top-0)).value;
 
             List<Expression> temp = new ArrayList<>();
             temp.add(arg);
             RESULT = temp;
 

@@ -1483,15 +1483,15 @@
           case 109: // FunctionCall ::= FunctionName LPAREN NonemptyArgumentList RPAREN
             {
                 Expression RESULT = null;
                 int fnameleft = (parser_stack.get(parser_top-3)).left;
                 int fnameright = (parser_stack.get(parser_top-3)).right;
-                QName fname = (QName)((Symbol) parser_stack.get(parser_top-3)).value;
+                QName fname = (QName)(parser_stack.get(parser_top-3)).value;
                 int arglleft = (parser_stack.get(parser_top-1)).left;
                 int arglright = (parser_stack.get(parser_top-1)).right;
                 @SuppressWarnings("unchecked")
-                List<Expression> argl = (ArrayList<Expression>)((Symbol) parser_stack.get(parser_top-1)).value;
+                List<Expression> argl = (ArrayList<Expression>)(parser_stack.get(parser_top-1)).value;
 
           if (fname == parser.getQNameIgnoreDefaultNs("concat")) {
             RESULT = new ConcatCall(fname, argl);
           }
           else if (fname == parser.getQNameIgnoreDefaultNs("number")) {

@@ -1582,11 +1582,11 @@
           case 108: // FunctionCall ::= FunctionName LPAREN RPAREN
             {
               Expression RESULT = null;
                 int fnameleft = (parser_stack.get(parser_top-2)).left;
                 int fnameright = (parser_stack.get(parser_top-2)).right;
-                QName fname = (QName)((Symbol) parser_stack.get(parser_top-2)).value;
+                QName fname = (QName)(parser_stack.get(parser_top-2)).value;
 
 
           if (fname == parser.getQNameIgnoreDefaultNs("current")) {
             RESULT = new CurrentCall(fname);
           }

@@ -1638,11 +1638,11 @@
           case 107: // VariableReference ::= DOLLAR VariableName
             {
               Expression RESULT = null;
                 int varNameleft = (parser_stack.get(parser_top-0)).left;
                 int varNameright = (parser_stack.get(parser_top-0)).right;
-                QName varName = (QName)((Symbol) parser_stack.get(parser_top-0)).value;
+                QName varName = (QName)(parser_stack.get(parser_top-0)).value;
 
             // An empty qname prefix for a variable or parameter reference
             // should map to the null namespace and not the default URI.
             SyntaxTreeNode node = parser.lookupName(varName);
 

@@ -1670,11 +1670,11 @@
           case 106: // PrimaryExpr ::= FunctionCall
             {
               Expression RESULT = null;
                 int fcleft = (parser_stack.get(parser_top-0)).left;
                 int fcright = (parser_stack.get(parser_top-0)).right;
-                Expression fc = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression fc = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = fc;
               parser_result = new Symbol(17/*PrimaryExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1682,11 +1682,11 @@
           case 105: // PrimaryExpr ::= REAL
             {
               Expression RESULT = null;
                 int numleft = (parser_stack.get(parser_top-0)).left;
                 int numright = (parser_stack.get(parser_top-0)).right;
-                Double num = (Double)((Symbol) parser_stack.get(parser_top-0)).value;
+                Double num = (Double)(parser_stack.get(parser_top-0)).value;
                  RESULT = new RealExpr(num.doubleValue());
               parser_result = new Symbol(17/*PrimaryExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1694,11 +1694,11 @@
           case 104: // PrimaryExpr ::= INT
             {
               Expression RESULT = null;
                 int numleft = (parser_stack.get(parser_top-0)).left;
                 int numright = (parser_stack.get(parser_top-0)).right;
-                Long num = (Long)((Symbol) parser_stack.get(parser_top-0)).value;
+                Long num = (Long)(parser_stack.get(parser_top-0)).value;
 
            long value = num.longValue();
            if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
                 RESULT = new RealExpr(value);
            }

@@ -1721,11 +1721,11 @@
           case 103: // PrimaryExpr ::= Literal
             {
               Expression RESULT = null;
                 int stringleft = (parser_stack.get(parser_top-0)).left;
                 int stringright = (parser_stack.get(parser_top-0)).right;
-                String string = (String)((Symbol) parser_stack.get(parser_top-0)).value;
+                String string = (String)(parser_stack.get(parser_top-0)).value;
 
         /*
         * If the string appears to have the syntax of a QName, store
         * namespace info in the literal expression. This is used for
         * element-available and function-available functions, among

@@ -1749,11 +1749,11 @@
           case 102: // PrimaryExpr ::= LPAREN Expr RPAREN
             {
               Expression RESULT = null;
                 int exleft = (parser_stack.get(parser_top-1)).left;
                 int exright = (parser_stack.get(parser_top-1)).right;
-                Expression ex = (Expression)((Symbol) parser_stack.get(parser_top-1)).value;
+                Expression ex = (Expression)(parser_stack.get(parser_top-1)).value;
                  RESULT = ex;
               parser_result = new Symbol(17/*PrimaryExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1761,11 +1761,11 @@
           case 101: // PrimaryExpr ::= VariableReference
             {
               Expression RESULT = null;
                 int vrleft = (parser_stack.get(parser_top-0)).left;
                 int vrright = (parser_stack.get(parser_top-0)).right;
-                Expression vr = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression vr = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = vr;
               parser_result = new Symbol(17/*PrimaryExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1773,15 +1773,15 @@
           case 100: // FilterExpr ::= PrimaryExpr Predicates
             {
               Expression RESULT = null;
                 int primaryleft = (parser_stack.get(parser_top-1)).left;
                 int primaryright = (parser_stack.get(parser_top-1)).right;
-                Expression primary = (Expression)((Symbol) parser_stack.get(parser_top-1)).value;
+                Expression primary = (Expression)(parser_stack.get(parser_top-1)).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Expression> pp = (ArrayList<Expression>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Expression> pp = (ArrayList<Expression>)(parser_stack.get(parser_top-0)).value;
                  RESULT = new FilterExpr(primary, pp);
               parser_result = new Symbol(6/*FilterExpr*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1789,11 +1789,11 @@
           case 99: // FilterExpr ::= PrimaryExpr
             {
               Expression RESULT = null;
                 int primaryleft = (parser_stack.get(parser_top-0)).left;
                 int primaryright = (parser_stack.get(parser_top-0)).right;
-                Expression primary = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression primary = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = primary;
               parser_result = new Symbol(6/*FilterExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1945,11 +1945,11 @@
           case 82: // AxisSpecifier ::= AxisName DCOLON
             {
               Integer RESULT = null;
                 int anleft = (parser_stack.get(parser_top-1)).left;
                 int anright = (parser_stack.get(parser_top-1)).right;
-                Integer an = (Integer)((Symbol) parser_stack.get(parser_top-1)).value;
+                Integer an = (Integer)(parser_stack.get(parser_top-1)).value;
                  RESULT = an;
               parser_result = new Symbol(41/*AxisSpecifier*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1957,11 +1957,11 @@
           case 81: // Step ::= AbbreviatedStep
             {
               Expression RESULT = null;
                 int abbrevleft = (parser_stack.get(parser_top-0)).left;
                 int abbrevright = (parser_stack.get(parser_top-0)).right;
-                Expression abbrev = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression abbrev = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = abbrev;
               parser_result = new Symbol(7/*Step*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -1969,14 +1969,14 @@
           case 80: // Step ::= AxisSpecifier NodeTest
             {
               Expression RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-1)).left;
                 int axisright = (parser_stack.get(parser_top-1)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-1)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-1)).value;
                 int ntestleft = (parser_stack.get(parser_top-0)).left;
                 int ntestright = (parser_stack.get(parser_top-0)).right;
-                Object ntest = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object ntest = parser_stack.get(parser_top-0).value;
                  RESULT = new Step(axis.intValue(),
                              parser.findNodeType(axis.intValue(), ntest),
                              null);
 
               parser_result = new Symbol(7/*Step*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);

@@ -1987,18 +1987,18 @@
           case 79: // Step ::= AxisSpecifier NodeTest Predicates
             {
               Expression RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-2)).left;
                 int axisright = (parser_stack.get(parser_top-2)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-2)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-2)).value;
                 int ntestleft = (parser_stack.get(parser_top-1)).left;
                 int ntestright = (parser_stack.get(parser_top-1)).right;
-                Object ntest = (Object)((Symbol) parser_stack.get(parser_top-1)).value;
+                Object ntest = parser_stack.get(parser_top-1).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Predicate> pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Predicate> pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
                  RESULT = new Step(axis.intValue(),
                              parser.findNodeType(axis.intValue(), ntest),
                              pp);
 
               parser_result = new Symbol(7/*Step*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);

@@ -2009,15 +2009,15 @@
           case 78: // Step ::= NodeTest Predicates
             {
               Expression RESULT = null;
                 int ntestleft = (parser_stack.get(parser_top-1)).left;
                 int ntestright = (parser_stack.get(parser_top-1)).right;
-                Object ntest = (Object)((Symbol) parser_stack.get(parser_top-1)).value;
+                Object ntest = parser_stack.get(parser_top-1).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Predicate> pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Predicate> pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
 
             if (ntest instanceof Step) {
                 Step step = (Step)ntest;
                 step.addPredicates(pp);
                 RESULT = (Step)ntest;

@@ -2035,11 +2035,11 @@
           case 77: // Step ::= NodeTest
             {
               Expression RESULT = null;
                 int ntestleft = (parser_stack.get(parser_top-0)).left;
                 int ntestright = (parser_stack.get(parser_top-0)).right;
-                Object ntest = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object ntest = parser_stack.get(parser_top-0).value;
 
             if (ntest instanceof Step) {
                 RESULT = (Step)ntest;
             }
             else {

@@ -2056,11 +2056,11 @@
           case 76: // AbbreviatedAbsoluteLocationPath ::= DSLASH RelativeLocationPath
             {
               Expression RESULT = null;
                 int rlpleft = (parser_stack.get(parser_top-0)).left;
                 int rlpright = (parser_stack.get(parser_top-0)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-0)).value;
 
            //
            // Expand '//' into '/descendant-or-self::node()/' or
            // into /descendant-or-self::*/
            //

@@ -2082,14 +2082,14 @@
           case 75: // AbbreviatedRelativeLocationPath ::= RelativeLocationPath DSLASH Step
             {
               Expression RESULT = null;
                 int rlpleft = (parser_stack.get(parser_top-2)).left;
                 int rlpright = (parser_stack.get(parser_top-2)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-2)).value;
                 int stepleft = (parser_stack.get(parser_top-0)).left;
                 int stepright = (parser_stack.get(parser_top-0)).right;
-                Expression step = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression step = (Expression)(parser_stack.get(parser_top-0)).value;
 
            final Step right  = (Step)step;
            final int  axis   = right.getAxis();
            final int  type   = right.getNodeType();
            final List<Predicate> predicates = right.getPredicates();

@@ -2149,11 +2149,11 @@
           case 74: // AbsoluteLocationPath ::= AbbreviatedAbsoluteLocationPath
             {
               Expression RESULT = null;
                 int aalpleft = (parser_stack.get(parser_top-0)).left;
                 int aalpright = (parser_stack.get(parser_top-0)).right;
-                Expression aalp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression aalp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = aalp;
               parser_result = new Symbol(23/*AbsoluteLocationPath*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2161,11 +2161,11 @@
           case 73: // AbsoluteLocationPath ::= SLASH RelativeLocationPath
             {
               Expression RESULT = null;
                 int rlpleft = (parser_stack.get(parser_top-0)).left;
                 int rlpright = (parser_stack.get(parser_top-0)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AbsoluteLocationPath(rlp);
               parser_result = new Symbol(23/*AbsoluteLocationPath*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2182,11 +2182,11 @@
           case 71: // RelativeLocationPath ::= AbbreviatedRelativeLocationPath
             {
               Expression RESULT = null;
                 int arlpleft = (parser_stack.get(parser_top-0)).left;
                 int arlpright = (parser_stack.get(parser_top-0)).right;
-                Expression arlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression arlp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = arlp;
               parser_result = new Symbol(21/*RelativeLocationPath*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2194,14 +2194,14 @@
           case 70: // RelativeLocationPath ::= RelativeLocationPath SLASH Step
             {
               Expression RESULT = null;
                 int rlpleft = (parser_stack.get(parser_top-2)).left;
                 int rlpright = (parser_stack.get(parser_top-2)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-2)).value;
                 int stepleft = (parser_stack.get(parser_top-0)).left;
                 int stepright = (parser_stack.get(parser_top-0)).right;
-                Expression step = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression step = (Expression)(parser_stack.get(parser_top-0)).value;
 
         if (rlp instanceof Step && ((Step) rlp).isAbbreviatedDot()) {
               RESULT = step;       // Remove './' from the middle
         }
         else if (((Step) step).isAbbreviatedDot()) {

@@ -2220,11 +2220,11 @@
           case 69: // RelativeLocationPath ::= Step
             {
               Expression RESULT = null;
                 int stepleft = (parser_stack.get(parser_top-0)).left;
                 int stepright = (parser_stack.get(parser_top-0)).right;
-                Expression step = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression step = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = step;
               parser_result = new Symbol(21/*RelativeLocationPath*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2232,11 +2232,11 @@
           case 68: // LocationPath ::= AbsoluteLocationPath
             {
               Expression RESULT = null;
                 int alpleft = (parser_stack.get(parser_top-0)).left;
                 int alpright = (parser_stack.get(parser_top-0)).right;
-                Expression alp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression alp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = alp;
               parser_result = new Symbol(4/*LocationPath*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2244,11 +2244,11 @@
           case 67: // LocationPath ::= RelativeLocationPath
             {
               Expression RESULT = null;
                 int rlpleft = (parser_stack.get(parser_top-0)).left;
                 int rlpright = (parser_stack.get(parser_top-0)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = rlp;
               parser_result = new Symbol(4/*LocationPath*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2256,14 +2256,14 @@
           case 66: // PathExpr ::= FilterExpr DSLASH RelativeLocationPath
             {
               Expression RESULT = null;
                 int fexpleft = (parser_stack.get(parser_top-2)).left;
                 int fexpright = (parser_stack.get(parser_top-2)).right;
-                Expression fexp = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression fexp = (Expression)(parser_stack.get(parser_top-2)).value;
                 int rlpleft = (parser_stack.get(parser_top-0)).left;
                 int rlpright = (parser_stack.get(parser_top-0)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-0)).value;
 
            //
            // Expand '//' into '/descendant-or-self::node()/' or
            // into /descendant-or-self::*/
            //

@@ -2289,14 +2289,14 @@
           case 65: // PathExpr ::= FilterExpr SLASH RelativeLocationPath
             {
               Expression RESULT = null;
                 int fexpleft = (parser_stack.get(parser_top-2)).left;
                 int fexpright = (parser_stack.get(parser_top-2)).right;
-                Expression fexp = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression fexp = (Expression)(parser_stack.get(parser_top-2)).value;
                 int rlpleft = (parser_stack.get(parser_top-0)).left;
                 int rlpright = (parser_stack.get(parser_top-0)).right;
-                Expression rlp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rlp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new FilterParentPath(fexp, rlp);
               parser_result = new Symbol(19/*PathExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2304,11 +2304,11 @@
           case 64: // PathExpr ::= FilterExpr
             {
               Expression RESULT = null;
                 int fexpleft = (parser_stack.get(parser_top-0)).left;
                 int fexpright = (parser_stack.get(parser_top-0)).right;
-                Expression fexp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression fexp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = fexp;
               parser_result = new Symbol(19/*PathExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2316,11 +2316,11 @@
           case 63: // PathExpr ::= LocationPath
             {
               Expression RESULT = null;
                 int lpleft = (parser_stack.get(parser_top-0)).left;
                 int lpright = (parser_stack.get(parser_top-0)).right;
-                Expression lp = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression lp = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = lp;
               parser_result = new Symbol(19/*PathExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2328,14 +2328,14 @@
           case 62: // UnionExpr ::= PathExpr VBAR UnionExpr
             {
               Expression RESULT = null;
                 int peleft = (parser_stack.get(parser_top-2)).left;
                 int peright = (parser_stack.get(parser_top-2)).right;
-                Expression pe = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression pe = (Expression)(parser_stack.get(parser_top-2)).value;
                 int restleft = (parser_stack.get(parser_top-0)).left;
                 int restright = (parser_stack.get(parser_top-0)).right;
-                Expression rest = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression rest = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new UnionPathExpr(pe, rest);
               parser_result = new Symbol(18/*UnionExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2343,11 +2343,11 @@
           case 61: // UnionExpr ::= PathExpr
             {
               Expression RESULT = null;
                 int peleft = (parser_stack.get(parser_top-0)).left;
                 int peright = (parser_stack.get(parser_top-0)).right;
-                Expression pe = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression pe = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = pe;
               parser_result = new Symbol(18/*UnionExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2355,11 +2355,11 @@
           case 60: // UnaryExpr ::= MINUS UnaryExpr
             {
               Expression RESULT = null;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new UnaryOpExpr(ue);
               parser_result = new Symbol(14/*UnaryExpr*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2367,11 +2367,11 @@
           case 59: // UnaryExpr ::= UnionExpr
             {
               Expression RESULT = null;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ue;
               parser_result = new Symbol(14/*UnaryExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2379,14 +2379,14 @@
           case 58: // MultiplicativeExpr ::= MultiplicativeExpr MOD UnaryExpr
             {
               Expression RESULT = null;
                 int meleft = (parser_stack.get(parser_top-2)).left;
                 int meright = (parser_stack.get(parser_top-2)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-2)).value;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new BinOpExpr(BinOpExpr.MOD, me, ue);
               parser_result = new Symbol(13/*MultiplicativeExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2394,14 +2394,14 @@
           case 57: // MultiplicativeExpr ::= MultiplicativeExpr DIV UnaryExpr
             {
               Expression RESULT = null;
                 int meleft = (parser_stack.get(parser_top-2)).left;
                 int meright = (parser_stack.get(parser_top-2)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-2)).value;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new BinOpExpr(BinOpExpr.DIV, me, ue);
               parser_result = new Symbol(13/*MultiplicativeExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2409,14 +2409,14 @@
           case 56: // MultiplicativeExpr ::= MultiplicativeExpr STAR UnaryExpr
             {
               Expression RESULT = null;
                 int meleft = (parser_stack.get(parser_top-2)).left;
                 int meright = (parser_stack.get(parser_top-2)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-2)).value;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new BinOpExpr(BinOpExpr.TIMES, me, ue);
               parser_result = new Symbol(13/*MultiplicativeExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2424,11 +2424,11 @@
           case 55: // MultiplicativeExpr ::= UnaryExpr
             {
               Expression RESULT = null;
                 int ueleft = (parser_stack.get(parser_top-0)).left;
                 int ueright = (parser_stack.get(parser_top-0)).right;
-                Expression ue = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ue = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ue;
               parser_result = new Symbol(13/*MultiplicativeExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2436,14 +2436,14 @@
           case 54: // AdditiveExpr ::= AdditiveExpr MINUS MultiplicativeExpr
             {
               Expression RESULT = null;
                 int aeleft = (parser_stack.get(parser_top-2)).left;
                 int aeright = (parser_stack.get(parser_top-2)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-2)).value;
                 int meleft = (parser_stack.get(parser_top-0)).left;
                 int meright = (parser_stack.get(parser_top-0)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new BinOpExpr(BinOpExpr.MINUS, ae, me);
               parser_result = new Symbol(12/*AdditiveExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2451,14 +2451,14 @@
           case 53: // AdditiveExpr ::= AdditiveExpr PLUS MultiplicativeExpr
             {
               Expression RESULT = null;
                 int aeleft = (parser_stack.get(parser_top-2)).left;
                 int aeright = (parser_stack.get(parser_top-2)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-2)).value;
                 int meleft = (parser_stack.get(parser_top-0)).left;
                 int meright = (parser_stack.get(parser_top-0)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new BinOpExpr(BinOpExpr.PLUS, ae, me);
               parser_result = new Symbol(12/*AdditiveExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2466,11 +2466,11 @@
           case 52: // AdditiveExpr ::= MultiplicativeExpr
             {
               Expression RESULT = null;
                 int meleft = (parser_stack.get(parser_top-0)).left;
                 int meright = (parser_stack.get(parser_top-0)).right;
-                Expression me = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression me = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = me;
               parser_result = new Symbol(12/*AdditiveExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2478,14 +2478,14 @@
           case 51: // RelationalExpr ::= RelationalExpr GE AdditiveExpr
             {
               Expression RESULT = null;
                 int releft = (parser_stack.get(parser_top-2)).left;
                 int reright = (parser_stack.get(parser_top-2)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-2)).value;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new RelationalExpr(Operators.GE, re, ae);
               parser_result = new Symbol(11/*RelationalExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2493,14 +2493,14 @@
           case 50: // RelationalExpr ::= RelationalExpr LE AdditiveExpr
             {
               Expression RESULT = null;
                 int releft = (parser_stack.get(parser_top-2)).left;
                 int reright = (parser_stack.get(parser_top-2)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-2)).value;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new RelationalExpr(Operators.LE, re, ae);
               parser_result = new Symbol(11/*RelationalExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2508,14 +2508,14 @@
           case 49: // RelationalExpr ::= RelationalExpr GT AdditiveExpr
             {
               Expression RESULT = null;
                 int releft = (parser_stack.get(parser_top-2)).left;
                 int reright = (parser_stack.get(parser_top-2)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-2)).value;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new RelationalExpr(Operators.GT, re, ae);
               parser_result = new Symbol(11/*RelationalExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2523,14 +2523,14 @@
           case 48: // RelationalExpr ::= RelationalExpr LT AdditiveExpr
             {
               Expression RESULT = null;
                 int releft = (parser_stack.get(parser_top-2)).left;
                 int reright = (parser_stack.get(parser_top-2)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-2)).value;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new RelationalExpr(Operators.LT, re, ae);
               parser_result = new Symbol(11/*RelationalExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2538,11 +2538,11 @@
           case 47: // RelationalExpr ::= AdditiveExpr
             {
               Expression RESULT = null;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ae;
               parser_result = new Symbol(11/*RelationalExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2550,14 +2550,14 @@
           case 46: // EqualityExpr ::= EqualityExpr NE RelationalExpr
             {
               Expression RESULT = null;
                 int eeleft = (parser_stack.get(parser_top-2)).left;
                 int eeright = (parser_stack.get(parser_top-2)).right;
-                Expression ee = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression ee = (Expression)(parser_stack.get(parser_top-2)).value;
                 int releft = (parser_stack.get(parser_top-0)).left;
                 int reright = (parser_stack.get(parser_top-0)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new EqualityExpr(Operators.NE, ee, re);
               parser_result = new Symbol(10/*EqualityExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2565,14 +2565,14 @@
           case 45: // EqualityExpr ::= EqualityExpr EQ RelationalExpr
             {
               Expression RESULT = null;
                 int eeleft = (parser_stack.get(parser_top-2)).left;
                 int eeright = (parser_stack.get(parser_top-2)).right;
-                Expression ee = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression ee = (Expression)(parser_stack.get(parser_top-2)).value;
                 int releft = (parser_stack.get(parser_top-0)).left;
                 int reright = (parser_stack.get(parser_top-0)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new EqualityExpr(Operators.EQ, ee, re);
               parser_result = new Symbol(10/*EqualityExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2580,11 +2580,11 @@
           case 44: // EqualityExpr ::= RelationalExpr
             {
               Expression RESULT = null;
                 int releft = (parser_stack.get(parser_top-0)).left;
                 int reright = (parser_stack.get(parser_top-0)).right;
-                Expression re = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression re = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = re;
               parser_result = new Symbol(10/*EqualityExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2592,14 +2592,14 @@
           case 43: // AndExpr ::= AndExpr AND EqualityExpr
             {
               Expression RESULT = null;
                 int aeleft = (parser_stack.get(parser_top-2)).left;
                 int aeright = (parser_stack.get(parser_top-2)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-2)).value;
                 int eeleft = (parser_stack.get(parser_top-0)).left;
                 int eeright = (parser_stack.get(parser_top-0)).right;
-                Expression ee = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ee = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new LogicalExpr(LogicalExpr.AND, ae, ee);
               parser_result = new Symbol(9/*AndExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2607,11 +2607,11 @@
           case 42: // AndExpr ::= EqualityExpr
             {
               Expression RESULT = null;
                 int eleft = (parser_stack.get(parser_top-0)).left;
                 int eright = (parser_stack.get(parser_top-0)).right;
-                Expression e = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression e = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = e;
               parser_result = new Symbol(9/*AndExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2619,14 +2619,14 @@
           case 41: // OrExpr ::= OrExpr OR AndExpr
             {
               Expression RESULT = null;
                 int oeleft = (parser_stack.get(parser_top-2)).left;
                 int oeright = (parser_stack.get(parser_top-2)).right;
-                Expression oe = (Expression)((Symbol) parser_stack.get(parser_top-2)).value;
+                Expression oe = (Expression)(parser_stack.get(parser_top-2)).value;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = new LogicalExpr(LogicalExpr.OR, oe, ae);
               parser_result = new Symbol(8/*OrExpr*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2634,11 +2634,11 @@
           case 40: // OrExpr ::= AndExpr
             {
               Expression RESULT = null;
                 int aeleft = (parser_stack.get(parser_top-0)).left;
                 int aeright = (parser_stack.get(parser_top-0)).right;
-                Expression ae = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ae = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ae;
               parser_result = new Symbol(8/*OrExpr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2646,11 +2646,11 @@
           case 39: // Expr ::= OrExpr
             {
               Expression RESULT = null;
                 int exleft = (parser_stack.get(parser_top-0)).left;
                 int exright = (parser_stack.get(parser_top-0)).right;
-                Expression ex = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression ex = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = ex;
               parser_result = new Symbol(2/*Expr*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2658,11 +2658,11 @@
           case 38: // Predicate ::= LBRACK Expr RBRACK
             {
               Expression RESULT = null;
                 int eleft = (parser_stack.get(parser_top-1)).left;
                 int eright = (parser_stack.get(parser_top-1)).right;
-                Expression e = (Expression)((Symbol) parser_stack.get(parser_top-1)).value;
+                Expression e = (Expression)(parser_stack.get(parser_top-1)).value;
 
                 RESULT = new Predicate(e);
 
               parser_result = new Symbol(5/*Predicate*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2672,15 +2672,15 @@
           case 37: // Predicates ::= Predicate Predicates
             {
                 List<Expression> RESULT = null;
                 int pleft = (parser_stack.get(parser_top-1)).left;
                 int pright = (parser_stack.get(parser_top-1)).right;
-                Expression p = (Expression)((Symbol) parser_stack.get(parser_top-1)).value;
+                Expression p = (Expression)(parser_stack.get(parser_top-1)).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Expression> pp = (ArrayList<Expression>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Expression> pp = (ArrayList<Expression>)(parser_stack.get(parser_top-0)).value;
                 pp.add(0, p); RESULT = pp;
               parser_result = new Symbol(35/*Predicates*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2688,11 +2688,11 @@
           case 36: // Predicates ::= Predicate
             {
                 List<Expression> RESULT = null;
                 int pleft = (parser_stack.get(parser_top-0)).left;
                 int pright = (parser_stack.get(parser_top-0)).right;
-                Expression p = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression p = (Expression)(parser_stack.get(parser_top-0)).value;
 
                 List<Expression> temp = new ArrayList<>();
                 temp.add(p);
                 RESULT = temp;
 

@@ -2731,11 +2731,11 @@
           case 32: // NameTestPattern ::= QName
             {
               Object RESULT = null;
                 int qnleft = (parser_stack.get(parser_top-0)).left;
                 int qnright = (parser_stack.get(parser_top-0)).right;
-                QName qn = (QName)((Symbol) parser_stack.get(parser_top-0)).value;
+                QName qn = (QName)(parser_stack.get(parser_top-0)).value;
                  RESULT = qn;
               parser_result = new Symbol(34/*NameTestPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2788,11 +2788,11 @@
           case 26: // NodeTestPattern ::= NameTestPattern
             {
               Object RESULT = null;
                 int ntleft = (parser_stack.get(parser_top-0)).left;
                 int ntright = (parser_stack.get(parser_top-0)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object nt = parser_stack.get(parser_top-0).value;
                  RESULT = nt;
               parser_result = new Symbol(33/*NodeTestPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2800,18 +2800,18 @@
           case 25: // StepPattern ::= ChildOrAttributeAxisSpecifier ProcessingInstructionPattern Predicates
             {
               StepPattern RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-2)).left;
                 int axisright = (parser_stack.get(parser_top-2)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-2)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-2)).value;
                 int pipleft = (parser_stack.get(parser_top-1)).left;
                 int pipright = (parser_stack.get(parser_top-1)).right;
-                StepPattern pip = (StepPattern)((Symbol) parser_stack.get(parser_top-1)).value;
+                StepPattern pip = (StepPattern)(parser_stack.get(parser_top-1)).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Predicate> pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Predicate> pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
 
                // TODO: report error if axis is attribute
                RESULT = (ProcessingInstructionPattern)pip.setPredicates(pp);
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);

@@ -2822,14 +2822,14 @@
           case 24: // StepPattern ::= ChildOrAttributeAxisSpecifier ProcessingInstructionPattern
             {
               StepPattern RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-1)).left;
                 int axisright = (parser_stack.get(parser_top-1)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-1)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-1)).value;
                 int pipleft = (parser_stack.get(parser_top-0)).left;
                 int pipright = (parser_stack.get(parser_top-0)).right;
-                StepPattern pip = (StepPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                StepPattern pip = (StepPattern)(parser_stack.get(parser_top-0)).value;
 
                RESULT = pip;    // TODO: report error if axis is attribute
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2839,18 +2839,18 @@
           case 23: // StepPattern ::= ChildOrAttributeAxisSpecifier NodeTestPattern Predicates
             {
               StepPattern RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-2)).left;
                 int axisright = (parser_stack.get(parser_top-2)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-2)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-2)).value;
                 int ntleft = (parser_stack.get(parser_top-1)).left;
                 int ntright = (parser_stack.get(parser_top-1)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-1)).value;
+                Object nt = parser_stack.get(parser_top-1).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-               List<Predicate>pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+               List<Predicate>pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
 
                RESULT = parser.createStepPattern(axis.intValue(), nt, pp);
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2860,14 +2860,14 @@
           case 22: // StepPattern ::= ChildOrAttributeAxisSpecifier NodeTestPattern
             {
               StepPattern RESULT = null;
                 int axisleft = (parser_stack.get(parser_top-1)).left;
                 int axisright = (parser_stack.get(parser_top-1)).right;
-                Integer axis = (Integer)((Symbol) parser_stack.get(parser_top-1)).value;
+                Integer axis = (Integer)(parser_stack.get(parser_top-1)).value;
                 int ntleft = (parser_stack.get(parser_top-0)).left;
                 int ntright = (parser_stack.get(parser_top-0)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object nt = parser_stack.get(parser_top-0).value;
 
                RESULT = parser.createStepPattern(axis.intValue(), nt, null);
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2877,15 +2877,15 @@
           case 21: // StepPattern ::= ProcessingInstructionPattern Predicates
             {
               StepPattern RESULT = null;
                 int pipleft = (parser_stack.get(parser_top-1)).left;
                 int pipright = (parser_stack.get(parser_top-1)).right;
-                StepPattern pip = (StepPattern)((Symbol) parser_stack.get(parser_top-1)).value;
+                StepPattern pip = (StepPattern)(parser_stack.get(parser_top-1)).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Predicate> pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Predicate> pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
                  RESULT = (ProcessingInstructionPattern)pip.setPredicates(pp);
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2893,11 +2893,11 @@
           case 20: // StepPattern ::= ProcessingInstructionPattern
             {
               StepPattern RESULT = null;
                 int pipleft = (parser_stack.get(parser_top-0)).left;
                 int pipright = (parser_stack.get(parser_top-0)).right;
-                StepPattern pip = (StepPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                StepPattern pip = (StepPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = pip;
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2905,15 +2905,15 @@
           case 19: // StepPattern ::= NodeTestPattern Predicates
             {
               StepPattern RESULT = null;
                 int ntleft = (parser_stack.get(parser_top-1)).left;
                 int ntright = (parser_stack.get(parser_top-1)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-1)).value;
+                Object nt = parser_stack.get(parser_top-1).value;
                 int ppleft = (parser_stack.get(parser_top-0)).left;
                 int ppright = (parser_stack.get(parser_top-0)).right;
                 @SuppressWarnings("unchecked")
-                List<Predicate> pp = (ArrayList<Predicate>)((Symbol) parser_stack.get(parser_top-0)).value;
+                List<Predicate> pp = (ArrayList<Predicate>)(parser_stack.get(parser_top-0)).value;
 
                 RESULT = parser.createStepPattern(Axis.CHILD, nt, pp);
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2923,11 +2923,11 @@
           case 18: // StepPattern ::= NodeTestPattern
             {
               StepPattern RESULT = null;
                 int ntleft = (parser_stack.get(parser_top-0)).left;
                 int ntright = (parser_stack.get(parser_top-0)).right;
-                Object nt = (Object)((Symbol) parser_stack.get(parser_top-0)).value;
+                Object nt = parser_stack.get(parser_top-0).value;
 
                 RESULT = parser.createStepPattern(Axis.CHILD, nt, null);
 
               parser_result = new Symbol(32/*StepPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -2937,14 +2937,14 @@
           case 17: // RelativePathPattern ::= StepPattern DSLASH RelativePathPattern
             {
               RelativePathPattern RESULT = null;
                 int spleft = (parser_stack.get(parser_top-2)).left;
                 int spright = (parser_stack.get(parser_top-2)).right;
-                StepPattern sp = (StepPattern)((Symbol) parser_stack.get(parser_top-2)).value;
+                StepPattern sp = (StepPattern)(parser_stack.get(parser_top-2)).value;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AncestorPattern(sp, rpp);
               parser_result = new Symbol(31/*RelativePathPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2952,14 +2952,14 @@
           case 16: // RelativePathPattern ::= StepPattern SLASH RelativePathPattern
             {
               RelativePathPattern RESULT = null;
                 int spleft = (parser_stack.get(parser_top-2)).left;
                 int spright = (parser_stack.get(parser_top-2)).right;
-                StepPattern sp = (StepPattern)((Symbol) parser_stack.get(parser_top-2)).value;
+                StepPattern sp = (StepPattern)(parser_stack.get(parser_top-2)).value;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new ParentPattern(sp, rpp);
               parser_result = new Symbol(31/*RelativePathPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2967,11 +2967,11 @@
           case 15: // RelativePathPattern ::= StepPattern
             {
               RelativePathPattern RESULT = null;
                 int spleft = (parser_stack.get(parser_top-0)).left;
                 int spright = (parser_stack.get(parser_top-0)).right;
-                StepPattern sp = (StepPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                StepPattern sp = (StepPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = sp;
               parser_result = new Symbol(31/*RelativePathPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2979,11 +2979,11 @@
           case 14: // ProcessingInstructionPattern ::= PIPARAM LPAREN Literal RPAREN
             {
               StepPattern RESULT = null;
                 int lleft = (parser_stack.get(parser_top-1)).left;
                 int lright = (parser_stack.get(parser_top-1)).right;
-                String l = (String)((Symbol) parser_stack.get(parser_top-1)).value;
+                String l = (String)(parser_stack.get(parser_top-1)).value;
                  RESULT = new ProcessingInstructionPattern(l);
               parser_result = new Symbol(30/*ProcessingInstructionPattern*/, (parser_stack.get(parser_top-3)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -2991,14 +2991,14 @@
           case 13: // IdKeyPattern ::= KEY LPAREN Literal COMMA Literal RPAREN
             {
               IdKeyPattern RESULT = null;
                 int l1left = (parser_stack.get(parser_top-3)).left;
                 int l1right = (parser_stack.get(parser_top-3)).right;
-                String l1 = (String)((Symbol) parser_stack.get(parser_top-3)).value;
+                String l1 = (String)(parser_stack.get(parser_top-3)).value;
                 int l2left = (parser_stack.get(parser_top-1)).left;
                 int l2right = (parser_stack.get(parser_top-1)).right;
-                String l2 = (String)((Symbol) parser_stack.get(parser_top-1)).value;
+                String l2 = (String)(parser_stack.get(parser_top-1)).value;
                  RESULT = new KeyPattern(l1, l2);
               parser_result = new Symbol(27/*IdKeyPattern*/, (parser_stack.get(parser_top-5)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3006,11 +3006,11 @@
           case 12: // IdKeyPattern ::= ID LPAREN Literal RPAREN
             {
               IdKeyPattern RESULT = null;
                 int lleft = (parser_stack.get(parser_top-1)).left;
                 int lright = (parser_stack.get(parser_top-1)).right;
-                String l = (String)((Symbol) parser_stack.get(parser_top-1)).value;
+                String l = (String)(parser_stack.get(parser_top-1)).value;
                  RESULT = new IdPattern(l);
                parser.setHasIdCall(true);
 
               parser_result = new Symbol(27/*IdKeyPattern*/, (parser_stack.get(parser_top-3)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }

@@ -3020,11 +3020,11 @@
           case 11: // LocationPathPattern ::= RelativePathPattern
             {
               Pattern RESULT = null;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = rpp;
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3032,11 +3032,11 @@
           case 10: // LocationPathPattern ::= DSLASH RelativePathPattern
             {
               Pattern RESULT = null;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AncestorPattern(rpp);
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3044,14 +3044,14 @@
           case 9: // LocationPathPattern ::= IdKeyPattern DSLASH RelativePathPattern
             {
               Pattern RESULT = null;
                 int ikpleft = (parser_stack.get(parser_top-2)).left;
                 int ikpright = (parser_stack.get(parser_top-2)).right;
-                IdKeyPattern ikp = (IdKeyPattern)((Symbol) parser_stack.get(parser_top-2)).value;
+                IdKeyPattern ikp = (IdKeyPattern)(parser_stack.get(parser_top-2)).value;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AncestorPattern(ikp, rpp);
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3059,14 +3059,14 @@
           case 8: // LocationPathPattern ::= IdKeyPattern SLASH RelativePathPattern
             {
               Pattern RESULT = null;
                 int ikpleft = (parser_stack.get(parser_top-2)).left;
                 int ikpright = (parser_stack.get(parser_top-2)).right;
-                IdKeyPattern ikp = (IdKeyPattern)((Symbol) parser_stack.get(parser_top-2)).value;
+                IdKeyPattern ikp = (IdKeyPattern)(parser_stack.get(parser_top-2)).value;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new ParentPattern(ikp, rpp);
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3074,11 +3074,11 @@
           case 7: // LocationPathPattern ::= IdKeyPattern
             {
               Pattern RESULT = null;
                 int ikpleft = (parser_stack.get(parser_top-0)).left;
                 int ikpright = (parser_stack.get(parser_top-0)).right;
-                IdKeyPattern ikp = (IdKeyPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                IdKeyPattern ikp = (IdKeyPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = ikp;
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3086,11 +3086,11 @@
           case 6: // LocationPathPattern ::= SLASH RelativePathPattern
             {
               Pattern RESULT = null;
                 int rppleft = (parser_stack.get(parser_top-0)).left;
                 int rppright = (parser_stack.get(parser_top-0)).right;
-                RelativePathPattern rpp = (RelativePathPattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                RelativePathPattern rpp = (RelativePathPattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AbsolutePathPattern(rpp);
               parser_result = new Symbol(29/*LocationPathPattern*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3107,14 +3107,14 @@
           case 4: // Pattern ::= LocationPathPattern VBAR Pattern
             {
               Pattern RESULT = null;
                 int lppleft = (parser_stack.get(parser_top-2)).left;
                 int lppright = (parser_stack.get(parser_top-2)).right;
-                Pattern lpp = (Pattern)((Symbol) parser_stack.get(parser_top-2)).value;
+                Pattern lpp = (Pattern)(parser_stack.get(parser_top-2)).value;
                 int pleft = (parser_stack.get(parser_top-0)).left;
                 int pright = (parser_stack.get(parser_top-0)).right;
-                Pattern p = (Pattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                Pattern p = (Pattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = new AlternativePattern(lpp, p);
               parser_result = new Symbol(28/*Pattern*/, (parser_stack.get(parser_top-2)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3122,11 +3122,11 @@
           case 3: // Pattern ::= LocationPathPattern
             {
               Pattern RESULT = null;
                 int lppleft = (parser_stack.get(parser_top-0)).left;
                 int lppright = (parser_stack.get(parser_top-0)).right;
-                Pattern lpp = (Pattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                Pattern lpp = (Pattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = lpp;
               parser_result = new Symbol(28/*Pattern*/, (parser_stack.get(parser_top-0)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3134,11 +3134,11 @@
           case 2: // TopLevel ::= EXPRESSION Expr
             {
               SyntaxTreeNode RESULT = null;
                 int exprleft = (parser_stack.get(parser_top-0)).left;
                 int exprright = (parser_stack.get(parser_top-0)).right;
-                Expression expr = (Expression)((Symbol) parser_stack.get(parser_top-0)).value;
+                Expression expr = (Expression)(parser_stack.get(parser_top-0)).value;
                  RESULT = expr;
               parser_result = new Symbol(1/*TopLevel*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3146,11 +3146,11 @@
           case 1: // TopLevel ::= PATTERN Pattern
             {
               SyntaxTreeNode RESULT = null;
                 int patternleft = (parser_stack.get(parser_top-0)).left;
                 int patternright = (parser_stack.get(parser_top-0)).right;
-                Pattern pattern = (Pattern)((Symbol) parser_stack.get(parser_top-0)).value;
+                Pattern pattern = (Pattern)(parser_stack.get(parser_top-0)).value;
                  RESULT = pattern;
               parser_result = new Symbol(1/*TopLevel*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           return parser_result;
 

@@ -3158,11 +3158,11 @@
           case 0: // $START ::= TopLevel EOF
             {
               Object RESULT = null;
                 int start_valleft = (parser_stack.get(parser_top-1)).left;
                 int start_valright = (parser_stack.get(parser_top-1)).right;
-                SyntaxTreeNode start_val = (SyntaxTreeNode)((Symbol) parser_stack.get(parser_top-1)).value;
+                SyntaxTreeNode start_val = (SyntaxTreeNode)(parser_stack.get(parser_top-1)).value;
                 RESULT = start_val;
               parser_result = new Symbol(0/*$START*/, (parser_stack.get(parser_top-1)).left, (parser_stack.get(parser_top-0)).right, RESULT);
             }
           /* ACCEPT */
           parser_parser.done_parsing();
< prev index next >