| |
| /*================================================================*/ |
| /* |
| JavaCup Specification for the JavaCup Specification Language |
| by Scott Hudson, GVU Center, Georgia Tech, August 1995 |
| |
| This JavaCup specification is used to implement JavaCup itself. |
| It specifies the parser for the JavaCup specification language. |
| (It also serves as a reasonable example of what a typical JavaCup |
| spec looks like). |
| |
| The specification has the following parts: |
| Package and import declarations |
| These serve the same purpose as in a normal Java source file |
| (and will appear in the generated code for the parser). In this |
| case we are part of the java_cup package and we import both the |
| java_cup runtime system and Hashtable from the standard Java |
| utilities package. |
| |
| Action code |
| This section provides code that is included with the class encapsulating |
| the various pieces of user code embedded in the grammar (i.e., the |
| semantic actions). This provides a series of helper routines and |
| data structures that the semantic actions use. |
| |
| Parser code |
| This section provides code included in the parser class itself. In |
| this case we override the default error reporting routines. |
| |
| Init with and scan with |
| These sections provide small bits of code that initialize, then |
| indicate how to invoke the scanner. |
| |
| Symbols and grammar |
| These sections declare all the terminal and non terminal symbols |
| and the types of objects that they will be represented by at runtime, |
| then indicate the start symbol of the grammar (), and finally provide |
| the grammar itself (with embedded actions). |
| |
| Operation of the parser |
| The parser acts primarily by accumulating data structures representing |
| various parts of the specification. Various small parts (e.g., single |
| code strings) are stored as static variables of the emit class and |
| in a few cases as variables declared in the action code section. |
| Terminals, non terminals, and productions, are maintained as collection |
| accessible via static methods of those classes. In addition, two |
| symbol tables are kept: |
| symbols maintains the name to object mapping for all symbols |
| non_terms maintains a separate mapping containing only the non terms |
| |
| Several intermediate working structures are also declared in the action |
| code section. These include: rhs_parts, rhs_pos, and lhs_nt which |
| build up parts of the current production while it is being parsed. |
| |
| Author(s) |
| Scott Hudson, GVU Center, Georgia Tech. |
| |
| Revisions |
| v0.9a First released version [SEH] 8/29/95 |
| v0.9b Updated for beta language (throws clauses) [SEH] 11/25/95 |
| */ |
| /*================================================================*/ |
| |
| package java_cup; |
| import java_cup.runtime.*; |
| import java.util.Hashtable; |
| |
| /*----------------------------------------------------------------*/ |
| |
| action code {: |
| /** helper routine to clone a new production part adding a given label */ |
| protected production_part add_lab(production_part part, String lab) |
| throws internal_error |
| { |
| /* if there is no label, or this is an action, just return the original */ |
| if (lab == null || part.is_action()) return part; |
| |
| /* otherwise build a new one with the given label attached */ |
| return new symbol_part(((symbol_part)part).the_symbol(),lab); |
| } |
| |
| /** max size of right hand side we will support */ |
| protected final int MAX_RHS = 200; |
| |
| /** array for accumulating right hand side parts */ |
| protected production_part[] rhs_parts = new production_part[MAX_RHS]; |
| |
| /** where we are currently in building a right hand side */ |
| protected int rhs_pos = 0; |
| |
| /** start a new right hand side */ |
| protected void new_rhs() {rhs_pos = 0; } |
| |
| /** add a new right hand side part */ |
| protected void add_rhs_part(production_part part) throws java.lang.Exception |
| { |
| if (rhs_pos >= MAX_RHS) |
| throw new Exception("Internal Error: Productions limited to " + |
| MAX_RHS + " symbols and actions"); |
| |
| rhs_parts[rhs_pos] = part; |
| rhs_pos++; |
| } |
| |
| /** string to build up multiple part names */ |
| protected String multipart_name = new String(); |
| |
| /** append a new name segment to the accumulated multipart name */ |
| protected void append_multipart(String name) |
| { |
| String dot = ""; |
| |
| /* if we aren't just starting out, put on a dot */ |
| if (multipart_name.length() != 0) dot = "."; |
| |
| multipart_name = multipart_name.concat(dot + name); |
| } |
| |
| /** table of declared symbols -- contains production parts indexed by name */ |
| protected Hashtable symbols = new Hashtable(); |
| |
| /** table of just non terminals -- contains non_terminals indexed by name */ |
| protected Hashtable non_terms = new Hashtable(); |
| |
| /** declared start non_terminal */ |
| protected non_terminal start_nt = null; |
| |
| /** left hand side non terminal of the current production */ |
| protected non_terminal lhs_nt; |
| |
| :}; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| parser code {: |
| |
| /* override error routines */ |
| |
| public void report_fatal_error( |
| String message, |
| Object info) |
| { |
| done_parsing(); |
| lexer.emit_error(message); |
| System.err.println("Can't recover from previous error(s), giving up."); |
| System.exit(1); |
| } |
| |
| public void report_error(String message, Object info) |
| { |
| lexer.emit_error(message); |
| } |
| :}; |
| |
| /*----------------------------------------------------------------*/ |
| |
| init with {: lexer.init(); :}; |
| scan with {: return lexer.next_token(); :}; |
| |
| /*----------------------------------------------------------------*/ |
| |
| terminal java_cup.runtime.token |
| PACKAGE, IMPORT, CODE, ACTION, PARSER, TERMINAL, NON, INIT, SCAN, WITH, |
| START, SEMI, COMMA, STAR, DOT, COLON, COLON_COLON_EQUALS, BAR, |
| DEBUG; |
| |
| terminal java_cup.runtime.str_token ID, CODE_STRING; |
| |
| non terminal java_cup.runtime.symbol |
| spec, package_spec, import_list, code_part, action_code_part, |
| parser_code_part, symbol_list, start_spec, production_list, |
| multipart_id, import_spec, import_id, init_code, scan_code, symbol, |
| debug_grammar, |
| type_id, term_name_list, non_term_name_list, production, prod_part_list, |
| prod_part, new_term_id, new_non_term_id, rhs_list, rhs, empty; |
| |
| non terminal java_cup.runtime.str_token nt_id, symbol_id, label_id, opt_label; |
| |
| /*----------------------------------------------------------------*/ |
| |
| start with spec; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| spec ::= |
| {: |
| /* declare "error" as a terminal */ |
| symbols.put("error", new symbol_part(terminal.error)); |
| |
| /* declare start non terminal */ |
| non_terms.put("$START", non_terminal.START_nt); |
| :} |
| package_spec |
| import_list |
| code_part |
| debug_grammar |
| init_code |
| scan_code |
| symbol_list |
| start_spec |
| production_list |
| | |
| /* error recovery assuming something went wrong before symbols |
| and we have TERMINAL or NON TERMINAL to sync on. if we get |
| an error after that, we recover inside symbol_list or |
| production_list |
| */ |
| error |
| symbol_list |
| start_spec |
| production_list |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| package_spec ::= |
| PACKAGE |
| multipart_id |
| {: |
| /* save the package name */ |
| emit.package_name = multipart_name; |
| |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| import_list ::= |
| import_list |
| import_spec |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| import_spec ::= |
| IMPORT |
| import_id |
| {: |
| /* save this import on the imports list */ |
| emit.import_list.push(multipart_name); |
| |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| code_part ::= action_code_part parser_code_part ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| action_code_part ::= |
| ACTION CODE CODE_STRING:user_code SEMI |
| {: |
| /* save the user included code string */ |
| emit.action_code = user_code.str_val; |
| :} |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| parser_code_part ::= |
| PARSER CODE CODE_STRING:user_code SEMI |
| {: |
| /* save the user included code string */ |
| emit.parser_code = user_code.str_val; |
| :} |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| init_code ::= |
| INIT WITH CODE_STRING:user_code SEMI |
| {: |
| /* save the user code */ |
| emit.init_code = user_code.str_val; |
| :} |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| scan_code ::= |
| SCAN WITH CODE_STRING:user_code SEMI |
| {: |
| /* save the user code */ |
| emit.scan_code = user_code.str_val; |
| :} |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| debug_grammar ::= |
| DEBUG WITH multipart_id SEMI |
| {: |
| /* save the procedure name */ |
| emit.debug_grammar = multipart_name; |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| symbol_list ::= symbol_list symbol | symbol; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| symbol ::= |
| TERMINAL |
| type_id |
| term_name_list |
| {: |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| | |
| NON |
| TERMINAL |
| type_id |
| non_term_name_list |
| {: |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| | |
| |
| /* error recovery productions -- sync on semicolon */ |
| |
| TERMINAL |
| error |
| {: |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| | |
| NON |
| TERMINAL |
| error |
| {: |
| /* reset the accumulated multipart name */ |
| multipart_name = new String(); |
| :} |
| SEMI |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| term_name_list ::= term_name_list COMMA new_term_id | new_term_id; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| non_term_name_list ::= |
| non_term_name_list |
| COMMA |
| new_non_term_id |
| | |
| new_non_term_id |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| start_spec ::= |
| START WITH nt_id:start_name |
| {: |
| /* verify that the name has been declared as a non terminal */ |
| non_terminal nt = (non_terminal)non_terms.get(start_name.str_val); |
| if (nt == null) |
| { |
| lexer.emit_error( "Start non terminal \"" + start_name.str_val + |
| "\" has not been declared"); |
| } |
| else |
| { |
| /* remember the non-terminal for later */ |
| start_nt = nt; |
| |
| /* build a special start production */ |
| new_rhs(); |
| add_rhs_part(new symbol_part(start_nt)); |
| add_rhs_part(new symbol_part(terminal.EOF)); |
| emit.start_production = |
| new production(non_terminal.START_nt, rhs_parts, rhs_pos); |
| new_rhs(); |
| } |
| :} |
| SEMI |
| | |
| empty |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| production_list ::= production_list production | production; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| production ::= |
| nt_id:lhs_id |
| {: |
| /* lookup the lhs nt */ |
| lhs_nt = (non_terminal)non_terms.get(lhs_id.str_val); |
| |
| /* if it wasn't declared, emit a message */ |
| if (lhs_nt == null) |
| { |
| if (lexer.error_count == 0) |
| lexer.emit_error("LHS non terminal \"" + lhs_id.str_val + |
| "\" has not been declared"); |
| } |
| |
| /* reset the rhs accumulation */ |
| new_rhs(); |
| :} |
| COLON_COLON_EQUALS |
| rhs_list |
| SEMI |
| | |
| error |
| {: lexer.emit_error("Syntax Error"); :} |
| SEMI |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| rhs_list ::= rhs_list BAR rhs | rhs; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| rhs ::= |
| prod_part_list |
| {: |
| if (lhs_nt != null) |
| { |
| /* build the production */ |
| production p = new production(lhs_nt, rhs_parts, rhs_pos); |
| |
| /* if we have no start non-terminal declared and this is |
| the first production, make its lhs nt the start_nt |
| and build a special start production for it. */ |
| if (start_nt == null) |
| { |
| start_nt = lhs_nt; |
| |
| /* build a special start production */ |
| new_rhs(); |
| add_rhs_part(new symbol_part(start_nt)); |
| add_rhs_part(new symbol_part(terminal.EOF)); |
| emit.start_production = |
| new production(non_terminal.START_nt, rhs_parts, rhs_pos); |
| new_rhs(); |
| } |
| } |
| |
| /* reset the rhs accumulation in any case */ |
| new_rhs(); |
| :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| prod_part_list ::= prod_part_list prod_part | empty; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| prod_part ::= |
| symbol_id:symid opt_label:labid |
| {: |
| /* try to look up the id */ |
| production_part symb = (production_part)symbols.get(symid.str_val); |
| |
| /* if that fails, symbol is undeclared */ |
| if (symb == null) |
| { |
| if (lexer.error_count == 0) |
| lexer.emit_error("Symbol \"" + symid.str_val + |
| "\" has not been declared"); |
| } |
| else |
| { |
| /* add a labeled production part */ |
| add_rhs_part(add_lab(symb, labid.str_val)); |
| } |
| :} |
| | |
| CODE_STRING:code_str |
| {: |
| /* add a new production part */ |
| add_rhs_part(new action_part(code_str.str_val)); |
| :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| opt_label ::= |
| COLON label_id:labid |
| {: RESULT.str_val = labid.str_val; :} |
| | |
| empty |
| {: RESULT.str_val = null; :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| multipart_id ::= |
| multipart_id DOT ID:another_id |
| {: append_multipart(another_id.str_val); :} |
| | |
| ID:an_id |
| {: append_multipart(an_id.str_val); :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| import_id ::= |
| multipart_id DOT STAR |
| {: append_multipart("*"); :} |
| | |
| multipart_id |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| type_id ::= multipart_id; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| new_term_id ::= |
| ID:term_id |
| {: |
| /* see if this terminal has been declared before */ |
| if (symbols.get(term_id.str_val) != null) |
| { |
| /* issue a message */ |
| lexer.emit_error("Symbol \"" + term_id.str_val + |
| "\" has already been declared"); |
| } |
| else |
| { |
| /* build a production_part and put it in the table */ |
| symbols.put(term_id.str_val, |
| new symbol_part(new terminal(term_id.str_val, multipart_name))); |
| } |
| :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| new_non_term_id ::= |
| ID:non_term_id |
| {: |
| /* see if this non terminal has been declared before */ |
| if (symbols.get(non_term_id.str_val) != null) |
| { |
| /* issue a message */ |
| lexer.emit_error( "Symbol \"" + non_term_id.str_val + |
| "\" has already been declared"); |
| } |
| else |
| { |
| /* build the non terminal object */ |
| non_terminal this_nt = |
| new non_terminal(non_term_id.str_val, multipart_name); |
| |
| /* put it in the non_terms table */ |
| non_terms.put(non_term_id.str_val, this_nt); |
| |
| /* build a production_part and put it in the symbols table */ |
| symbols.put(non_term_id.str_val, new symbol_part(this_nt)); |
| } |
| :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| nt_id ::= |
| ID:the_id |
| {: RESULT.str_val = the_id.str_val; :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| symbol_id ::= |
| ID:the_id |
| {: RESULT.str_val = the_id.str_val; :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| label_id ::= |
| ID:the_id |
| {: RESULT.str_val = the_id.str_val; :} |
| ; |
| |
| /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ |
| |
| empty ::= /* nothing */; |
| |
| /*----------------------------------------------------------------*/ |
