X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.basicexpression%2Fsrc%2Forg%2Fsimantics%2Fbasicexpression%2Fparser%2FParser.java;fp=bundles%2Forg.simantics.basicexpression%2Fsrc%2Forg%2Fsimantics%2Fbasicexpression%2Fparser%2FParser.java;h=7fe8f4afe0aac9a14e02da786082faaba88100ad;hp=0000000000000000000000000000000000000000;hb=969bd23cab98a79ca9101af33334000879fb60c5;hpb=866dba5cd5a3929bbeae85991796acb212338a08 diff --git a/bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/parser/Parser.java b/bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/parser/Parser.java new file mode 100644 index 000000000..7fe8f4afe --- /dev/null +++ b/bundles/org.simantics.basicexpression/src/org/simantics/basicexpression/parser/Parser.java @@ -0,0 +1,994 @@ +/* This file was generated by SableCC (http://www.sablecc.org/). */ + +package org.simantics.basicexpression.parser; + +import org.simantics.basicexpression.lexer.*; +import org.simantics.basicexpression.node.*; +import org.simantics.basicexpression.analysis.*; +import java.util.*; + +import java.io.DataInputStream; +import java.io.BufferedInputStream; +import java.io.IOException; + +@SuppressWarnings("nls") +public class Parser +{ + public final Analysis ignoredTokens = new AnalysisAdapter(); + + protected ArrayList nodeList; + + private final Lexer lexer; + private final ListIterator stack = new LinkedList().listIterator(); + private int last_pos; + private int last_line; + private Token last_token; + private final TokenIndex converter = new TokenIndex(); + private final int[] action = new int[2]; + + private final static int SHIFT = 0; + private final static int REDUCE = 1; + private final static int ACCEPT = 2; + private final static int ERROR = 3; + + public Parser(@SuppressWarnings("hiding") Lexer lexer) + { + this.lexer = lexer; + } + + protected void filter() throws ParserException, LexerException, IOException + { + // Empty body + } + + private void push(int numstate, ArrayList listNode, boolean hidden) throws ParserException, LexerException, IOException + { + this.nodeList = listNode; + + if(!hidden) + { + filter(); + } + + if(!this.stack.hasNext()) + { + this.stack.add(new State(numstate, this.nodeList)); + return; + } + + State s = (State) this.stack.next(); + s.state = numstate; + s.nodes = this.nodeList; + } + + private int goTo(int index) + { + int state = state(); + int low = 1; + int high = gotoTable[index].length - 1; + int value = gotoTable[index][0][1]; + + while(low <= high) + { + int middle = (low + high) / 2; + + if(state < gotoTable[index][middle][0]) + { + high = middle - 1; + } + else if(state > gotoTable[index][middle][0]) + { + low = middle + 1; + } + else + { + value = gotoTable[index][middle][1]; + break; + } + } + + return value; + } + + private int state() + { + State s = (State) this.stack.previous(); + this.stack.next(); + return s.state; + } + + private ArrayList pop() + { + return ((State) this.stack.previous()).nodes; + } + + private int index(Switchable token) + { + this.converter.index = -1; + token.apply(this.converter); + return this.converter.index; + } + + @SuppressWarnings("unchecked") + public Start parse() throws ParserException, LexerException, IOException + { + push(0, null, true); + List ign = null; + while(true) + { + while(index(this.lexer.peek()) == -1) + { + if(ign == null) + { + ign = new LinkedList(); + } + + ign.add(this.lexer.next()); + } + + if(ign != null) + { + this.ignoredTokens.setIn(this.lexer.peek(), ign); + ign = null; + } + + this.last_pos = this.lexer.peek().getPos(); + this.last_line = this.lexer.peek().getLine(); + this.last_token = this.lexer.peek(); + + int index = index(this.lexer.peek()); + this.action[0] = Parser.actionTable[state()][0][1]; + this.action[1] = Parser.actionTable[state()][0][2]; + + int low = 1; + int high = Parser.actionTable[state()].length - 1; + + while(low <= high) + { + int middle = (low + high) / 2; + + if(index < Parser.actionTable[state()][middle][0]) + { + high = middle - 1; + } + else if(index > Parser.actionTable[state()][middle][0]) + { + low = middle + 1; + } + else + { + this.action[0] = Parser.actionTable[state()][middle][1]; + this.action[1] = Parser.actionTable[state()][middle][2]; + break; + } + } + + switch(this.action[0]) + { + case SHIFT: + { + ArrayList list = new ArrayList(); + list.add(this.lexer.next()); + push(this.action[1], list, false); + } + break; + case REDUCE: + switch(this.action[1]) + { + case 0: /* reduce AMultExpression */ + { + ArrayList list = new0(); + push(goTo(0), list, false); + } + break; + case 1: /* reduce APlusExpression */ + { + ArrayList list = new1(); + push(goTo(0), list, false); + } + break; + case 2: /* reduce AMinusExpression */ + { + ArrayList list = new2(); + push(goTo(0), list, false); + } + break; + case 3: /* reduce AUnaryMultiplicative */ + { + ArrayList list = new3(); + push(goTo(1), list, false); + } + break; + case 4: /* reduce AMultMultiplicative */ + { + ArrayList list = new4(); + push(goTo(1), list, false); + } + break; + case 5: /* reduce ADivMultiplicative */ + { + ArrayList list = new5(); + push(goTo(1), list, false); + } + break; + case 6: /* reduce APrimaryUnary */ + { + ArrayList list = new6(); + push(goTo(2), list, false); + } + break; + case 7: /* reduce AUnaryplusUnary */ + { + ArrayList list = new7(); + push(goTo(2), list, false); + } + break; + case 8: /* reduce AUnaryminusUnary */ + { + ArrayList list = new8(); + push(goTo(2), list, false); + } + break; + case 9: /* reduce ASingleArgList */ + { + ArrayList list = new9(); + push(goTo(3), list, false); + } + break; + case 10: /* reduce ASequenceArgList */ + { + ArrayList list = new10(); + push(goTo(3), list, false); + } + break; + case 11: /* reduce AValuePrimary */ + { + ArrayList list = new11(); + push(goTo(4), list, false); + } + break; + case 12: /* reduce AVariablePrimary */ + { + ArrayList list = new12(); + push(goTo(4), list, false); + } + break; + case 13: /* reduce AAfunctionprimary1Primary */ + { + ArrayList list = new13(); + push(goTo(4), list, false); + } + break; + case 14: /* reduce AAfunctionprimary2Primary */ + { + ArrayList list = new14(); + push(goTo(4), list, false); + } + break; + case 15: /* reduce ASingleRange */ + { + ArrayList list = new15(); + push(goTo(5), list, false); + } + break; + case 16: /* reduce AMultiRange */ + { + ArrayList list = new16(); + push(goTo(5), list, false); + } + break; + case 17: /* reduce ARviValue */ + { + ArrayList list = new17(); + push(goTo(6), list, false); + } + break; + case 18: /* reduce AStringValue */ + { + ArrayList list = new18(); + push(goTo(6), list, false); + } + break; + case 19: /* reduce AConstantValue */ + { + ArrayList list = new19(); + push(goTo(6), list, false); + } + break; + case 20: /* reduce ARangeValue */ + { + ArrayList list = new20(); + push(goTo(6), list, false); + } + break; + case 21: /* reduce AAddressValue */ + { + ArrayList list = new21(); + push(goTo(6), list, false); + } + break; + case 22: /* reduce AExprValue */ + { + ArrayList list = new22(); + push(goTo(6), list, false); + } + break; + } + break; + case ACCEPT: + { + EOF node2 = (EOF) this.lexer.next(); + PExpression node1 = (PExpression) pop().get(0); + Start node = new Start(node1, node2); + return node; + } + case ERROR: + throw new ParserException(this.last_token, + "[" + this.last_line + "," + this.last_pos + "] " + + Parser.errorMessages[Parser.errors[this.action[1]]]); + } + } + } + + + + @SuppressWarnings("unchecked") + ArrayList new0() /* reduce AMultExpression */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PExpression pexpressionNode1; + { + // Block + PMultiplicative pmultiplicativeNode2; + pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0); + + pexpressionNode1 = new AMultExpression(pmultiplicativeNode2); + } + nodeList.add(pexpressionNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new1() /* reduce APlusExpression */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PExpression pexpressionNode1; + { + // Block + PExpression pexpressionNode2; + TPlus tplusNode3; + PMultiplicative pmultiplicativeNode4; + pexpressionNode2 = (PExpression)nodeArrayList1.get(0); + tplusNode3 = (TPlus)nodeArrayList2.get(0); + pmultiplicativeNode4 = (PMultiplicative)nodeArrayList3.get(0); + + pexpressionNode1 = new APlusExpression(pexpressionNode2, tplusNode3, pmultiplicativeNode4); + } + nodeList.add(pexpressionNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new2() /* reduce AMinusExpression */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PExpression pexpressionNode1; + { + // Block + PExpression pexpressionNode2; + TMinus tminusNode3; + PMultiplicative pmultiplicativeNode4; + pexpressionNode2 = (PExpression)nodeArrayList1.get(0); + tminusNode3 = (TMinus)nodeArrayList2.get(0); + pmultiplicativeNode4 = (PMultiplicative)nodeArrayList3.get(0); + + pexpressionNode1 = new AMinusExpression(pexpressionNode2, tminusNode3, pmultiplicativeNode4); + } + nodeList.add(pexpressionNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new3() /* reduce AUnaryMultiplicative */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PMultiplicative pmultiplicativeNode1; + { + // Block + PUnary punaryNode2; + punaryNode2 = (PUnary)nodeArrayList1.get(0); + + pmultiplicativeNode1 = new AUnaryMultiplicative(punaryNode2); + } + nodeList.add(pmultiplicativeNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new4() /* reduce AMultMultiplicative */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PMultiplicative pmultiplicativeNode1; + { + // Block + PMultiplicative pmultiplicativeNode2; + TMult tmultNode3; + PUnary punaryNode4; + pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0); + tmultNode3 = (TMult)nodeArrayList2.get(0); + punaryNode4 = (PUnary)nodeArrayList3.get(0); + + pmultiplicativeNode1 = new AMultMultiplicative(pmultiplicativeNode2, tmultNode3, punaryNode4); + } + nodeList.add(pmultiplicativeNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new5() /* reduce ADivMultiplicative */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PMultiplicative pmultiplicativeNode1; + { + // Block + PMultiplicative pmultiplicativeNode2; + TDiv tdivNode3; + PUnary punaryNode4; + pmultiplicativeNode2 = (PMultiplicative)nodeArrayList1.get(0); + tdivNode3 = (TDiv)nodeArrayList2.get(0); + punaryNode4 = (PUnary)nodeArrayList3.get(0); + + pmultiplicativeNode1 = new ADivMultiplicative(pmultiplicativeNode2, tdivNode3, punaryNode4); + } + nodeList.add(pmultiplicativeNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new6() /* reduce APrimaryUnary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PUnary punaryNode1; + { + // Block + PPrimary pprimaryNode2; + pprimaryNode2 = (PPrimary)nodeArrayList1.get(0); + + punaryNode1 = new APrimaryUnary(pprimaryNode2); + } + nodeList.add(punaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new7() /* reduce AUnaryplusUnary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PUnary punaryNode1; + { + // Block + TPlus tplusNode2; + PUnary punaryNode3; + tplusNode2 = (TPlus)nodeArrayList1.get(0); + punaryNode3 = (PUnary)nodeArrayList2.get(0); + + punaryNode1 = new AUnaryplusUnary(tplusNode2, punaryNode3); + } + nodeList.add(punaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new8() /* reduce AUnaryminusUnary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PUnary punaryNode1; + { + // Block + TMinus tminusNode2; + PUnary punaryNode3; + tminusNode2 = (TMinus)nodeArrayList1.get(0); + punaryNode3 = (PUnary)nodeArrayList2.get(0); + + punaryNode1 = new AUnaryminusUnary(tminusNode2, punaryNode3); + } + nodeList.add(punaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new9() /* reduce ASingleArgList */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PArgList parglistNode1; + { + // Block + PExpression pexpressionNode2; + pexpressionNode2 = (PExpression)nodeArrayList1.get(0); + + parglistNode1 = new ASingleArgList(pexpressionNode2); + } + nodeList.add(parglistNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new10() /* reduce ASequenceArgList */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PArgList parglistNode1; + { + // Block + PArgList parglistNode2; + TComma tcommaNode3; + PExpression pexpressionNode4; + parglistNode2 = (PArgList)nodeArrayList1.get(0); + tcommaNode3 = (TComma)nodeArrayList2.get(0); + pexpressionNode4 = (PExpression)nodeArrayList3.get(0); + + parglistNode1 = new ASequenceArgList(parglistNode2, tcommaNode3, pexpressionNode4); + } + nodeList.add(parglistNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new11() /* reduce AValuePrimary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PPrimary pprimaryNode1; + { + // Block + PValue pvalueNode2; + pvalueNode2 = (PValue)nodeArrayList1.get(0); + + pprimaryNode1 = new AValuePrimary(pvalueNode2); + } + nodeList.add(pprimaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new12() /* reduce AVariablePrimary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PPrimary pprimaryNode1; + { + // Block + TVariable tvariableNode2; + tvariableNode2 = (TVariable)nodeArrayList1.get(0); + + pprimaryNode1 = new AVariablePrimary(tvariableNode2); + } + nodeList.add(pprimaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new13() /* reduce AAfunctionprimary1Primary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PPrimary pprimaryNode1; + { + // Block + TFunc tfuncNode2; + @SuppressWarnings("unused") Object nullNode3 = null; + TRPar trparNode4; + tfuncNode2 = (TFunc)nodeArrayList1.get(0); + trparNode4 = (TRPar)nodeArrayList2.get(0); + + pprimaryNode1 = new AFunctionPrimary(tfuncNode2, null, trparNode4); + } + nodeList.add(pprimaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new14() /* reduce AAfunctionprimary2Primary */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PPrimary pprimaryNode1; + { + // Block + TFunc tfuncNode2; + PArgList parglistNode3; + TRPar trparNode4; + tfuncNode2 = (TFunc)nodeArrayList1.get(0); + parglistNode3 = (PArgList)nodeArrayList2.get(0); + trparNode4 = (TRPar)nodeArrayList3.get(0); + + pprimaryNode1 = new AFunctionPrimary(tfuncNode2, parglistNode3, trparNode4); + } + nodeList.add(pprimaryNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new15() /* reduce ASingleRange */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PRange prangeNode1; + { + // Block + TCell tcellNode2; + tcellNode2 = (TCell)nodeArrayList1.get(0); + + prangeNode1 = new ASingleRange(tcellNode2); + } + nodeList.add(prangeNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new16() /* reduce AMultiRange */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PRange prangeNode1; + { + // Block + TCell tcellNode2; + TColon tcolonNode3; + TCell tcellNode4; + tcellNode2 = (TCell)nodeArrayList1.get(0); + tcolonNode3 = (TColon)nodeArrayList2.get(0); + tcellNode4 = (TCell)nodeArrayList3.get(0); + + prangeNode1 = new AMultiRange(tcellNode2, tcolonNode3, tcellNode4); + } + nodeList.add(prangeNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new17() /* reduce ARviValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + TRvi trviNode2; + trviNode2 = (TRvi)nodeArrayList1.get(0); + + pvalueNode1 = new ARviValue(trviNode2); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new18() /* reduce AStringValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + TString tstringNode2; + tstringNode2 = (TString)nodeArrayList1.get(0); + + pvalueNode1 = new AStringValue(tstringNode2); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new19() /* reduce AConstantValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + TNumber tnumberNode2; + tnumberNode2 = (TNumber)nodeArrayList1.get(0); + + pvalueNode1 = new AConstantValue(tnumberNode2); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new20() /* reduce ARangeValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + PRange prangeNode2; + prangeNode2 = (PRange)nodeArrayList1.get(0); + + pvalueNode1 = new ARangeValue(prangeNode2); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new21() /* reduce AAddressValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + TAmpersand tampersandNode2; + PRange prangeNode3; + tampersandNode2 = (TAmpersand)nodeArrayList1.get(0); + prangeNode3 = (PRange)nodeArrayList2.get(0); + + pvalueNode1 = new AAddressValue(tampersandNode2, prangeNode3); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + @SuppressWarnings("unchecked") + ArrayList new22() /* reduce AExprValue */ + { + @SuppressWarnings("hiding") ArrayList nodeList = new ArrayList(); + + @SuppressWarnings("unused") ArrayList nodeArrayList3 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList2 = pop(); + @SuppressWarnings("unused") ArrayList nodeArrayList1 = pop(); + PValue pvalueNode1; + { + // Block + TLPar tlparNode2; + PExpression pexpressionNode3; + TRPar trparNode4; + tlparNode2 = (TLPar)nodeArrayList1.get(0); + pexpressionNode3 = (PExpression)nodeArrayList2.get(0); + trparNode4 = (TRPar)nodeArrayList3.get(0); + + pvalueNode1 = new AExprValue(tlparNode2, pexpressionNode3, trparNode4); + } + nodeList.add(pvalueNode1); + return nodeList; + } + + + + private static int[][][] actionTable; +/* { + {{-1, ERROR, 0}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 1}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 2}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 3}, {14, SHIFT, 7}, }, + {{-1, ERROR, 4}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, REDUCE, 12}, }, + {{-1, ERROR, 6}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {11, SHIFT, 21}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, REDUCE, 15}, {9, SHIFT, 24}, }, + {{-1, REDUCE, 17}, }, + {{-1, REDUCE, 19}, }, + {{-1, REDUCE, 18}, }, + {{-1, ERROR, 11}, {3, SHIFT, 25}, {4, SHIFT, 26}, {19, ACCEPT, -1}, }, + {{-1, REDUCE, 0}, {5, SHIFT, 27}, {6, SHIFT, 28}, }, + {{-1, REDUCE, 3}, }, + {{-1, REDUCE, 6}, }, + {{-1, REDUCE, 20}, }, + {{-1, REDUCE, 11}, }, + {{-1, REDUCE, 7}, }, + {{-1, REDUCE, 8}, }, + {{-1, REDUCE, 21}, }, + {{-1, ERROR, 20}, {3, SHIFT, 25}, {4, SHIFT, 26}, {11, SHIFT, 29}, }, + {{-1, REDUCE, 13}, }, + {{-1, REDUCE, 9}, {3, SHIFT, 25}, {4, SHIFT, 26}, }, + {{-1, ERROR, 23}, {8, SHIFT, 30}, {11, SHIFT, 31}, }, + {{-1, ERROR, 24}, {14, SHIFT, 32}, }, + {{-1, ERROR, 25}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 26}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 27}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, ERROR, 28}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, REDUCE, 22}, }, + {{-1, ERROR, 30}, {3, SHIFT, 1}, {4, SHIFT, 2}, {7, SHIFT, 3}, {10, SHIFT, 4}, {12, SHIFT, 5}, {13, SHIFT, 6}, {14, SHIFT, 7}, {15, SHIFT, 8}, {16, SHIFT, 9}, {17, SHIFT, 10}, }, + {{-1, REDUCE, 14}, }, + {{-1, REDUCE, 16}, }, + {{-1, REDUCE, 1}, {5, SHIFT, 27}, {6, SHIFT, 28}, }, + {{-1, REDUCE, 2}, {5, SHIFT, 27}, {6, SHIFT, 28}, }, + {{-1, REDUCE, 4}, }, + {{-1, REDUCE, 5}, }, + {{-1, REDUCE, 10}, {3, SHIFT, 25}, {4, SHIFT, 26}, }, + };*/ + private static int[][][] gotoTable; +/* { + {{-1, 11}, {4, 20}, {6, 22}, {30, 37}, }, + {{-1, 12}, {25, 33}, {26, 34}, }, + {{-1, 13}, {1, 17}, {2, 18}, {27, 35}, {28, 36}, }, + {{-1, 23}, }, + {{-1, 14}, }, + {{-1, 15}, {3, 19}, }, + {{-1, 16}, }, + };*/ + private static String[] errorMessages; +/* { + "expecting: '+', '-', '&', '(', variable, func, cell, rvi, number, string", + "expecting: cell", + "expecting: '+', '-', '*', '/', ',', ')', EOF", + "expecting: '+', '-', '&', '(', ')', variable, func, cell, rvi, number, string", + "expecting: '+', '-', '*', '/', ',', ':', ')', EOF", + "expecting: '+', '-', EOF", + "expecting: '+', '-', ')'", + "expecting: '+', '-', ',', ')'", + "expecting: ',', ')'", + };*/ + private static int[] errors; +/* { + 0, 0, 0, 1, 0, 2, 3, 4, 2, 2, 2, 5, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, 7, 8, 1, 0, 0, 0, 0, 2, 0, 2, 2, 2, 2, 2, 2, 7, + };*/ + + static + { + try + { + DataInputStream s = new DataInputStream( + new BufferedInputStream( + Parser.class.getResourceAsStream("parser.dat"))); + + // read actionTable + int length = s.readInt(); + Parser.actionTable = new int[length][][]; + for(int i = 0; i < Parser.actionTable.length; i++) + { + length = s.readInt(); + Parser.actionTable[i] = new int[length][3]; + for(int j = 0; j < Parser.actionTable[i].length; j++) + { + for(int k = 0; k < 3; k++) + { + Parser.actionTable[i][j][k] = s.readInt(); + } + } + } + + // read gotoTable + length = s.readInt(); + gotoTable = new int[length][][]; + for(int i = 0; i < gotoTable.length; i++) + { + length = s.readInt(); + gotoTable[i] = new int[length][2]; + for(int j = 0; j < gotoTable[i].length; j++) + { + for(int k = 0; k < 2; k++) + { + gotoTable[i][j][k] = s.readInt(); + } + } + } + + // read errorMessages + length = s.readInt(); + errorMessages = new String[length]; + for(int i = 0; i < errorMessages.length; i++) + { + length = s.readInt(); + StringBuffer buffer = new StringBuffer(); + + for(int j = 0; j < length; j++) + { + buffer.append(s.readChar()); + } + errorMessages[i] = buffer.toString(); + } + + // read errors + length = s.readInt(); + errors = new int[length]; + for(int i = 0; i < errors.length; i++) + { + errors[i] = s.readInt(); + } + + s.close(); + } + catch(Exception e) + { + throw new RuntimeException("The file \"parser.dat\" is either missing or corrupted."); + } + } +}