X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Finternal%2Fparsing%2Fparser%2FSCLParser.java;h=6852771b1b8558f107758215e1e557d31dc56cf2;hp=532f6e8a3f62941644a6c57a501e7a13fa08381e;hb=00b73fe170154840ac11c2a9403c6bcd9a0e673a;hpb=0ae2b770234dfc3cbb18bd38f324125cf0faca07 diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/parsing/parser/SCLParser.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/parsing/parser/SCLParser.java index 532f6e8a3..6852771b1 100644 --- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/parsing/parser/SCLParser.java +++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/parsing/parser/SCLParser.java @@ -13,18 +13,18 @@ public abstract class SCLParser { public static final boolean TRACE = false; private static final int INITIAL_CAPACITY = 16; - private static final int STATE_COUNT = 344; - private static final int TERMINAL_COUNT = 82; - private static final int NONTERMINAL_COUNT = 51; - private static final int PRODUCT_COUNT = 132; + private static final int STATE_COUNT = 363; + private static final int TERMINAL_COUNT = 86; + private static final int NONTERMINAL_COUNT = 52; + private static final int PRODUCT_COUNT = 139; private static final int[] ACTION_ROW_ID = new int[STATE_COUNT]; private static final int[] ACTION_COLUMN_ID = new int[TERMINAL_COUNT]; - private static final short[] ACTION_TABLE = new short[6120]; - private static final int[] ERROR_TABLE = new int[882]; + private static final short[] ACTION_TABLE = new short[6765]; + private static final int[] ERROR_TABLE = new int[976]; private static final int[] GOTO_ROW_ID = new int[STATE_COUNT]; private static final int[] GOTO_COLUMN_ID = new int[NONTERMINAL_COUNT]; - private static final short[] GOTO_TABLE = new short[1829]; + private static final short[] GOTO_TABLE = new short[1953]; private static final int[] PRODUCT_LHS = new int[PRODUCT_COUNT]; private static final short STATE_MASK = (short)0x0fff; @@ -38,6 +38,7 @@ public abstract class SCLParser { "SEMICOLON", "LBRACE", "RBRACE", + "MODULE", "COMMA", "HASTYPE", "DATA", @@ -63,6 +64,7 @@ public abstract class SCLParser { "EXTENDS", "MAPPING_RELATION", "FOLLOWS", + "RULESET", "IMPORT", "INCLUDE", "AS", @@ -71,7 +73,6 @@ public abstract class SCLParser { "HIDING", "ARROW", "COLON", - "WITH", "MINUS", "SYMBOL", "LESS", @@ -85,6 +86,7 @@ public abstract class SCLParser { "MATCH", "DO", "MDO", + "EDO", "ENFORCE", "BLANK", "FLOAT", @@ -98,10 +100,12 @@ public abstract class SCLParser { "SELECT_DISTINCT", "TRANSFORMATION", "EQ", + "CHR_SELECT", "ATTACHED_DOT", "IN", "THEN", "ELSE", + "WITH", "RBRACKET", "DOTDOT", "AT", @@ -130,6 +134,7 @@ public abstract class SCLParser { "command", "statement", "declarations", + "field", "var", "bexp", "rhs", @@ -139,26 +144,26 @@ public abstract class SCLParser { "atype", "aexp", "ruleDeclarations", + "statements", "importSpec", "importItem", "fieldDeclaration", - "statements", "guardedExpEq", "fundep", "ruleDeclaration", "query", - "queryBlock", "lexp", "symbol", "faexp", "accessor", "case", + "queryBlock", + "verboseChrQuery", "stringLiteral", "symbolWithoutMinus", "listQualifier", - "field", "chrQuery", - "verboseChrQuery", + "chrQueryPart", "caseRhs", "guardedExpArrow", "equation", @@ -252,18 +257,22 @@ public abstract class SCLParser { protected abstract RuntimeException syntaxError(Token token, String description); - private static String describeAction(int action) { + private static String describeAction(boolean isGoto, int action) { if(action == ERROR_ACTION) return "ERROR"; if(action == ACCEPT_ACTION) return "ACCEPT"; StringBuilder b = new StringBuilder(); - if((action & REDUCE_MASK) != 0) { - action ^= REDUCE_MASK; - b.append("REDUCE"); + if(isGoto) + b.append("GOTO "); + else { + if((action & REDUCE_MASK) != 0) { + action ^= REDUCE_MASK; + b.append("REDUCE"); + } + else + b.append("SHIFT"); } - else - b.append("SHIFT"); if((action & POP_MASK) != 0) { action ^= POP_MASK; b.append(" POP"); @@ -276,34 +285,46 @@ public abstract class SCLParser { return b.toString(); } + private void printState(int state) { + System.out.print("state=" + state + ":"); + for(int i=symbolStackLength-1,j=stateStackLength-1;i>=0;--i) { + Object s = symbolStack[i]; + if(s instanceof Token) + System.out.print(" " + TERMINAL_NAMES[((Token)s).id]); + else if(s == null) + System.out.print(" null"); + else + System.out.print(" " + s.getClass().getSimpleName()); + while(j>=0 && symbolStackPositionStack[j]==i) + System.out.print(" (" + stateStack[j--] + ")"); + } + System.out.println(); + } + private Object parse(int state) { while(true) { Token token = nextToken(); int tokenId = token.id; + if(TRACE) + System.out.println("---> token " + TERMINAL_NAMES[tokenId] + " \"" + token.text + "\" <---"); while(true) { + if(TRACE) + printState(state); short action = getAction(state, tokenId); - if(TRACE) { - System.out.println("state=" + state + ", tokenId=" + TERMINAL_NAMES[tokenId] + - ", action=" + describeAction(action)); - System.out.print(" "); - for(int i=symbolStackLength-1,j=stateStackLength-1;i>=0;--i) { - Object s = symbolStack[i]; - if(s instanceof Token) - System.out.print(" " + TERMINAL_NAMES[((Token)s).id]); - else - System.out.print(" " + s.getClass().getSimpleName()); - while(j>=0 && symbolStackPositionStack[j]==i) - System.out.print(" (" + stateStack[j--] + ")"); - } - System.out.println(); - } + if(TRACE) + System.out.println(" -> action=" + describeAction(false, action)); //System.out.println(STATE_DESCRIPTIONS[state]); if((action & REDUCE_MASK) != 0) { if(action == ACCEPT_ACTION) return symbolStack[symbolStackLength-1]; if(action == ERROR_ACTION) throw syntaxError(token, parseErrorDescription(state, token, tokenId)); - stateStackLength -= (action >>> 13)&3; + int popAmount = (action >>> 13)&3; + if(TRACE) { + if(popAmount > 0) + System.out.println(" POP " + popAmount); + } + stateStackLength -= popAmount; action &= STATE_MASK; int reductionBegin = symbolStackPositionStack[--stateStackLength]; @@ -318,7 +339,16 @@ public abstract class SCLParser { symbolStack[symbolStackLength] = symbol; state = stateStack[stateStackLength]; + if(TRACE) { + ++symbolStackLength; + printState(state); + --symbolStackLength; + System.out.println(" nonterminal=" + NONTERMINAL_NAMES[PRODUCT_LHS[action]]); + } action = getGoto(state, PRODUCT_LHS[action]); + if(TRACE) + System.out.println(" -> action=" + describeAction(true, action)); + // Pop state if((action & POP_MASK) != 0) { --stateStackLength; @@ -367,19 +397,19 @@ public abstract class SCLParser { return parse(0); } public Object parseCommands() { - return parse(329); + return parse(347); } public Object parseImport() { - return parse(336); + return parse(355); } public Object parseType() { - return parse(338); + return parse(357); } public Object parseExp() { - return parse(340); + return parse(359); } public Object parseEquationBlock() { - return parse(342); + return parse(361); } @@ -399,9 +429,9 @@ public abstract class SCLParser { case 5: return reduceLocalTypeAnnotation(); case 6: - return reduceEntityTypeAnnotation(); - case 7: return reduceEquationBlock(); + case 7: + return reduceModuleHeader(); case 8: return reduceTypeAnnotation(); case 9: @@ -435,209 +465,223 @@ public abstract class SCLParser { case 23: return reduceRelationDefinition(); case 24: - return reduceStatementCommand(); + return reduceRulesetDefinition(); case 25: - return reduceImportCommand(); + return reduceStatementCommand(); case 26: - return reduceGuardStatement(); + return reduceImportCommand(); case 27: - return reduceLetStatement(); + return reduceGuardStatement(); case 28: - return reduceBindStatement(); + return reduceLetStatement(); case 29: - return reduceRuleStatement(); + return reduceBindStatement(); case 30: - return reduceCHRStatement(); + return reduceRuleStatement(); case 31: - return reduceVerboseCHRStatement(); + return reduceCHRStatement(); case 32: - return reduceConstraintStatement(); + return reduceVerboseCHRStatement(); case 33: - return reduceDeclarations(); + return reduceConstraintStatement(); case 34: - return reduceVarId(); + return reduceLocalInclude(); case 35: - return reduceEscapedSymbol(); + return reduceDeclarations(); case 36: - return reduceTupleConstructor(); + return reduceField(); case 37: - return reduceBinary(); + return reduceFieldShorthand(); case 38: - return reduceSimpleRhs(); + return reduceWildcard(); case 39: - return reduceGuardedRhs(); + return reduceVarId(); case 40: - return reduceConstructor(); + return reduceEscapedSymbol(); case 41: - return reduceRecordConstructor(); + return reduceTupleConstructor(); case 42: - return reduceContext(); + return reduceBinary(); case 43: - return reduceFundeps(); + return reduceSimpleRhs(); case 44: - return reduceTypeVar(); + return reduceGuardedRhs(); case 45: - return reduceTupleType(); + return reduceConstructor(); case 46: - return reduceListType(); + return reduceRecordConstructor(); case 47: - return reduceListTypeConstructor(); + return reduceContext(); case 48: - return reduceTupleTypeConstructor(); + return reduceFundeps(); case 49: - return reduceLambda(); + return reduceTypeVar(); case 50: - return reduceLambdaMatch(); + return reduceTupleType(); case 51: - return reduceLet(); + return reduceListType(); case 52: - return reduceIf(); + return reduceListTypeConstructor(); case 53: - return reduceMatch(); + return reduceTupleTypeConstructor(); case 54: - return reduceDo(); + return reduceLambda(); case 55: - return reduceSelect(); + return reduceLambdaMatch(); case 56: - return reduceEnforce(); + return reduceLet(); case 57: - return reduceVar(); + return reduceIf(); case 58: - return reduceHashedId(); + return reduceMatch(); case 59: - return reduceBlank(); + return reduceDo(); case 60: - return reduceInteger(); + return reduceSelect(); case 61: - return reduceFloat(); + return reduceCHRSelect(); case 62: - return reduceString(); + return reduceEnforce(); case 63: - return reduceChar(); + return reduceVar(); case 64: - return reduceTuple(); + return reduceHashedId(); case 65: - return reduceViewPattern(); + return reduceBlank(); case 66: - return reduceRightSection(); + return reduceInteger(); case 67: - return reduceLeftSection(); + return reduceFloat(); case 68: - return reduceListLiteral(); + return reduceString(); case 69: - return reduceRange(); + return reduceChar(); case 70: - return reduceListComprehension(); + return reduceTuple(); case 71: - return reduceAs(); + return reduceViewPattern(); case 72: - return reduceRecord(); + return reduceRightSection(); case 73: - return reduceTransformation(); + return reduceLeftSection(); case 74: - return reduceEq(); + return reduceListLiteral(); case 75: - return reduceRuleDeclarations(); + return reduceRange(); case 76: - return reduceImportShowing(); + return reduceListComprehension(); case 77: - return reduceImportHiding(); + return reduceAs(); case 78: - return reduceImportValueItem(); + return reduceRecord(); case 79: - return reduceFieldDescription(); + return reduceTransformation(); case 80: - return reduceStatements(); + return reduceEq(); case 81: - return reduceGuardedExpEq(); + return reduceRuleDeclarations(); case 82: - return reduceFundep(); + return reduceStatements(); case 83: - return reduceQueryRuleDeclaration(); + return reduceImportShowing(); case 84: - return reduceAnnotation(); + return reduceImportHiding(); case 85: - return reduceGuardQuery(); + return reduceImportValueItem(); case 86: - return reduceEqualsQuery(); + return reduceFieldDescription(); case 87: - return reduceBindQuery(); + return reduceGuardedExpEq(); case 88: - return reduceCompositeQuery(); + return reduceFundep(); case 89: - return reduceQueryBlock(); + return reduceQueryRuleDeclaration(); case 90: - return reduceApply(); + return reduceAnnotation(); case 91: - return reduceSymbol(); + return reduceGuardQuery(); case 92: - return reduceEscapedId(); + return reduceEqualsQuery(); case 93: - return reduceMinus(); + return reduceBindQuery(); case 94: - return reduceLess(); + return reduceCompositeQuery(); case 95: - return reduceGreater(); + return reduceApply(); case 96: - return reduceDot(); + return reduceSymbol(); case 97: - return reduceFieldAccess(); + return reduceEscapedId(); case 98: - return reduceIdAccessor(); + return reduceMinus(); case 99: - return reduceStringAccessor(); + return reduceLess(); case 100: - return reduceExpAccessor(); + return reduceGreater(); case 101: - return reduceCase(); + return reduceDot(); case 102: - return reduceStringLiteral(); + return reduceFieldAccess(); case 103: - return reduceSymbol(); + return reduceIdAccessor(); case 104: - return reduceEscapedId(); + return reduceStringAccessor(); case 105: - return reduceLess(); + return reduceExpAccessor(); case 106: - return reduceGreater(); + return reduceCase(); case 107: - return reduceDot(); + return reduceQueryBlock(); case 108: - return reduceGuardQualifier(); + return reduceVerboseCHRConjunction(); case 109: - return reduceLetQualifier(); + return reduceStringLiteral(); case 110: - return reduceBindQualifier(); + return reduceSymbol(); case 111: - return reduceThenQualifier(); + return reduceEscapedId(); case 112: - return reduceField(); + return reduceLess(); case 113: - return reduceFieldShorthand(); + return reduceGreater(); case 114: - return reduceCHRQuery(); + return reduceDot(); case 115: - return reduceVerboseCHRQuery(); + return reduceGuardQualifier(); case 116: - return reduceSimpleCaseRhs(); + return reduceLetQualifier(); case 117: - return reduceGuardedCaseRhs(); + return reduceBindQualifier(); case 118: - return reduceGuardedExpArrow(); + return reduceThenQualifier(); case 119: - return reduceGuardEquation(); + return reduceCHRConjunction(); case 120: - return reduceBasicEquation(); + return reduceCHRAtom(); case 121: - return reduceEffect(); + return reduceCHREquals(); case 122: - return reduceJustEtype(); + return reduceCHRBinds(); case 123: - return reduceForAll(); + return reduceSimpleCaseRhs(); case 124: - return reduceApplyType(); + return reduceGuardedCaseRhs(); case 125: - return reduceDummy1(); + return reduceGuardedExpArrow(); + case 126: + return reduceGuardEquation(); + case 127: + return reduceBasicEquation(); + case 128: + return reduceEffect(); + case 129: + return reduceJustEtype(); + case 130: + return reduceForAll(); + case 131: + return reduceApplyType(); + case 132: + return reduceDummy(); default: throw new RuntimeException("Internal parser error."); @@ -681,14 +725,14 @@ public abstract class SCLParser { * exp ::= bexp (HASTYPE type)? */ protected abstract Object reduceLocalTypeAnnotation(); - /** - * exp ::= bexp COLON ID (queryBlock | WITH queryBlock?)? - */ - protected abstract Object reduceEntityTypeAnnotation(); /** * equationBlock ::= (equation (SEMICOLON equation)*)? */ protected abstract Object reduceEquationBlock(); + /** + * declaration ::= MODULE LBRACE (field (COMMA field)*)? RBRACE + */ + protected abstract Object reduceModuleHeader(); /** * declaration ::= (var COMMA)* var HASTYPE type */ @@ -753,6 +797,10 @@ public abstract class SCLParser { * declaration ::= bexp FOLLOWS ruleDeclarations */ protected abstract Object reduceRelationDefinition(); + /** + * declaration ::= RULESET ID WHERE statements + */ + protected abstract Object reduceRulesetDefinition(); /** * command ::= statement */ @@ -786,13 +834,29 @@ public abstract class SCLParser { */ protected abstract Object reduceVerboseCHRStatement(); /** - * statement ::= CONSTRAINT ID atype* + * statement ::= CONSTRAINT constructor */ protected abstract Object reduceConstraintStatement(); + /** + * statement ::= INCLUDE ID aexp + */ + protected abstract Object reduceLocalInclude(); /** * declarations ::= LBRACE (declaration (SEMICOLON (declaration SEMICOLON)* declaration)?)? RBRACE */ protected abstract Object reduceDeclarations(); + /** + * field ::= ID EQUALS exp + */ + protected abstract Object reduceField(); + /** + * field ::= ID + */ + protected abstract Object reduceFieldShorthand(); + /** + * field ::= DOTDOT + */ + protected abstract Object reduceWildcard(); /** * var ::= ID */ @@ -874,13 +938,17 @@ public abstract class SCLParser { */ protected abstract Object reduceMatch(); /** - * aexp ::= (DO | MDO) statements + * aexp ::= (DO | MDO | EDO) statements */ protected abstract Object reduceDo(); /** * aexp ::= (SELECT | SELECT_FIRST | SELECT_DISTINCT) exp WHERE queryBlock */ protected abstract Object reduceSelect(); + /** + * aexp ::= CHR_SELECT exp WHERE verboseChrQuery + */ + protected abstract Object reduceCHRSelect(); /** * aexp ::= ENFORCE queryBlock */ @@ -961,6 +1029,10 @@ public abstract class SCLParser { * ruleDeclarations ::= LBRACE (ruleDeclaration (SEMICOLON (ruleDeclaration SEMICOLON)* ruleDeclaration)?)? RBRACE */ protected abstract Object reduceRuleDeclarations(); + /** + * statements ::= LBRACE (statement (SEMICOLON (statement SEMICOLON)* statement)?)? RBRACE + */ + protected abstract Object reduceStatements(); /** * importSpec ::= LPAREN (importItem (COMMA (importItem COMMA)* importItem)?)? RPAREN */ @@ -977,10 +1049,6 @@ public abstract class SCLParser { * fieldDeclaration ::= ID HASTYPE type */ protected abstract Object reduceFieldDescription(); - /** - * statements ::= LBRACE (statement (SEMICOLON (statement SEMICOLON)* statement)?)? RBRACE - */ - protected abstract Object reduceStatements(); /** * guardedExpEq ::= BAR exp (COMMA exp)* EQUALS exp */ @@ -1009,10 +1077,6 @@ public abstract class SCLParser { * query ::= QUERY_OP queryBlock */ protected abstract Object reduceCompositeQuery(); - /** - * queryBlock ::= LBRACE (query (SEMICOLON (query SEMICOLON)* query)?)? RBRACE - */ - protected abstract Object reduceQueryBlock(); /** * lexp ::= faexp faexp* */ @@ -1061,6 +1125,14 @@ public abstract class SCLParser { * case ::= exp caseRhs */ protected abstract Object reduceCase(); + /** + * queryBlock ::= LBRACE (query (SEMICOLON (query SEMICOLON)* query)?)? RBRACE + */ + protected abstract Object reduceQueryBlock(); + /** + * verboseChrQuery ::= LBRACE chrQuery (SEMICOLON chrQuery)* RBRACE + */ + protected abstract Object reduceVerboseCHRConjunction(); /** * stringLiteral ::= BEGIN_STRING (SUSPEND_STRING exp CONTINUE_STRING)* END_STRING */ @@ -1082,21 +1154,21 @@ public abstract class SCLParser { */ protected abstract Object reduceThenQualifier(); /** - * field ::= ID EQUALS exp + * chrQuery ::= (chrQueryPart COMMA)* chrQueryPart */ - protected abstract Object reduceField(); + protected abstract Object reduceCHRConjunction(); /** - * field ::= ID + * chrQueryPart ::= exp */ - protected abstract Object reduceFieldShorthand(); + protected abstract Object reduceCHRAtom(); /** - * chrQuery ::= (listQualifier COMMA)* listQualifier + * chrQueryPart ::= exp EQUALS exp */ - protected abstract Object reduceCHRQuery(); + protected abstract Object reduceCHREquals(); /** - * verboseChrQuery ::= LBRACE listQualifier (SEMICOLON listQualifier)* RBRACE + * chrQueryPart ::= exp BINDS exp */ - protected abstract Object reduceVerboseCHRQuery(); + protected abstract Object reduceCHRBinds(); /** * caseRhs ::= ARROW exp (WHERE statements)? */ @@ -1136,7 +1208,7 @@ public abstract class SCLParser { /** * dummy ::= COMMENT EOL */ - protected abstract Object reduceDummy1(); + protected abstract Object reduceDummy(); protected void postReduce(Object reduced) { }