bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/parsing/parser/SCLParser.java

   1 package org.simantics.scl.compiler.internal.parsing.parser;\r
   2 \r
   3 import java.io.DataInputStream;\r
   4 import java.io.IOException;\r
   5 import java.util.ArrayList;\r
   6 import java.util.Arrays;\r
   7 import java.util.Collections;\r
   8 import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;\r
   9 \r
  10 import org.simantics.scl.compiler.internal.parsing.Token;\r
  11 \r
  12 public abstract class SCLParser {    \r
  13     public static final boolean TRACE = false;\r
  14 \r
  15     private static final int INITIAL_CAPACITY = 16;\r
  16     private static final int STATE_COUNT = 344;\r
  17     private static final int TERMINAL_COUNT = 82;\r
  18     private static final int NONTERMINAL_COUNT = 51;\r
  19     private static final int PRODUCT_COUNT = 132;\r
  20     \r
  21     private static final int[] ACTION_ROW_ID = new int[STATE_COUNT];\r
  22     private static final int[] ACTION_COLUMN_ID = new int[TERMINAL_COUNT];\r
  23     private static final short[] ACTION_TABLE = new short[6120];\r
  24     private static final int[] ERROR_TABLE = new int[882];\r
  25     private static final int[] GOTO_ROW_ID = new int[STATE_COUNT];\r
  26     private static final int[] GOTO_COLUMN_ID = new int[NONTERMINAL_COUNT];\r
  27     private static final short[] GOTO_TABLE = new short[1829];\r
  28     private static final int[] PRODUCT_LHS = new int[PRODUCT_COUNT];\r
  29 \r
  30     private static final short STATE_MASK = (short)0x0fff;\r
  31     private static final short REDUCE_MASK = (short)0x8000;\r
  32     private static final short POP_MASK = (short)0x4000;\r
  33     private static final short PUSH_MASK = (short)0x2000;\r
  34     private static final short ERROR_ACTION = (short)0xffff;\r
  35     private static final short ACCEPT_ACTION = (short)0xfffe;\r
  36     \r
  37     public static final String[] TERMINAL_NAMES = new String[] {\r
  38         "SEMICOLON",\r
  39         "LBRACE",\r
  40         "RBRACE",\r
  41         "COMMA",\r
  42         "HASTYPE",\r
  43         "DATA",\r
  44         "ID",\r
  45         "EQUALS",\r
  46         "BAR",\r
  47         "TYPE",\r
  48         "CLASS",\r
  49         "WHERE",\r
  50         "INSTANCE",\r
  51         "DERIVING",\r
  52         "BEGIN_STRING",\r
  53         "END_STRING",\r
  54         "ANNOTATION_ID",\r
  55         "INFIX",\r
  56         "INFIXL",\r
  57         "INFIXR",\r
  58         "INTEGER",\r
  59         "IMPORTJAVA",\r
  60         "EFFECT",\r
  61         "RULE",\r
  62         "ABSTRACT_RULE",\r
  63         "EXTENDS",\r
  64         "MAPPING_RELATION",\r
  65         "FOLLOWS",\r
  66         "IMPORT",\r
  67         "INCLUDE",\r
  68         "AS",\r
  69         "LPAREN",\r
  70         "RPAREN",\r
  71         "HIDING",\r
  72         "ARROW",\r
  73         "COLON",\r
  74         "WITH",\r
  75         "MINUS",\r
  76         "SYMBOL",\r
  77         "LESS",\r
  78         "GREATER",\r
  79         "SEPARATED_DOT",\r
  80         "ESCAPED_ID",\r
  81         "LAMBDA",\r
  82         "LAMBDA_MATCH",\r
  83         "LET",\r
  84         "IF",\r
  85         "MATCH",\r
  86         "DO",\r
  87         "MDO",\r
  88         "ENFORCE",\r
  89         "BLANK",\r
  90         "FLOAT",\r
  91         "LBRACKET",\r
  92         "ESCAPED_SYMBOL",\r
  93         "CHAR",\r
  94         "WHEN",\r
  95         "ATTACHED_HASH",\r
  96         "SELECT",\r
  97         "SELECT_FIRST",\r
  98         "SELECT_DISTINCT",\r
  99         "TRANSFORMATION",\r
 100         "EQ",\r
 101         "ATTACHED_DOT",\r
 102         "IN",\r
 103         "THEN",\r
 104         "ELSE",\r
 105         "RBRACKET",\r
 106         "DOTDOT",\r
 107         "AT",\r
 108         "SUSPEND_STRING",\r
 109         "CONTINUE_STRING",\r
 110         "BINDS",\r
 111         "IMPLIES",\r
 112         "THEN_AFTER_WHEN",\r
 113         "CONSTRAINT",\r
 114         "BY",\r
 115         "QUERY_OP",\r
 116         "FORALL",\r
 117         "COMMENT",\r
 118         "EOL",\r
 119         "EOF"\r
 120     };\r
 121 \r
 122     public static final String[] NONTERMINAL_NAMES = new String[] {\r
 123         "module",\r
 124         "commands",\r
 125         "import",\r
 126         "type",\r
 127         "exp",\r
 128         "equationBlock",\r
 129         "declaration",\r
 130         "command",\r
 131         "statement",\r
 132         "declarations",\r
 133         "var",\r
 134         "bexp",\r
 135         "rhs",\r
 136         "constructor",\r
 137         "context",\r
 138         "fundeps",\r
 139         "atype",\r
 140         "aexp",\r
 141         "ruleDeclarations",\r
 142         "importSpec",\r
 143         "importItem",\r
 144         "fieldDeclaration",\r
 145         "statements",\r
 146         "guardedExpEq",\r
 147         "fundep",\r
 148         "ruleDeclaration",\r
 149         "query",\r
 150         "queryBlock",\r
 151         "lexp",\r
 152         "symbol",\r
 153         "faexp",\r
 154         "accessor",\r
 155         "case",\r
 156         "stringLiteral",\r
 157         "symbolWithoutMinus",\r
 158         "listQualifier",\r
 159         "field",\r
 160         "chrQuery",\r
 161         "verboseChrQuery",\r
 162         "caseRhs",\r
 163         "guardedExpArrow",\r
 164         "equation",\r
 165         "etype",\r
 166         "btype",\r
 167         "dummy",\r
 168         "init$6",\r
 169         "init$5",\r
 170         "init$4",\r
 171         "init$3",\r
 172         "init$2",\r
 173         "init$1"\r
 174     };\r
 175         \r
 176     static {\r
 177         try {\r
 178             DataInputStream input = new DataInputStream(SCLParser.class.getResourceAsStream("SCLParser.dat"));\r
 179             for(int i=0;i<ACTION_ROW_ID.length;++i)\r
 180                 ACTION_ROW_ID[i] = input.readInt();\r
 181             for(int i=0;i<ACTION_COLUMN_ID.length;++i)\r
 182                 ACTION_COLUMN_ID[i] = input.readInt();    \r
 183             for(int i=0;i<ACTION_TABLE.length;++i)\r
 184                 ACTION_TABLE[i] = input.readShort();\r
 185             for(int i=0;i<ERROR_TABLE.length;++i)\r
 186                 ERROR_TABLE[i] = input.readInt();\r
 187             for(int i=0;i<GOTO_ROW_ID.length;++i)\r
 188                 GOTO_ROW_ID[i] = input.readInt();\r
 189             for(int i=0;i<GOTO_COLUMN_ID.length;++i)\r
 190                 GOTO_COLUMN_ID[i] = input.readInt();    \r
 191             for(int i=0;i<GOTO_TABLE.length;++i)\r
 192                 GOTO_TABLE[i] = input.readShort();\r
 193             for(int i=0;i<PRODUCT_LHS.length;++i)\r
 194                 PRODUCT_LHS[i] = input.readInt();\r
 195             input.close();\r
 196         } catch(IOException e) {\r
 197             e.printStackTrace();\r
 198         }\r
 199     }\r
 200     \r
 201     private static short getAction(int state, int symbol) {\r
 202         int id = TERMINAL_COUNT*state + symbol;\r
 203         if( ((ERROR_TABLE[id>>5] >> (id&31))&1) != 0 )\r
 204             return ERROR_ACTION;\r
 205         return ACTION_TABLE[ACTION_ROW_ID[state] + ACTION_COLUMN_ID[symbol]];\r
 206     }\r
 207     \r
 208     private static short getGoto(int state, int symbol) {\r
 209         return GOTO_TABLE[GOTO_ROW_ID[state] + GOTO_COLUMN_ID[symbol]];\r
 210     }\r
 211     \r
 212     protected abstract Token nextToken();\r
 213     \r
 214     private Object[] symbolStack = new Object[INITIAL_CAPACITY];\r
 215     private int symbolStackLength = 0;\r
 216     \r
 217     private int[] stateStack = new int[INITIAL_CAPACITY];\r
 218     private int[] symbolStackPositionStack = new int[INITIAL_CAPACITY];\r
 219     private int stateStackLength = 0;\r
 220     \r
 221     // For reduce\r
 222     private int reductionLength;\r
 223     \r
 224     protected int length() {\r
 225         return reductionLength;\r
 226     }\r
 227     \r
 228     protected Object get(int i) {\r
 229         if(i < 0 || i >= reductionLength)\r
 230             throw new IndexOutOfBoundsException();\r
 231         return symbolStack[symbolStackLength+i];\r
 232     }\r
 233     \r
 234     private String parseErrorDescription(int state, Token token, int tokenId) {\r
 235         StringBuilder b = new StringBuilder();\r
 236         b.append("Unexpected token '").append(token)\r
 237          .append("' (").append(TERMINAL_NAMES[tokenId])\r
 238          .append("). Expected one of ");\r
 239         ArrayList<String> possibleTerminals = new ArrayList<String>();\r
 240         for(int i=0;i<TERMINAL_COUNT;++i)\r
 241             if(getAction(state, i) != ERROR_ACTION)\r
 242                 possibleTerminals.add(TERMINAL_NAMES[i]);\r
 243         Collections.sort(possibleTerminals);\r
 244         for(int i=0;i<possibleTerminals.size();++i) {\r
 245             if(i > 0)\r
 246                 b.append(", ");\r
 247             b.append(possibleTerminals.get(i));\r
 248         }\r
 249         b.append('.');\r
 250         return b.toString();\r
 251     }\r
 252     \r
 253     protected abstract RuntimeException syntaxError(Token token, String description);\r
 254     \r
 255     private static String describeAction(int action) {\r
 256         if(action == ERROR_ACTION)\r
 257             return "ERROR";\r
 258         if(action == ACCEPT_ACTION)\r
 259             return "ACCEPT";\r
 260         StringBuilder b = new StringBuilder();\r
 261         if((action & REDUCE_MASK) != 0) {\r
 262             action ^= REDUCE_MASK;\r
 263             b.append("REDUCE");\r
 264         }\r
 265         else\r
 266             b.append("SHIFT");\r
 267         if((action & POP_MASK) != 0) {\r
 268             action ^= POP_MASK;\r
 269             b.append(" POP");\r
 270         }\r
 271         if((action & PUSH_MASK) != 0) {\r
 272             action ^= PUSH_MASK;\r
 273             b.append(" PUSH");\r
 274         }\r
 275         b.append(' ').append(action);\r
 276         return b.toString();\r
 277     }\r
 278     \r
 279     private Object parse(int state) {\r
 280         while(true) {\r
 281             Token token = nextToken();\r
 282             int tokenId = token.id;\r
 283             while(true) {\r
 284                 short action = getAction(state, tokenId);\r
 285                 if(TRACE) {\r
 286                     System.out.println("state=" + state + ", tokenId=" + TERMINAL_NAMES[tokenId] + \r
 287                         ", action=" + describeAction(action));\r
 288                     System.out.print("   ");\r
 289                     for(int i=symbolStackLength-1,j=stateStackLength-1;i>=0;--i) {                    \r
 290                         Object s = symbolStack[i];\r
 291                         if(s instanceof Token)\r
 292                             System.out.print(" " + TERMINAL_NAMES[((Token)s).id]);\r
 293                         else\r
 294                             System.out.print(" " + s.getClass().getSimpleName());                            \r
 295                         while(j>=0 && symbolStackPositionStack[j]==i)\r
 296                             System.out.print(" (" + stateStack[j--] + ")");\r
 297                     }\r
 298                     System.out.println();\r
 299                 }\r
 300                 //System.out.println(STATE_DESCRIPTIONS[state]);\r
 301                 if((action & REDUCE_MASK) != 0) {\r
 302                     if(action == ACCEPT_ACTION)\r
 303                         return symbolStack[symbolStackLength-1];\r
 304                     if(action == ERROR_ACTION)\r
 305                         throw syntaxError(token, parseErrorDescription(state, token, tokenId));\r
 306                     stateStackLength -= (action >>> 13)&3;\r
 307                     action &= STATE_MASK;\r
 308                     \r
 309                     int reductionBegin = symbolStackPositionStack[--stateStackLength];\r
 310                     \r
 311                     reductionLength = symbolStackLength-reductionBegin;\r
 312                     symbolStackLength = reductionBegin;\r
 313                     \r
 314                     if(symbolStackLength == symbolStack.length)\r
 315                         symbolStack = Arrays.copyOf(symbolStack, symbolStackLength*2);\r
 316                     Object symbol = reduce(action);\r
 317                     postReduce(symbol);\r
 318                     symbolStack[symbolStackLength] = symbol;\r
 319                     \r
 320                     state = stateStack[stateStackLength];\r
 321                     action = getGoto(state, PRODUCT_LHS[action]);\r
 322                     // Pop state\r
 323                     if((action & POP_MASK) != 0) {\r
 324                         --stateStackLength;\r
 325                     }\r
 326                     // Push state\r
 327                     if((action & PUSH_MASK) != 0) {\r
 328                         if(stateStackLength == stateStack.length) {\r
 329                             stateStack = Arrays.copyOf(stateStack, stateStackLength*2);\r
 330                             symbolStackPositionStack = Arrays.copyOf(symbolStackPositionStack, stateStackLength*2);\r
 331                         }\r
 332                         symbolStackPositionStack[stateStackLength] = symbolStackLength;\r
 333                         stateStack[stateStackLength++] = state;\r
 334                     }\r
 335                     state = action & STATE_MASK;\r
 336                     ++symbolStackLength;\r
 337                 }\r
 338                 else {\r
 339                     // Pop state\r
 340                     if((action & POP_MASK) != 0) {\r
 341                         --stateStackLength;\r
 342                     }\r
 343                     // Push state\r
 344                     if((action & PUSH_MASK) != 0) {\r
 345                         if(stateStackLength == stateStack.length) {\r
 346                             stateStack = Arrays.copyOf(stateStack, stateStackLength*2);\r
 347                             symbolStackPositionStack = Arrays.copyOf(symbolStackPositionStack, stateStackLength*2);\r
 348                         }\r
 349                         symbolStackPositionStack[stateStackLength] = symbolStackLength;\r
 350                         stateStack[stateStackLength++] = state;\r
 351                     }\r
 352                     \r
 353                     // New state\r
 354                     state = action & STATE_MASK;\r
 355                     \r
 356                     // Push symbol\r
 357                     if(symbolStackLength == symbolStack.length)\r
 358                         symbolStack = Arrays.copyOf(symbolStack, symbolStackLength*2);\r
 359                     symbolStack[symbolStackLength++] = token;\r
 360                     break;\r
 361                 }\r
 362             }\r
 363         }\r
 364     }\r
 365     \r
 366     public Object parseModule() {\r
 367         return parse(0);\r
 368     }\r
 369     public Object parseCommands() {\r
 370         return parse(329);\r
 371     }\r
 372     public Object parseImport() {\r
 373         return parse(336);\r
 374     }\r
 375     public Object parseType() {\r
 376         return parse(338);\r
 377     }\r
 378     public Object parseExp() {\r
 379         return parse(340);\r
 380     }\r
 381     public Object parseEquationBlock() {\r
 382         return parse(342);\r
 383     }\r
 384 \r
 385 \r
 386     protected Object reduce(int productionId) {\r
 387         try {\r
 388         switch(productionId) {\r
 389         case 0:\r
 390             return reduceModule();\r
 391         case 1:\r
 392             return reduceOneCommand();\r
 393         case 2:\r
 394             return reduceManyCommands();\r
 395         case 3:\r
 396             return reduceImport();\r
 397         case 4:\r
 398             return reduceArrow();\r
 399         case 5:\r
 400             return reduceLocalTypeAnnotation();\r
 401         case 6:\r
 402             return reduceEntityTypeAnnotation();\r
 403         case 7:\r
 404             return reduceEquationBlock();\r
 405         case 8:\r
 406             return reduceTypeAnnotation();\r
 407         case 9:\r
 408             return reduceValueDefinition();\r
 409         case 10:\r
 410             return reduceDataDefinition();\r
 411         case 11:\r
 412             return reduceTypeDefinition();\r
 413         case 12:\r
 414             return reduceClassDefinition();\r
 415         case 13:\r
 416             return reduceInstanceDefinition();\r
 417         case 14:\r
 418             return reduceDerivingInstanceDefinition();\r
 419         case 15:\r
 420             return reduceDocumentationString();\r
 421         case 16:\r
 422             return reduceAnnotation();\r
 423         case 17:\r
 424             return reducePrecedenceDefinition();\r
 425         case 18:\r
 426             return reduceJustImport();\r
 427         case 19:\r
 428             return reduceImportJava();\r
 429         case 20:\r
 430             return reduceEffectDefinition();\r
 431         case 21:\r
 432             return reduceRuleDefinition();\r
 433         case 22:\r
 434             return reduceMappingRelationDefinition();\r
 435         case 23:\r
 436             return reduceRelationDefinition();\r
 437         case 24:\r
 438             return reduceStatementCommand();\r
 439         case 25:\r
 440             return reduceImportCommand();\r
 441         case 26:\r
 442             return reduceGuardStatement();\r
 443         case 27:\r
 444             return reduceLetStatement();\r
 445         case 28:\r
 446             return reduceBindStatement();\r
 447         case 29:\r
 448             return reduceRuleStatement();\r
 449         case 30:\r
 450             return reduceCHRStatement();\r
 451         case 31:\r
 452             return reduceVerboseCHRStatement();\r
 453         case 32:\r
 454             return reduceConstraintStatement();\r
 455         case 33:\r
 456             return reduceDeclarations();\r
 457         case 34:\r
 458             return reduceVarId();\r
 459         case 35:\r
 460             return reduceEscapedSymbol();\r
 461         case 36:\r
 462             return reduceTupleConstructor();\r
 463         case 37:\r
 464             return reduceBinary();\r
 465         case 38:\r
 466             return reduceSimpleRhs();\r
 467         case 39:\r
 468             return reduceGuardedRhs();\r
 469         case 40:\r
 470             return reduceConstructor();\r
 471         case 41:\r
 472             return reduceRecordConstructor();\r
 473         case 42:\r
 474             return reduceContext();\r
 475         case 43:\r
 476             return reduceFundeps();\r
 477         case 44:\r
 478             return reduceTypeVar();\r
 479         case 45:\r
 480             return reduceTupleType();\r
 481         case 46:\r
 482             return reduceListType();\r
 483         case 47:\r
 484             return reduceListTypeConstructor();\r
 485         case 48:\r
 486             return reduceTupleTypeConstructor();\r
 487         case 49:\r
 488             return reduceLambda();\r
 489         case 50:\r
 490             return reduceLambdaMatch();\r
 491         case 51:\r
 492             return reduceLet();\r
 493         case 52:\r
 494             return reduceIf();\r
 495         case 53:\r
 496             return reduceMatch();\r
 497         case 54:\r
 498             return reduceDo();\r
 499         case 55:\r
 500             return reduceSelect();\r
 501         case 56:\r
 502             return reduceEnforce();\r
 503         case 57:\r
 504             return reduceVar();\r
 505         case 58:\r
 506             return reduceHashedId();\r
 507         case 59:\r
 508             return reduceBlank();\r
 509         case 60:\r
 510             return reduceInteger();\r
 511         case 61:\r
 512             return reduceFloat();\r
 513         case 62:\r
 514             return reduceString();\r
 515         case 63:\r
 516             return reduceChar();\r
 517         case 64:\r
 518             return reduceTuple();\r
 519         case 65:\r
 520             return reduceViewPattern();\r
 521         case 66:\r
 522             return reduceRightSection();\r
 523         case 67:\r
 524             return reduceLeftSection();\r
 525         case 68:\r
 526             return reduceListLiteral();\r
 527         case 69:\r
 528             return reduceRange();\r
 529         case 70:\r
 530             return reduceListComprehension();\r
 531         case 71:\r
 532             return reduceAs();\r
 533         case 72:\r
 534             return reduceRecord();\r
 535         case 73:\r
 536             return reduceTransformation();\r
 537         case 74:\r
 538             return reduceEq();\r
 539         case 75:\r
 540             return reduceRuleDeclarations();\r
 541         case 76:\r
 542             return reduceImportShowing();\r
 543         case 77:\r
 544             return reduceImportHiding();\r
 545         case 78:\r
 546             return reduceImportValueItem();\r
 547         case 79:\r
 548             return reduceFieldDescription();\r
 549         case 80:\r
 550             return reduceStatements();\r
 551         case 81:\r
 552             return reduceGuardedExpEq();\r
 553         case 82:\r
 554             return reduceFundep();\r
 555         case 83:\r
 556             return reduceQueryRuleDeclaration();\r
 557         case 84:\r
 558             return reduceAnnotation();\r
 559         case 85:\r
 560             return reduceGuardQuery();\r
 561         case 86:\r
 562             return reduceEqualsQuery();\r
 563         case 87:\r
 564             return reduceBindQuery();\r
 565         case 88:\r
 566             return reduceCompositeQuery();\r
 567         case 89:\r
 568             return reduceQueryBlock();\r
 569         case 90:\r
 570             return reduceApply();\r
 571         case 91:\r
 572             return reduceSymbol();\r
 573         case 92:\r
 574             return reduceEscapedId();\r
 575         case 93:\r
 576             return reduceMinus();\r
 577         case 94:\r
 578             return reduceLess();\r
 579         case 95:\r
 580             return reduceGreater();\r
 581         case 96:\r
 582             return reduceDot();\r
 583         case 97:\r
 584             return reduceFieldAccess();\r
 585         case 98:\r
 586             return reduceIdAccessor();\r
 587         case 99:\r
 588             return reduceStringAccessor();\r
 589         case 100:\r
 590             return reduceExpAccessor();\r
 591         case 101:\r
 592             return reduceCase();\r
 593         case 102:\r
 594             return reduceStringLiteral();\r
 595         case 103:\r
 596             return reduceSymbol();\r
 597         case 104:\r
 598             return reduceEscapedId();\r
 599         case 105:\r
 600             return reduceLess();\r
 601         case 106:\r
 602             return reduceGreater();\r
 603         case 107:\r
 604             return reduceDot();\r
 605         case 108:\r
 606             return reduceGuardQualifier();\r
 607         case 109:\r
 608             return reduceLetQualifier();\r
 609         case 110:\r
 610             return reduceBindQualifier();\r
 611         case 111:\r
 612             return reduceThenQualifier();\r
 613         case 112:\r
 614             return reduceField();\r
 615         case 113:\r
 616             return reduceFieldShorthand();\r
 617         case 114:\r
 618             return reduceCHRQuery();\r
 619         case 115:\r
 620             return reduceVerboseCHRQuery();\r
 621         case 116:\r
 622             return reduceSimpleCaseRhs();\r
 623         case 117:\r
 624             return reduceGuardedCaseRhs();\r
 625         case 118:\r
 626             return reduceGuardedExpArrow();\r
 627         case 119:\r
 628             return reduceGuardEquation();\r
 629         case 120:\r
 630             return reduceBasicEquation();\r
 631         case 121:\r
 632             return reduceEffect();\r
 633         case 122:\r
 634             return reduceJustEtype();\r
 635         case 123:\r
 636             return reduceForAll();\r
 637         case 124:\r
 638             return reduceApplyType();\r
 639         case 125:\r
 640             return reduceDummy1();\r
 641 \r
 642         default:\r
 643             throw new RuntimeException("Internal parser error.");\r
 644         }\r
 645         } catch(SCLSyntaxErrorException e) {\r
 646             StringBuilder b = new StringBuilder();\r
 647             b.append("Failed to reduce");\r
 648             for(int i=0;i<length();++i) {\r
 649                 Object obj = get(i);\r
 650                 b.append("\n    (").append(i).append(") \"").append(obj).append('\"');\r
 651                 if(obj instanceof Token)\r
 652                     b.append(" (").append(TERMINAL_NAMES[((Token)obj).id]).append(")");\r
 653                 else\r
 654                     b.append(" [").append(obj.getClass().getSimpleName()).append("]");\r
 655             }\r
 656             throw new RuntimeException(b.toString(), e);\r
 657         } \r
 658     }\r
 659 \r
 660     /**\r
 661      * module ::= (declaration (SEMICOLON declaration)&#42;)?\r
 662      */\r
 663     protected abstract Object reduceModule();\r
 664     /**\r
 665      * commands ::= command?\r
 666      */\r
 667     protected abstract Object reduceOneCommand();\r
 668     /**\r
 669      * commands ::= commands SEMICOLON command\r
 670      */\r
 671     protected abstract Object reduceManyCommands();\r
 672     /**\r
 673      * import ::= (IMPORT | INCLUDE) BEGIN_STRING END_STRING (AS ID)? importSpec?\r
 674      */\r
 675     protected abstract Object reduceImport();\r
 676     /**\r
 677      * type ::= (etype (ARROW | IMPLIES))&#42; etype\r
 678      */\r
 679     protected abstract Object reduceArrow();\r
 680     /**\r
 681      * exp ::= bexp (HASTYPE type)?\r
 682      */\r
 683     protected abstract Object reduceLocalTypeAnnotation();\r
 684     /**\r
 685      * exp ::= bexp COLON ID (queryBlock | WITH queryBlock?)?\r
 686      */\r
 687     protected abstract Object reduceEntityTypeAnnotation();\r
 688     /**\r
 689      * equationBlock ::= (equation (SEMICOLON equation)&#42;)?\r
 690      */\r
 691     protected abstract Object reduceEquationBlock();\r
 692     /**\r
 693      * declaration ::= (var COMMA)&#42; var HASTYPE type\r
 694      */\r
 695     protected abstract Object reduceTypeAnnotation();\r
 696     /**\r
 697      * declaration ::= bexp rhs\r
 698      */\r
 699     protected abstract Object reduceValueDefinition();\r
 700     /**\r
 701      * declaration ::= DATA ID ID&#42; (EQUALS (constructor BAR)&#42; constructor)?\r
 702      */\r
 703     protected abstract Object reduceDataDefinition();\r
 704     /**\r
 705      * declaration ::= TYPE ID ID&#42; EQUALS type\r
 706      */\r
 707     protected abstract Object reduceTypeDefinition();\r
 708     /**\r
 709      * declaration ::= CLASS context? ID ID&#42; (BAR fundeps | (BAR fundeps)? WHERE declarations)?\r
 710      */\r
 711     protected abstract Object reduceClassDefinition();\r
 712     /**\r
 713      * declaration ::= INSTANCE context? ID atype atype&#42; (WHERE declarations)?\r
 714      */\r
 715     protected abstract Object reduceInstanceDefinition();\r
 716     /**\r
 717      * declaration ::= DERIVING INSTANCE context? ID atype atype&#42;\r
 718      */\r
 719     protected abstract Object reduceDerivingInstanceDefinition();\r
 720     /**\r
 721      * declaration ::= BEGIN_STRING END_STRING\r
 722      */\r
 723     protected abstract Object reduceDocumentationString();\r
 724     /**\r
 725      * declaration ::= ANNOTATION_ID aexp&#42;\r
 726      */\r
 727     protected abstract Object reduceAnnotation();\r
 728     /**\r
 729      * declaration ::= (INFIX | INFIXL | INFIXR) INTEGER (var COMMA)&#42; var\r
 730      */\r
 731     protected abstract Object reducePrecedenceDefinition();\r
 732     /**\r
 733      * declaration ::= import\r
 734      */\r
 735     protected abstract Object reduceJustImport();\r
 736     /**\r
 737      * declaration ::= IMPORTJAVA BEGIN_STRING END_STRING WHERE declarations\r
 738      */\r
 739     protected abstract Object reduceImportJava();\r
 740     /**\r
 741      * declaration ::= EFFECT ID BEGIN_STRING END_STRING BEGIN_STRING END_STRING\r
 742      */\r
 743     protected abstract Object reduceEffectDefinition();\r
 744     /**\r
 745      * declaration ::= (RULE | ABSTRACT_RULE) ID (EXTENDS (ID COMMA)&#42; ID)? WHERE ruleDeclarations\r
 746      */\r
 747     protected abstract Object reduceRuleDefinition();\r
 748     /**\r
 749      * declaration ::= MAPPING_RELATION ID atype&#42;\r
 750      */\r
 751     protected abstract Object reduceMappingRelationDefinition();\r
 752     /**\r
 753      * declaration ::= bexp FOLLOWS ruleDeclarations\r
 754      */\r
 755     protected abstract Object reduceRelationDefinition();\r
 756     /**\r
 757      * command ::= statement\r
 758      */\r
 759     protected abstract Object reduceStatementCommand();\r
 760     /**\r
 761      * command ::= import\r
 762      */\r
 763     protected abstract Object reduceImportCommand();\r
 764     /**\r
 765      * statement ::= exp\r
 766      */\r
 767     protected abstract Object reduceGuardStatement();\r
 768     /**\r
 769      * statement ::= exp rhs\r
 770      */\r
 771     protected abstract Object reduceLetStatement();\r
 772     /**\r
 773      * statement ::= exp BINDS exp\r
 774      */\r
 775     protected abstract Object reduceBindStatement();\r
 776     /**\r
 777      * statement ::= exp FOLLOWS queryBlock\r
 778      */\r
 779     protected abstract Object reduceRuleStatement();\r
 780     /**\r
 781      * statement ::= chrQuery IMPLIES chrQuery\r
 782      */\r
 783     protected abstract Object reduceCHRStatement();\r
 784     /**\r
 785      * statement ::= WHEN verboseChrQuery THEN_AFTER_WHEN verboseChrQuery\r
 786      */\r
 787     protected abstract Object reduceVerboseCHRStatement();\r
 788     /**\r
 789      * statement ::= CONSTRAINT ID atype&#42;\r
 790      */\r
 791     protected abstract Object reduceConstraintStatement();\r
 792     /**\r
 793      * declarations ::= LBRACE (declaration (SEMICOLON (declaration SEMICOLON)&#42; declaration)?)? RBRACE\r
 794      */\r
 795     protected abstract Object reduceDeclarations();\r
 796     /**\r
 797      * var ::= ID\r
 798      */\r
 799     protected abstract Object reduceVarId();\r
 800     /**\r
 801      * var ::= ESCAPED_SYMBOL\r
 802      */\r
 803     protected abstract Object reduceEscapedSymbol();\r
 804     /**\r
 805      * var ::= LPAREN COMMA COMMA&#42; RPAREN\r
 806      */\r
 807     protected abstract Object reduceTupleConstructor();\r
 808     /**\r
 809      * bexp ::= MINUS? lexp (symbol lexp)&#42;\r
 810      */\r
 811     protected abstract Object reduceBinary();\r
 812     /**\r
 813      * rhs ::= EQUALS exp (WHERE statements)?\r
 814      */\r
 815     protected abstract Object reduceSimpleRhs();\r
 816     /**\r
 817      * rhs ::= guardedExpEq guardedExpEq&#42; (WHERE statements)?\r
 818      */\r
 819     protected abstract Object reduceGuardedRhs();\r
 820     /**\r
 821      * constructor ::= (ANNOTATION_ID aexp)&#42; ID atype&#42;\r
 822      */\r
 823     protected abstract Object reduceConstructor();\r
 824     /**\r
 825      * constructor ::= (ANNOTATION_ID aexp)&#42; ID LBRACE fieldDeclaration (COMMA fieldDeclaration)&#42; RBRACE\r
 826      */\r
 827     protected abstract Object reduceRecordConstructor();\r
 828     /**\r
 829      * context ::= LPAREN type (COMMA type)&#42; RPAREN IMPLIES\r
 830      */\r
 831     protected abstract Object reduceContext();\r
 832     /**\r
 833      * fundeps ::= (fundep COMMA)&#42; fundep\r
 834      */\r
 835     protected abstract Object reduceFundeps();\r
 836     /**\r
 837      * atype ::= ID\r
 838      */\r
 839     protected abstract Object reduceTypeVar();\r
 840     /**\r
 841      * atype ::= LPAREN (type (COMMA (type COMMA)&#42; type)?)? RPAREN\r
 842      */\r
 843     protected abstract Object reduceTupleType();\r
 844     /**\r
 845      * atype ::= LBRACKET type RBRACKET\r
 846      */\r
 847     protected abstract Object reduceListType();\r
 848     /**\r
 849      * atype ::= LBRACKET RBRACKET\r
 850      */\r
 851     protected abstract Object reduceListTypeConstructor();\r
 852     /**\r
 853      * atype ::= LPAREN COMMA COMMA&#42; RPAREN\r
 854      */\r
 855     protected abstract Object reduceTupleTypeConstructor();\r
 856     /**\r
 857      * aexp ::= LAMBDA aexp aexp&#42; ARROW exp\r
 858      */\r
 859     protected abstract Object reduceLambda();\r
 860     /**\r
 861      * aexp ::= LAMBDA_MATCH LBRACE case (SEMICOLON case)&#42; RBRACE\r
 862      */\r
 863     protected abstract Object reduceLambdaMatch();\r
 864     /**\r
 865      * aexp ::= LET statements IN exp\r
 866      */\r
 867     protected abstract Object reduceLet();\r
 868     /**\r
 869      * aexp ::= IF exp THEN exp (ELSE exp)?\r
 870      */\r
 871     protected abstract Object reduceIf();\r
 872     /**\r
 873      * aexp ::= MATCH exp WITH LBRACE case (SEMICOLON case)&#42; RBRACE\r
 874      */\r
 875     protected abstract Object reduceMatch();\r
 876     /**\r
 877      * aexp ::= (DO | MDO) statements\r
 878      */\r
 879     protected abstract Object reduceDo();\r
 880     /**\r
 881      * aexp ::= (SELECT | SELECT_FIRST | SELECT_DISTINCT) exp WHERE queryBlock\r
 882      */\r
 883     protected abstract Object reduceSelect();\r
 884     /**\r
 885      * aexp ::= ENFORCE queryBlock\r
 886      */\r
 887     protected abstract Object reduceEnforce();\r
 888     /**\r
 889      * aexp ::= var\r
 890      */\r
 891     protected abstract Object reduceVar();\r
 892     /**\r
 893      * aexp ::= ATTACHED_HASH ID\r
 894      */\r
 895     protected abstract Object reduceHashedId();\r
 896     /**\r
 897      * aexp ::= BLANK\r
 898      */\r
 899     protected abstract Object reduceBlank();\r
 900     /**\r
 901      * aexp ::= INTEGER\r
 902      */\r
 903     protected abstract Object reduceInteger();\r
 904     /**\r
 905      * aexp ::= FLOAT\r
 906      */\r
 907     protected abstract Object reduceFloat();\r
 908     /**\r
 909      * aexp ::= stringLiteral\r
 910      */\r
 911     protected abstract Object reduceString();\r
 912     /**\r
 913      * aexp ::= CHAR\r
 914      */\r
 915     protected abstract Object reduceChar();\r
 916     /**\r
 917      * aexp ::= LPAREN (exp (COMMA (exp COMMA)&#42; exp)?)? RPAREN\r
 918      */\r
 919     protected abstract Object reduceTuple();\r
 920     /**\r
 921      * aexp ::= LPAREN exp ARROW exp RPAREN\r
 922      */\r
 923     protected abstract Object reduceViewPattern();\r
 924     /**\r
 925      * aexp ::= LPAREN symbolWithoutMinus lexp RPAREN\r
 926      */\r
 927     protected abstract Object reduceRightSection();\r
 928     /**\r
 929      * aexp ::= LPAREN lexp symbol RPAREN\r
 930      */\r
 931     protected abstract Object reduceLeftSection();\r
 932     /**\r
 933      * aexp ::= LBRACKET (exp (COMMA (exp COMMA)&#42; exp)?)? RBRACKET\r
 934      */\r
 935     protected abstract Object reduceListLiteral();\r
 936     /**\r
 937      * aexp ::= LBRACKET exp DOTDOT exp RBRACKET\r
 938      */\r
 939     protected abstract Object reduceRange();\r
 940     /**\r
 941      * aexp ::= LBRACKET exp BAR listQualifier (COMMA listQualifier)&#42; RBRACKET\r
 942      */\r
 943     protected abstract Object reduceListComprehension();\r
 944     /**\r
 945      * aexp ::= ID AT aexp\r
 946      */\r
 947     protected abstract Object reduceAs();\r
 948     /**\r
 949      * aexp ::= ID LBRACE (field (COMMA field)&#42;)? RBRACE\r
 950      */\r
 951     protected abstract Object reduceRecord();\r
 952     /**\r
 953      * aexp ::= TRANSFORMATION ID WHERE queryBlock\r
 954      */\r
 955     protected abstract Object reduceTransformation();\r
 956     /**\r
 957      * aexp ::= EQ LBRACE equationBlock RBRACE\r
 958      */\r
 959     protected abstract Object reduceEq();\r
 960     /**\r
 961      * ruleDeclarations ::= LBRACE (ruleDeclaration (SEMICOLON (ruleDeclaration SEMICOLON)&#42; ruleDeclaration)?)? RBRACE\r
 962      */\r
 963     protected abstract Object reduceRuleDeclarations();\r
 964     /**\r
 965      * importSpec ::= LPAREN (importItem (COMMA (importItem COMMA)&#42; importItem)?)? RPAREN\r
 966      */\r
 967     protected abstract Object reduceImportShowing();\r
 968     /**\r
 969      * importSpec ::= HIDING LPAREN (importItem (COMMA importItem)&#42;)? RPAREN\r
 970      */\r
 971     protected abstract Object reduceImportHiding();\r
 972     /**\r
 973      * importItem ::= ID\r
 974      */\r
 975     protected abstract Object reduceImportValueItem();\r
 976     /**\r
 977      * fieldDeclaration ::= ID HASTYPE type\r
 978      */\r
 979     protected abstract Object reduceFieldDescription();\r
 980     /**\r
 981      * statements ::= LBRACE (statement (SEMICOLON (statement SEMICOLON)&#42; statement)?)? RBRACE\r
 982      */\r
 983     protected abstract Object reduceStatements();\r
 984     /**\r
 985      * guardedExpEq ::= BAR exp (COMMA exp)&#42; EQUALS exp\r
 986      */\r
 987     protected abstract Object reduceGuardedExpEq();\r
 988     /**\r
 989      * fundep ::= ID ID&#42; ARROW ID\r
 990      */\r
 991     protected abstract Object reduceFundep();\r
 992     /**\r
 993      * ruleDeclaration ::= query\r
 994      */\r
 995     protected abstract Object reduceQueryRuleDeclaration();\r
 996     /**\r
 997      * query ::= exp\r
 998      */\r
 999     protected abstract Object reduceGuardQuery();\r
1000     /**\r
1001      * query ::= exp EQUALS exp\r
1002      */\r
1003     protected abstract Object reduceEqualsQuery();\r
1004     /**\r
1005      * query ::= exp BINDS exp\r
1006      */\r
1007     protected abstract Object reduceBindQuery();\r
1008     /**\r
1009      * query ::= QUERY_OP queryBlock\r
1010      */\r
1011     protected abstract Object reduceCompositeQuery();\r
1012     /**\r
1013      * queryBlock ::= LBRACE (query (SEMICOLON (query SEMICOLON)&#42; query)?)? RBRACE\r
1014      */\r
1015     protected abstract Object reduceQueryBlock();\r
1016     /**\r
1017      * lexp ::= faexp faexp&#42;\r
1018      */\r
1019     protected abstract Object reduceApply();\r
1020     /**\r
1021      * symbol ::= SYMBOL\r
1022      */\r
1023     protected abstract Object reduceSymbol();\r
1024     /**\r
1025      * symbol ::= ESCAPED_ID\r
1026      */\r
1027     protected abstract Object reduceEscapedId();\r
1028     /**\r
1029      * symbol ::= MINUS\r
1030      */\r
1031     protected abstract Object reduceMinus();\r
1032     /**\r
1033      * symbol ::= LESS\r
1034      */\r
1035     protected abstract Object reduceLess();\r
1036     /**\r
1037      * symbol ::= GREATER\r
1038      */\r
1039     protected abstract Object reduceGreater();\r
1040     /**\r
1041      * symbol ::= SEPARATED_DOT\r
1042      */\r
1043     protected abstract Object reduceDot();\r
1044     /**\r
1045      * faexp ::= aexp ((ATTACHED_HASH | ATTACHED_DOT) accessor)&#42;\r
1046      */\r
1047     protected abstract Object reduceFieldAccess();\r
1048     /**\r
1049      * accessor ::= ID\r
1050      */\r
1051     protected abstract Object reduceIdAccessor();\r
1052     /**\r
1053      * accessor ::= BEGIN_STRING END_STRING\r
1054      */\r
1055     protected abstract Object reduceStringAccessor();\r
1056     /**\r
1057      * accessor ::= LPAREN exp RPAREN\r
1058      */\r
1059     protected abstract Object reduceExpAccessor();\r
1060     /**\r
1061      * case ::= exp caseRhs\r
1062      */\r
1063     protected abstract Object reduceCase();\r
1064     /**\r
1065      * stringLiteral ::= BEGIN_STRING (SUSPEND_STRING exp CONTINUE_STRING)&#42; END_STRING\r
1066      */\r
1067     protected abstract Object reduceStringLiteral();\r
1068     /**\r
1069      * listQualifier ::= exp\r
1070      */\r
1071     protected abstract Object reduceGuardQualifier();\r
1072     /**\r
1073      * listQualifier ::= exp EQUALS exp\r
1074      */\r
1075     protected abstract Object reduceLetQualifier();\r
1076     /**\r
1077      * listQualifier ::= exp BINDS exp\r
1078      */\r
1079     protected abstract Object reduceBindQualifier();\r
1080     /**\r
1081      * listQualifier ::= THEN exp (BY exp)?\r
1082      */\r
1083     protected abstract Object reduceThenQualifier();\r
1084     /**\r
1085      * field ::= ID EQUALS exp\r
1086      */\r
1087     protected abstract Object reduceField();\r
1088     /**\r
1089      * field ::= ID\r
1090      */\r
1091     protected abstract Object reduceFieldShorthand();\r
1092     /**\r
1093      * chrQuery ::= (listQualifier COMMA)&#42; listQualifier\r
1094      */\r
1095     protected abstract Object reduceCHRQuery();\r
1096     /**\r
1097      * verboseChrQuery ::= LBRACE listQualifier (SEMICOLON listQualifier)&#42; RBRACE\r
1098      */\r
1099     protected abstract Object reduceVerboseCHRQuery();\r
1100     /**\r
1101      * caseRhs ::= ARROW exp (WHERE statements)?\r
1102      */\r
1103     protected abstract Object reduceSimpleCaseRhs();\r
1104     /**\r
1105      * caseRhs ::= guardedExpArrow guardedExpArrow&#42; (WHERE statements)?\r
1106      */\r
1107     protected abstract Object reduceGuardedCaseRhs();\r
1108     /**\r
1109      * guardedExpArrow ::= BAR exp (COMMA exp)&#42; ARROW exp\r
1110      */\r
1111     protected abstract Object reduceGuardedExpArrow();\r
1112     /**\r
1113      * equation ::= exp\r
1114      */\r
1115     protected abstract Object reduceGuardEquation();\r
1116     /**\r
1117      * equation ::= exp EQUALS exp\r
1118      */\r
1119     protected abstract Object reduceBasicEquation();\r
1120     /**\r
1121      * etype ::= LESS ID (COMMA ID)&#42; GREATER btype\r
1122      */\r
1123     protected abstract Object reduceEffect();\r
1124     /**\r
1125      * etype ::= btype\r
1126      */\r
1127     protected abstract Object reduceJustEtype();\r
1128     /**\r
1129      * etype ::= FORALL ID ID&#42; (SEPARATED_DOT | ATTACHED_DOT) type\r
1130      */\r
1131     protected abstract Object reduceForAll();\r
1132     /**\r
1133      * btype ::= atype atype&#42;\r
1134      */\r
1135     protected abstract Object reduceApplyType();\r
1136     /**\r
1137      * dummy ::= COMMENT EOL\r
1138      */\r
1139     protected abstract Object reduceDummy1();\r
1140 \r
1141     protected void postReduce(Object reduced) {\r
1142     }\r
1143 \r
1144 }\r