lr_parser.scan(). Integration
* of scanners implementing Scanner is facilitated.
*
* @version last updated 23-Jul-1999
* @author David MacMahon new Symbol(lr_parser.EOF_sym()) or
null.
***************************************************/
public interface Scanner {
/** Return the next token, or null on end-of-file. */
public Symbol next_token() throws java.lang.Exception;
}
cup-0.11a+20060608/src/java_cup/runtime/virtual_parse_stack.java 0000644 0001750 0001750 00000011577 10250537770 024215 0 ustar twerner twerner
package java_cup.runtime;
import java.util.Stack;
/** This class implements a temporary or "virtual" parse stack that
* replaces the top portion of the actual parse stack (the part that
* has been changed by some set of operations) while maintaining its
* original contents. This data structure is used when the parse needs
* to "parse ahead" to determine if a given error recovery attempt will
* allow the parse to continue far enough to consider it successful. Once
* success or failure of parse ahead is determined the system then
* reverts to the original parse stack (which has not actually been
* modified). Since parse ahead does not execute actions, only parse
* state is maintained on the virtual stack, not full Symbol objects.
*
* @see java_cup.runtime.lr_parser
* @version last updated: 7/3/96
* @author Frank Flannery
*/
public class virtual_parse_stack {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Constructor to build a virtual stack out of a real stack. */
public virtual_parse_stack(Stack shadowing_stack) throws java.lang.Exception
{
/* sanity check */
if (shadowing_stack == null)
throw new Exception(
"Internal parser error: attempt to create null virtual stack");
/* set up our internals */
real_stack = shadowing_stack;
vstack = new Stack();
real_next = 0;
/* get one element onto the virtual portion of the stack */
get_from_real();
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The real stack that we shadow. This is accessed when we move off
* the bottom of the virtual portion of the stack, but is always left
* unmodified.
*/
protected Stack real_stack;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Top of stack indicator for where we leave off in the real stack.
* This is measured from top of stack, so 0 would indicate that no
* elements have been "moved" from the real to virtual stack.
*/
protected int real_next;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** The virtual top portion of the stack. This stack contains Integer
* objects with state numbers. This stack shadows the top portion
* of the real stack within the area that has been modified (via operations
* on the virtual stack). When this portion of the stack becomes empty we
* transfer elements from the underlying stack onto this stack.
*/
protected Stack vstack;
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Transfer an element from the real to the virtual stack. This assumes
* that the virtual stack is currently empty.
*/
protected void get_from_real()
{
Symbol stack_sym;
/* don't transfer if the real stack is empty */
if (real_next >= real_stack.size()) return;
/* get a copy of the first Symbol we have not transfered */
stack_sym = (Symbol)real_stack.elementAt(real_stack.size()-1-real_next);
/* record the transfer */
real_next++;
/* put the state number from the Symbol onto the virtual stack */
vstack.push(new Integer(stack_sym.parse_state));
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Indicate whether the stack is empty. */
public boolean empty()
{
/* if vstack is empty then we were unable to transfer onto it and
the whole thing is empty. */
return vstack.empty();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Return value on the top of the stack (without popping it). */
public int top() throws java.lang.Exception
{
if (vstack.empty())
throw new Exception(
"Internal parser error: top() called on empty virtual stack");
return ((Integer)vstack.peek()).intValue();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Pop the stack. */
public void pop() throws java.lang.Exception
{
if (vstack.empty())
throw new Exception(
"Internal parser error: pop from empty virtual stack");
/* pop it */
vstack.pop();
/* if we are now empty transfer an element (if there is one) */
if (vstack.empty())
get_from_real();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Push a state number onto the stack. */
public void push(int state_num)
{
vstack.push(new Integer(state_num));
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/runtime/ComplexSymbolFactory.java 0000644 0001750 0001750 00000007627 10413036260 024263 0 ustar twerner twerner package java_cup.runtime;
/**
* Default Implementation for SymbolFactory, creates
* plain old Symbols
*
* @version last updated 27-03-2006
* @author Michael Petter
*/
/* *************************************************
class DefaultSymbolFactory
interface for creating new symbols
***************************************************/
public class ComplexSymbolFactory implements SymbolFactory{
public static class Location {
private String unit="unknown";
private int line, column;
public Location(String unit, int line, int column){
this.unit=unit;
this.line=line;
this.column=column;
}
public Location(int line, int column){
this.line=line;
this.column=column;
}
public String toString(){
return unit+":"+line+"/"+column;
}
public int getColumn(){
return column;
}
public int getLine(){
return line;
}
public String getUnit(){
return unit;
}
}
/**
* ComplexSymbol with detailed Location Informations and a Name
*/
public static class ComplexSymbol extends Symbol {
protected String name;
protected Location xleft,xright;
public ComplexSymbol(String name, int id) {
super(id);
this.name=name;
}
public ComplexSymbol(String name, int id, Object value) {
super(id,value);
this.name=name;
}
public String toString(){
if (xleft==null || xright==null) return "Symbol: "+name;
return "Symbol: "+name+" ("+xleft+" - "+xright+")";
}
public ComplexSymbol(String name, int id, int state) {
super(id,state);
this.name=name;
}
public ComplexSymbol(String name, int id, Symbol left, Symbol right) {
super(id,left,right);
this.name=name;
if (left!=null) this.xleft = ((ComplexSymbol)left).xleft;
if (right!=null) this.xright= ((ComplexSymbol)right).xright;
}
public ComplexSymbol(String name, int id, Location left, Location right) {
super(id);
this.name=name;
this.xleft=left;
this.xright=right;
}
public ComplexSymbol(String name, int id, Symbol left, Symbol right, Object value) {
super(id,value);
this.name=name;
if (left!=null) this.xleft = ((ComplexSymbol)left).xleft;
if (right!=null) this.xright= ((ComplexSymbol)right).xright;
}
public ComplexSymbol(String name, int id, Location left, Location right, Object value) {
super(id,value);
this.name=name;
this.xleft=left;
this.xright=right;
}
public Location getLeft(){
return xleft;
}
public Location getRight(){
return xright;
}
}
// Factory methods
public Symbol newSymbol(String name, int id, Location left, Location right, Object value){
return new ComplexSymbol(name,id,left,right,value);
}
public Symbol newSymbol(String name, int id, Location left, Location right){
return new ComplexSymbol(name,id,left,right);
}
public Symbol newSymbol(String name, int id, Symbol left, Symbol right, Object value){
return new ComplexSymbol(name,id,left,right,value);
}
public Symbol newSymbol(String name, int id, Symbol left, Symbol right){
return new ComplexSymbol(name,id,left,right);
}
public Symbol newSymbol(String name, int id){
return new ComplexSymbol(name,id);
}
public Symbol newSymbol(String name, int id, Object value){
return new ComplexSymbol(name,id,value);
}
public Symbol startSymbol(String name, int id, int state){
return new ComplexSymbol(name,id,state);
}
}
cup-0.11a+20060608/src/java_cup/runtime/Symbol.java 0000644 0001750 0001750 00000006115 10412217534 021376 0 ustar twerner twerner package java_cup.runtime;
/**
* Defines the Symbol class, which is used to represent all terminals
* and nonterminals while parsing. The lexer should pass CUP Symbols
* and CUP returns a Symbol.
*
* @version last updated: 7/3/96
* @author Frank Flannery
*/
/* ****************************************************************
Class Symbol
what the parser expects to receive from the lexer.
the token is identified as follows:
sym: the symbol type
parse_state: the parse state.
value: is the lexical value of type Object
left : is the left position in the original input file
right: is the right position in the original input file
xleft: is the left position Object in the original input file
xright: is the left position Object in the original input file
******************************************************************/
public class Symbol {
// TUM 20060327: Added new Constructor to provide more flexible way
// for location handling
/*******************************
*******************************/
public Symbol(int id, Symbol left, Symbol right, Object o){
this(id,left.left,right.right,o);
}
public Symbol(int id, Symbol left, Symbol right){
this(id,left.left,right.right);
}
/*******************************
Constructor for l,r values
*******************************/
public Symbol(int id, int l, int r, Object o) {
this(id);
left = l;
right = r;
value = o;
}
/*******************************
Constructor for no l,r values
********************************/
public Symbol(int id, Object o) {
this(id, -1, -1, o);
}
/*****************************
Constructor for no value
***************************/
public Symbol(int id, int l, int r) {
this(id, l, r, null);
}
/***********************************
Constructor for no value or l,r
***********************************/
public Symbol(int sym_num) {
this(sym_num, -1);
left = -1;
right = -1;
}
/***********************************
Constructor to give a start state
***********************************/
Symbol(int sym_num, int state)
{
sym = sym_num;
parse_state = state;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** The symbol number of the terminal or non terminal being represented */
public int sym;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** The parse state to be recorded on the parse stack with this symbol.
* This field is for the convenience of the parser and shouldn't be
* modified except by the parser.
*/
public int parse_state;
/** This allows us to catch some errors caused by scanners recycling
* symbols. For the use of the parser only. [CSA, 23-Jul-1999] */
boolean used_by_parser = false;
/*******************************
The data passed to parser
*******************************/
public int left, right;
public Object value;
/*****************************
Printing this token out. (Override for pretty-print).
****************************/
public String toString() { return "#"+sym; }
}
cup-0.11a+20060608/src/java_cup/runtime/DefaultSymbolFactory.java 0000644 0001750 0001750 00000003342 10413036260 024226 0 ustar twerner twerner package java_cup.runtime;
/**
* Default Implementation for SymbolFactory, creates
* plain old Symbols
*
* @version last updated 27-03-2006
* @author Michael Petter
*/
/* *************************************************
class DefaultSymbolFactory
interface for creating new symbols
***************************************************/
public class DefaultSymbolFactory implements SymbolFactory{
// Factory methods
/**
* DefaultSymbolFactory for CUP.
* Users are strongly encoraged to use ComplexSymbolFactory instead, since
* it offers more detailed information about Symbols in source code.
* Yet since migrating has always been a critical process, You have the
* chance of still using the oldstyle Symbols.
*
* @deprecated as of CUP v11a
* replaced by the new java_cup.runtime.ComplexSymbolFactory
*/
//@deprecated
public DefaultSymbolFactory(){
}
public Symbol newSymbol(String name ,int id, Symbol left, Symbol right, Object value){
return new Symbol(id,left,right,value);
}
public Symbol newSymbol(String name, int id, Symbol left, Symbol right){
return new Symbol(id,left,right);
}
public Symbol newSymbol(String name, int id, int left, int right, Object value){
return new Symbol(id,left,right,value);
}
public Symbol newSymbol(String name, int id, int left, int right){
return new Symbol(id,left,right);
}
public Symbol startSymbol(String name, int id, int state){
return new Symbol(id,state);
}
public Symbol newSymbol(String name, int id){
return new Symbol(id);
}
public Symbol newSymbol(String name, int id, Object value){
return new Symbol(id,value);
}
}
cup-0.11a+20060608/src/java_cup/runtime/SymbolFactory.java 0000644 0001750 0001750 00000002072 10413036260 022720 0 ustar twerner twerner package java_cup.runtime;
/**
* Creates the Symbols interface, which CUP uses as default
*
* @version last updated 27-03-2006
* @author Michael Petter
*/
/* *************************************************
Interface SymbolFactory
interface for creating new symbols
You can also use this interface for your own callback hooks
Declare Your own factory methods for creation of Objects in Your scanner!
***************************************************/
public interface SymbolFactory {
// Factory methods
/**
* Construction with left/right propagation switched on
*/
public Symbol newSymbol(String name, int id, Symbol left, Symbol right, Object value);
public Symbol newSymbol(String name, int id, Symbol left, Symbol right);
/**
* Construction with left/right propagation switched off
*/
public Symbol newSymbol(String name, int id, Object value);
public Symbol newSymbol(String name, int id);
/**
* Construction of start symbol
*/
public Symbol startSymbol(String name, int id, int state);
}
cup-0.11a+20060608/src/java_cup/runtime/lr_parser.java 0000644 0001750 0001750 00000127426 10412217534 022133 0 ustar twerner twerner
package java_cup.runtime;
import java.util.Stack;
/** This class implements a skeleton table driven LR parser. In general,
* LR parsers are a form of bottom up shift-reduce parsers. Shift-reduce
* parsers act by shifting input onto a parse stack until the Symbols
* matching the right hand side of a production appear on the top of the
* stack. Once this occurs, a reduce is performed. This involves removing
* the Symbols corresponding to the right hand side of the production
* (the so called "handle") and replacing them with the non-terminal from
* the left hand side of the production. * * To control the decision of whether to shift or reduce at any given point, * the parser uses a state machine (the "viable prefix recognition machine" * built by the parser generator). The current state of the machine is placed * on top of the parse stack (stored as part of a Symbol object representing * a terminal or non terminal). The parse action table is consulted * (using the current state and the current lookahead Symbol as indexes) to * determine whether to shift or to reduce. When the parser shifts, it * changes to a new state by pushing a new Symbol (containing a new state) * onto the stack. When the parser reduces, it pops the handle (right hand * side of a production) off the stack. This leaves the parser in the state * it was in before any of those Symbols were matched. Next the reduce-goto * table is consulted (using the new state and current lookahead Symbol as * indexes) to determine a new state to go to. The parser then shifts to * this goto state by pushing the left hand side Symbol of the production * (also containing the new state) onto the stack.
* * This class actually provides four LR parsers. The methods parse() and * debug_parse() provide two versions of the main parser (the only difference * being that debug_parse() emits debugging trace messages as it parses). * In addition to these main parsers, the error recovery mechanism uses two * more. One of these is used to simulate "parsing ahead" in the input * without carrying out actions (to verify that a potential error recovery * has worked), and the other is used to parse through buffered "parse ahead" * input in order to execute all actions and re-synchronize the actual parser * configuration.
* * This is an abstract class which is normally filled out by a subclass * generated by the JavaCup parser generator. In addition to supplying * the actual parse tables, generated code also supplies methods which * invoke various pieces of user supplied code, provide access to certain * special Symbols (e.g., EOF and error), etc. Specifically, the following * abstract methods are normally supplied by generated code: *
-
*
- short[][] production_table() *
- Provides a reference to the production table (indicating the index of * the left hand side non terminal and the length of the right hand side * for each production in the grammar). *
- short[][] action_table() *
- Provides a reference to the parse action table. *
- short[][] reduce_table() *
- Provides a reference to the reduce-goto table. *
- int start_state() *
- Indicates the index of the start state. *
- int start_production() *
- Indicates the index of the starting production. *
- int EOF_sym() *
- Indicates the index of the EOF Symbol. *
- int error_sym() *
- Indicates the index of the error Symbol. *
- Symbol do_action() *
- Executes a piece of user supplied action code. This always comes at * the point of a reduce in the parse, so this code also allocates and * fills in the left hand side non terminal Symbol object that is to be * pushed onto the stack for the reduce. *
- void init_actions() *
- Code to initialize a special object that encapsulates user supplied * actions (this object is used by do_action() to actually carry out the * actions). *
-
*
- Symbol scan() *
- Used to get the next input Symbol from the scanner. *
- Scanner getScanner() *
- Used to provide a scanner for the default implementation of * scan(). *
- int error_sync_size() *
- This determines how many Symbols past the point of an error * must be parsed without error in order to consider a recovery to * be valid. This defaults to 3. Values less than 2 are not * recommended. *
- void report_error(String message, Object info) *
- This method is called to report an error. The default implementation * simply prints a message to System.err and where the error occurred. * This method is often replaced in order to provide a more sophisticated * error reporting mechanism. *
- void report_fatal_error(String message, Object info) *
- This method is called when a fatal error that cannot be recovered from * is encountered. In the default implementation, it calls * report_error() to emit a message, then throws an exception. *
- void syntax_error(Symbol cur_token) *
- This method is called as soon as syntax error is detected (but * before recovery is attempted). In the default implementation it * invokes: report_error("Syntax error", null); *
- void unrecovered_syntax_error(Symbol cur_token) *
- This method is called if syntax error recovery fails. In the default
* implementation it invokes:
* report_fatal_error("Couldn't repair and continue parse", null); *
* * Factoring out of actions is accomplished by creating new "hidden" * non terminals. For example if the production was originally:
* A ::= B {action} C D
*
* then it is factored into two productions:
* A ::= B X C D
* X ::= {action}
*
* (where X is a unique new non terminal). This has the effect of placing
* all actions at the end where they can be handled as part of a reduce by
* the parser.
*/
public production(
non_terminal lhs_sym,
production_part rhs_parts[],
int rhs_l,
String action_str)
throws internal_error
{
int i;
action_part tail_action;
String declare_str;
int rightlen = rhs_l;
/* remember the length */
if (rhs_l >= 0)
_rhs_length = rhs_l;
else if (rhs_parts != null)
_rhs_length = rhs_parts.length;
else
_rhs_length = 0;
/* make sure we have a valid left-hand-side */
if (lhs_sym == null)
throw new internal_error(
"Attempt to construct a production with a null LHS");
/* I'm not translating labels anymore, I'm adding code to declare
labels as valid variables. This way, the users code string is
untouched
6/96 frankf */
/* check if the last part of the right hand side is an action. If
it is, it won't be on the stack, so we don't want to count it
in the rightlen. Then when we search down the stack for a
Symbol, we don't try to search past action */
if (rhs_l > 0) {
if (rhs_parts[rhs_l - 1].is_action()) {
rightlen = rhs_l - 1;
} else {
rightlen = rhs_l;
}
}
/* get the generated declaration code for the necessary labels. */
declare_str = declare_labels(
rhs_parts, rightlen, action_str);
if (action_str == null)
action_str = declare_str;
else
action_str = declare_str + action_str;
/* count use of lhs */
lhs_sym.note_use();
/* create the part for left-hand-side */
_lhs = new symbol_part(lhs_sym);
/* merge adjacent actions (if any) */
_rhs_length = merge_adjacent_actions(rhs_parts, _rhs_length);
/* strip off any trailing action */
tail_action = strip_trailing_action(rhs_parts, _rhs_length);
if (tail_action != null) _rhs_length--;
/* Why does this run through the right hand side happen
over and over? here a quick combination of two
prior runs plus one I wanted of my own
frankf 6/25/96 */
/* allocate and copy over the right-hand-side */
/* count use of each rhs symbol */
_rhs = new production_part[_rhs_length];
for (i=0; i<_rhs_length; i++) {
_rhs[i] = rhs_parts[i];
if (!_rhs[i].is_action()) {
((symbol_part)_rhs[i]).the_symbol().note_use();
if (((symbol_part)_rhs[i]).the_symbol() instanceof terminal) {
_rhs_prec =
((terminal)((symbol_part)_rhs[i]).the_symbol()).precedence_num();
_rhs_assoc =
((terminal)((symbol_part)_rhs[i]).the_symbol()).precedence_side();
}
}
}
/*now action string is really declaration string, so put it in front!
6/14/96 frankf */
if (action_str == null) action_str = "";
if (tail_action != null && tail_action.code_string() != null)
action_str = action_str + "\t\t" + tail_action.code_string();
/* stash the action */
_action = new action_part(action_str);
/* rewrite production to remove any embedded actions */
remove_embedded_actions();
/* assign an index */
_index = next_index++;
/* put us in the global collection of productions */
_all.put(new Integer(_index),this);
/* put us in the production list of the lhs non terminal */
lhs_sym.add_production(this);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Constructor with no action string. */
public production(
non_terminal lhs_sym,
production_part rhs_parts[],
int rhs_l)
throws internal_error
{
this(lhs_sym,rhs_parts,rhs_l,null);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/* Constructor with precedence and associativity of production
contextually define */
public production(
non_terminal lhs_sym,
production_part rhs_parts[],
int rhs_l,
String action_str,
int prec_num,
int prec_side)
throws internal_error
{
this(lhs_sym,rhs_parts,rhs_l,action_str);
/* set the precedence */
set_precedence_num(prec_num);
set_precedence_side(prec_side);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/* Constructor w/ no action string and contextual precedence
defined */
public production(
non_terminal lhs_sym,
production_part rhs_parts[],
int rhs_l,
int prec_num,
int prec_side)
throws internal_error
{
this(lhs_sym,rhs_parts,rhs_l,null);
/* set the precedence */
set_precedence_num(prec_num);
set_precedence_side(prec_side);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/*-----------------------------------------------------------*/
/*--- (Access to) Static (Class) Variables ------------------*/
/*-----------------------------------------------------------*/
/** Table of all productions. Elements are stored using their index as
* the key.
*/
protected static Hashtable _all = new Hashtable();
/** Access to all productions. */
public static Enumeration all() {return _all.elements();}
/** Lookup a production by index. */
public static production find(int indx) {
return (production) _all.get(new Integer(indx));
}
//Hm Added clear to clear all static fields
public static void clear() {
_all.clear();
next_index=0;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Total number of productions. */
public static int number() {return _all.size();}
/** Static counter for assigning unique index numbers. */
protected static int next_index;
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The left hand side non-terminal. */
protected symbol_part _lhs;
/** The left hand side non-terminal. */
public symbol_part lhs() {return _lhs;}
/** The precedence of the rule */
protected int _rhs_prec = -1;
protected int _rhs_assoc = -1;
/** Access to the precedence of the rule */
public int precedence_num() { return _rhs_prec; }
public int precedence_side() { return _rhs_assoc; }
/** Setting the precedence of a rule */
public void set_precedence_num(int prec_num) {
_rhs_prec = prec_num;
}
public void set_precedence_side(int prec_side) {
_rhs_assoc = prec_side;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** A collection of parts for the right hand side. */
protected production_part _rhs[];
/** Access to the collection of parts for the right hand side. */
public production_part rhs(int indx) throws internal_error
{
if (indx >= 0 && indx < _rhs_length)
return _rhs[indx];
else
throw new internal_error(
"Index out of range for right hand side of production");
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** How much of the right hand side array we are presently using. */
protected int _rhs_length;
/** How much of the right hand side array we are presently using. */
public int rhs_length() {return _rhs_length;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** An action_part containing code for the action to be performed when we
* reduce with this production.
*/
protected action_part _action;
/** An action_part containing code for the action to be performed when we
* reduce with this production.
*/
public action_part action() {return _action;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Index number of the production. */
protected int _index;
/** Index number of the production. */
public int index() {return _index;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Count of number of reductions using this production. */
protected int _num_reductions = 0;
/** Count of number of reductions using this production. */
public int num_reductions() {return _num_reductions;}
/** Increment the count of reductions with this non-terminal */
public void note_reduction_use() {_num_reductions++;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Is the nullability of the production known or unknown? */
protected boolean _nullable_known = false;
/** Is the nullability of the production known or unknown? */
public boolean nullable_known() {return _nullable_known;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Nullability of the production (can it derive the empty string). */
protected boolean _nullable = false;
/** Nullability of the production (can it derive the empty string). */
public boolean nullable() {return _nullable;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** First set of the production. This is the set of terminals that
* could appear at the front of some string derived from this production.
*/
protected terminal_set _first_set = new terminal_set();
/** First set of the production. This is the set of terminals that
* could appear at the front of some string derived from this production.
*/
public terminal_set first_set() {return _first_set;}
/*-----------------------------------------------------------*/
/*--- Static Methods ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Determine if a given character can be a label id starter.
* @param c the character in question.
*/
protected static boolean is_id_start(char c)
{
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_');
//later need to handle non-8-bit chars here
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Determine if a character can be in a label id.
* @param c the character in question.
*/
protected static boolean is_id_char(char c)
{
return is_id_start(c) || (c >= '0' && c <= '9');
}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Return label declaration code
* @param labelname the label name
* @param stack_type the stack type of label?
* @author frankf
*/
protected String make_declaration(
String labelname,
String stack_type,
int offset)
{
String ret;
/* Put in the left/right value labels */
if (emit.lr_values())
ret = "\t\tint " + labelname + "left = ((java_cup.runtime.Symbol)" +
emit.pre("stack") +
// TUM 20050917
((offset==0)?".peek()":(".elementAt(" + emit.pre("top") + "-" + offset + ")"))+
").left;\n" +
"\t\tint " + labelname + "right = ((java_cup.runtime.Symbol)" +
emit.pre("stack") +
// TUM 20050917
((offset==0)?".peek()":(".elementAt(" + emit.pre("top") + "-" + offset + ")"))+
").right;\n";
else ret = "";
/* otherwise, just declare label. */
return ret + "\t\t" + stack_type + " " + labelname + " = (" + stack_type +
")((" + "java_cup.runtime.Symbol) " + emit.pre("stack") +
// TUM 20050917
((offset==0)?".peek()":(".elementAt(" + emit.pre("top") + "-" + offset + ")"))+
").value;\n";
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Declare label names as valid variables within the action string
* @param rhs array of RHS parts.
* @param rhs_len how much of rhs to consider valid.
* @param final_action the final action string of the production.
* @param lhs_type the object type associated with the LHS symbol.
*/
protected String declare_labels(
production_part rhs[],
int rhs_len,
String final_action)
{
String declaration = "";
symbol_part part;
action_part act_part;
int pos;
/* walk down the parts and extract the labels */
for (pos = 0; pos < rhs_len; pos++)
{
if (!rhs[pos].is_action())
{
part = (symbol_part)rhs[pos];
/* if it has a label, make declaration! */
if (part.label() != null)
{
declaration = declaration +
make_declaration(part.label(), part.the_symbol().stack_type(),
rhs_len-pos-1);
}
}
}
return declaration;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Helper routine to merge adjacent actions in a set of RHS parts
* @param rhs_parts array of RHS parts.
* @param len amount of that array that is valid.
* @return remaining valid length.
*/
protected int merge_adjacent_actions(production_part rhs_parts[], int len)
{
int from_loc, to_loc, merge_cnt;
/* bail out early if we have no work to do */
if (rhs_parts == null || len == 0) return 0;
merge_cnt = 0;
to_loc = -1;
for (from_loc=0; from_loc
* A ::= B NT$1 C NT$2 D
* NT$1 ::= {action1}
* NT$2 ::= {action2}
*
* where NT$1 and NT$2 are new system created non terminals.
*/
/* the declarations added to the parent production are also passed along,
as they should be perfectly valid in this code string, since it
was originally a code string in the parent, not on its own.
frank 6/20/96 */
protected void remove_embedded_actions(
) throws internal_error
{
non_terminal new_nt;
production new_prod;
String declare_str;
int lastLocation = -1;
/* walk over the production and process each action */
for (int act_loc = 0; act_loc < rhs_length(); act_loc++)
if (rhs(act_loc).is_action())
{
declare_str = declare_labels(
_rhs, act_loc, "");
/* create a new non terminal for the action production */
new_nt = non_terminal.create_new(null, lhs().the_symbol().stack_type()); // TUM 20060608 embedded actions patch
new_nt.is_embedded_action = true; /* 24-Mar-1998, CSA */
/* create a new production with just the action */
new_prod = new action_production(this, new_nt, null, 0,
declare_str + ((action_part)rhs(act_loc)).code_string(), (lastLocation==-1)?-1:(act_loc-lastLocation));
/* replace the action with the generated non terminal */
_rhs[act_loc] = new symbol_part(new_nt);
lastLocation = act_loc;
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Check to see if the production (now) appears to be nullable.
* A production is nullable if its RHS could derive the empty string.
* This results when the RHS is empty or contains only non terminals
* which themselves are nullable.
*/
public boolean check_nullable() throws internal_error
{
production_part part;
symbol sym;
int pos;
/* if we already know bail out early */
if (nullable_known()) return nullable();
/* if we have a zero size RHS we are directly nullable */
if (rhs_length() == 0)
{
/* stash and return the result */
return set_nullable(true);
}
/* otherwise we need to test all of our parts */
for (pos=0; pos-
*
- -package name *
- specify package generated classes go in [default none] *
- -parser name *
- specify parser class name [default "parser"] *
- -symbols name *
- specify name for symbol constant class [default "sym"] *
- -interface *
- emit symbol constant interface, rather than class *
- -nonterms *
- put non terminals in symbol constant class *
- -expect # *
- number of conflicts expected/allowed [default 0] *
- -compact_red *
- compact tables by defaulting to most frequent reduce *
- -nowarn *
- don't warn about useless productions, etc. *
- -nosummary *
- don't print the usual summary of parse states, etc. *
- -progress *
- print messages to indicate progress of the system *
- -time *
- print time usage summary *
- -dump_grammar *
- produce a dump of the symbols and grammar *
- -dump_states *
- produce a dump of parse state machine *
- -dump_tables *
- produce a dump of the parse tables *
- -dump *
- produce a dump of all of the above *
- -debug *
- turn on debugging messages within JavaCup *
- -nopositions *
- don't generate the positions code *
- -noscanner *
- don't refer to java_cup.runtime.Scanner in the parser * (for compatibility with old runtimes) *
- -version *
- print version information for JavaCUP and halt. *
-
*
- Computing nullability of non-terminals. *
- Computing first sets of non-terminals and productions. *
- Building the viable prefix recognizer machine. *
- Filling in the (internal) parse tables. *
- Checking for unreduced productions. *
-
*
- symbol constant class *
- this contains constant declarations for each terminal (and * optionally each non-terminal). *
- action class *
- this non-public class contains code to invoke all the user actions * that were embedded in the parser specification. *
- parser class *
- the specialized parser class consisting primarily of some user * supplied general and initialization code, and the parse tables. *
* * Three parse tables are created as part of the parser class: *
-
*
- production table *
- lists the LHS non terminal number, and the length of the RHS of * each production. *
- action table *
- for each state of the parse machine, gives the action to be taken
* (shift, reduce, or error) under each lookahead symbol.
* - reduce-goto table *
- when a reduce on a given production is taken, the parse stack is * popped back a number of elements corresponding to the RHS of the * production. This reveals a prior state, which we transition out * of under the LHS non terminal symbol for the production (as if we * had seen the LHS symbol rather than all the symbols matching the * RHS). This table is indexed by non terminal numbers and indicates * how to make these transitions. *
* * In addition to the method interface, this class maintains a series of * public global variables and flags indicating how misc. parts of the code * and other output is to be produced, and counting things such as number of * conflicts detected (see the source code and public variables below for * more details).
* * This class is "static" (contains only static data and methods).
*
* @see java_cup.main
* @version last update: 11/25/95
* @author Scott Hudson
*/
/* Major externally callable routines here include:
symbols - emit the symbol constant class
parser - emit the parser class
In addition the following major internal routines are provided:
emit_package - emit a package declaration
emit_action_code - emit the class containing the user's actions
emit_production_table - emit declaration and init for the production table
do_action_table - emit declaration and init for the action table
do_reduce_table - emit declaration and init for the reduce-goto table
Finally, this class uses a number of public instance variables to communicate
optional parameters and flags used to control how code is generated,
as well as to report counts of various things (such as number of conflicts
detected). These include:
prefix - a prefix string used to prefix names that would
otherwise "pollute" someone else's name space.
package_name - name of the package emitted code is placed in
(or null for an unnamed package.
symbol_const_class_name - name of the class containing symbol constants.
parser_class_name - name of the class for the resulting parser.
action_code - user supplied declarations and other code to be
placed in action class.
parser_code - user supplied declarations and other code to be
placed in parser class.
init_code - user supplied code to be executed as the parser
is being initialized.
scan_code - user supplied code to get the next Symbol.
start_production - the start production for the grammar.
import_list - list of imports for use with action class.
num_conflicts - number of conflicts detected.
nowarn - true if we are not to issue warning messages.
not_reduced - count of number of productions that never reduce.
unused_term - count of unused terminal symbols.
unused_non_term - count of unused non terminal symbols.
*_time - a series of symbols indicating how long various
sub-parts of code generation took (used to produce
optional time reports in main).
*/
public class emit {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Only constructor is private so no instances can be created. */
private emit() { }
/*-----------------------------------------------------------*/
/*--- Static (Class) Variables ------------------------------*/
/*-----------------------------------------------------------*/
/** The prefix placed on names that pollute someone else's name space. */
public static String prefix = "CUP$";
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Package that the resulting code goes into (null is used for unnamed). */
public static String package_name = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Name of the generated class for symbol constants. */
public static String symbol_const_class_name = "sym";
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Name of the generated parser class. */
public static String parser_class_name = "parser";
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** TUM changes; proposed by Henning Niss 20050628: Type arguments for class declaration */
public static String class_type_argument = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** User declarations for direct inclusion in user action class. */
public static String action_code = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** User declarations for direct inclusion in parser class. */
public static String parser_code = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** User code for user_init() which is called during parser initialization. */
public static String init_code = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** User code for scan() which is called to get the next Symbol. */
public static String scan_code = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** The start production of the grammar. */
public static production start_production = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** List of imports (Strings containing class names) to go with actions. */
public static Stack import_list = new Stack();
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Number of conflict found while building tables. */
public static int num_conflicts = 0;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Do we skip warnings? */
public static boolean nowarn = false;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Count of the number on non-reduced productions found. */
public static int not_reduced = 0;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Count of unused terminals. */
public static int unused_term = 0;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Count of unused non terminals. */
public static int unused_non_term = 0;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/* Timing values used to produce timing report in main.*/
/** Time to produce symbol constant class. */
public static long symbols_time = 0;
/** Time to produce parser class. */
public static long parser_time = 0;
/** Time to produce action code class. */
public static long action_code_time = 0;
/** Time to produce the production table. */
public static long production_table_time = 0;
/** Time to produce the action table. */
public static long action_table_time = 0;
/** Time to produce the reduce-goto table. */
public static long goto_table_time = 0;
/* frankf 6/18/96 */
protected static boolean _lr_values;
/** whether or not to emit code for left and right values */
public static boolean lr_values() {return _lr_values;}
protected static void set_lr_values(boolean b) { _lr_values = b;}
//Hm Added clear to clear all static fields
public static void clear () {
_lr_values = true;
action_code = null;
import_list = new Stack();
init_code = null;
not_reduced = 0;
num_conflicts = 0;
package_name = null;
parser_class_name = "parser";
parser_code = null;
scan_code = null;
start_production = null;
symbol_const_class_name = "sym";
unused_non_term = 0;
unused_term = 0;
}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Build a string with the standard prefix.
* @param str string to prefix.
*/
protected static String pre(String str) {
return prefix + parser_class_name + "$" + str;
}
/**
* TUM changes; proposed by Henning Niss 20050628
* Build a string with the specified type arguments,
* if present, otherwise an empty string.
*/
protected static String typeArgument() {
return class_type_argument == null ? "" : "<" + class_type_argument + ">";
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Emit a package spec if the user wants one.
* @param out stream to produce output on.
*/
protected static void emit_package(PrintWriter out)
{
/* generate a package spec if we have a name for one */
if (package_name != null) {
out.println("package " + package_name + ";"); out.println();
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Emit code for the symbol constant class, optionally including non terms,
* if they have been requested.
* @param out stream to produce output on.
* @param emit_non_terms do we emit constants for non terminals?
* @param sym_interface should we emit an interface, rather than a class?
*/
public static void symbols(PrintWriter out,
boolean emit_non_terms, boolean sym_interface)
{
terminal term;
non_terminal nt;
String class_or_interface = (sym_interface)?"interface":"class";
long start_time = System.currentTimeMillis();
/* top of file */
out.println();
out.println("//----------------------------------------------------");
out.println("// The following code was generated by " +
version.title_str);
out.println("// " + new Date());
out.println("//----------------------------------------------------");
out.println();
emit_package(out);
/* class header */
out.println("/** CUP generated " + class_or_interface +
" containing symbol constants. */");
out.println("public " + class_or_interface + " " +
symbol_const_class_name + " {");
out.println(" /* terminals */");
/* walk over the terminals */ /* later might sort these */
for (Enumeration e = terminal.all(); e.hasMoreElements(); )
{
term = (terminal)e.nextElement();
/* output a constant decl for the terminal */
out.println(" public static final int " + term.name() + " = " +
term.index() + ";");
}
/* do the non terminals if they want them (parser doesn't need them) */
if (emit_non_terms)
{
out.println();
out.println(" /* non terminals */");
/* walk over the non terminals */ /* later might sort these */
for (Enumeration e = non_terminal.all(); e.hasMoreElements(); )
{
nt = (non_terminal)e.nextElement();
// ****
// TUM Comment: here we could add a typesafe enumeration
// ****
/* output a constant decl for the terminal */
out.println(" static final int " + nt.name() + " = " +
nt.index() + ";");
}
}
/* end of class */
out.println("}");
out.println();
symbols_time = System.currentTimeMillis() - start_time;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Emit code for the non-public class holding the actual action code.
* @param out stream to produce output on.
* @param start_prod the start production of the grammar.
*/
protected static void emit_action_code(PrintWriter out, production start_prod)
throws internal_error
{
production prod;
long start_time = System.currentTimeMillis();
/* class header */
out.println();
out.println(
"/** Cup generated class to encapsulate user supplied action code.*/"
);
/* TUM changes; proposed by Henning Niss 20050628: added type arguement */
out.println("class " + pre("actions") + typeArgument() + " {");
/* user supplied code */
if (action_code != null)
{
out.println();
out.println(action_code);
}
/* field for parser object */
/* TUM changes; proposed by Henning Niss 20050628: added typeArgument */
out.println(" private final "+parser_class_name + typeArgument() + " parser;");
/* constructor */
out.println();
out.println(" /** Constructor */");
/* TUM changes; proposed by Henning Niss 20050628: added typeArgument */
out.println(" " + pre("actions") + "("+parser_class_name+typeArgument()+" parser) {");
out.println(" this.parser = parser;");
out.println(" }");
/* action method head */
out.println();
out.println(" /** Method with the actual generated action code. */");
out.println(" public final java_cup.runtime.Symbol " +
pre("do_action") + "(");
out.println(" int " + pre("act_num,"));
out.println(" java_cup.runtime.lr_parser " + pre("parser,"));
out.println(" java.util.Stack " + pre("stack,"));
out.println(" int " + pre("top)"));
out.println(" throws java.lang.Exception");
out.println(" {");
/* declaration of result symbol */
/* New declaration!! now return Symbol
6/13/96 frankf */
out.println(" /* Symbol object for return from actions */");
out.println(" java_cup.runtime.Symbol " + pre("result") + ";");
out.println();
/* switch top */
out.println(" /* select the action based on the action number */");
out.println(" switch (" + pre("act_num") + ")");
out.println(" {");
/* emit action code for each production as a separate case */
for (Enumeration p = production.all(); p.hasMoreElements(); )
{
prod = (production)p.nextElement();
/* case label */
out.println(" /*. . . . . . . . . . . . . . . . . . . .*/");
out.println(" case " + prod.index() + ": // " +
prod.to_simple_string());
/* give them their own block to work in */
out.println(" {");
/**
* TUM 20060608 intermediate result patch
*/
String result = "null";
if (prod instanceof action_production) {
int lastResult = ((action_production)prod).getIndexOfIntermediateResult();
if (lastResult!=-1) {
result = "(" + prod.lhs().the_symbol().stack_type() + ") " +
"((java_cup.runtime.Symbol) " + emit.pre("stack") +
// TUM 20050917
((lastResult==1)?".peek()":(".elementAt(" + emit.pre("top") + "-" + (lastResult-1) + ")"))+
").value";
}
}
/* create the result symbol */
/*make the variable RESULT which will point to the new Symbol (see below)
and be changed by action code
6/13/96 frankf */
out.println(" " + prod.lhs().the_symbol().stack_type() +
" RESULT ="+result+";");
/* Add code to propagate RESULT assignments that occur in
* action code embedded in a production (ie, non-rightmost
* action code). 24-Mar-1998 CSA
*/
for (int i=prod.rhs_length()-1; i>=0; i--) {
// only interested in non-terminal symbols.
if (!(prod.rhs(i) instanceof symbol_part)) continue;
symbol s = ((symbol_part)prod.rhs(i)).the_symbol();
if (!(s instanceof non_terminal)) continue;
// skip this non-terminal unless it corresponds to
// an embedded action production.
if (((non_terminal)s).is_embedded_action == false) continue;
// OK, it fits. Make a conditional assignment to RESULT.
int index = prod.rhs_length() - i - 1; // last rhs is on top.
// set comment to inform about where the intermediate result came from
out.println(" " + "// propagate RESULT from " +s.name());
// // look out, whether the intermediate result is null or not
// out.println(" " + "if ( " +
// "((java_cup.runtime.Symbol) " + emit.pre("stack") +
// // TUM 20050917
// ((index==0)?".peek()":(".elementAt(" + emit.pre("top") + "-" + index + ")"))+
// ").value != null )");
// TUM 20060608: even when its null: who cares?
// store the intermediate result into RESULT
out.println(" " + "RESULT = " +
"(" + prod.lhs().the_symbol().stack_type() + ") " +
"((java_cup.runtime.Symbol) " + emit.pre("stack") +
// TUM 20050917
((index==0)?".peek()":(".elementAt(" + emit.pre("top") + "-" + index + ")"))+
").value;");
break;
}
/* if there is an action string, emit it */
if (prod.action() != null && prod.action().code_string() != null &&
!prod.action().equals(""))
out.println(prod.action().code_string());
/* here we have the left and right values being propagated.
must make this a command line option.
frankf 6/18/96 */
/* Create the code that assigns the left and right values of
the new Symbol that the production is reducing to */
if (emit.lr_values()) {
int loffset;
String leftstring, rightstring;
// TUM 20050917
//int roffset = 0;
rightstring = "((java_cup.runtime.Symbol)" + emit.pre("stack") +
// TUM 20050917
//".elementAt(" + emit.pre("top") + "-" + roffset + "))"+
".peek()"+
// TUM 20060327 removed .right
")";
if (prod.rhs_length() == 0)
leftstring = rightstring;
else {
loffset = prod.rhs_length() - 1;
leftstring = "((java_cup.runtime.Symbol)" + emit.pre("stack") +
// TUM 20050917
((loffset==0)?(".peek()"):(".elementAt(" + emit.pre("top") + "-" + loffset + ")")) +
// TUM 20060327 removed .left
")";
}
// out.println(" " + pre("result") + " = new java_cup.runtime.Symbol(" +
out.println(" " + pre("result") + " = parser.getSymbolFactory().newSymbol(" +
"\""+ prod.lhs().the_symbol().name() +"\","+
prod.lhs().the_symbol().index() +
", " + leftstring + ", " + rightstring + ", RESULT);");
} else {
// out.println(" " + pre("result") + " = new java_cup.runtime.Symbol(" +
out.println(" " + pre("result") + " = parser.getSymbolFactory().newSymbol(" +
"\""+ prod.lhs().the_symbol().name() + "\","+
prod.lhs().the_symbol().index() +
", RESULT);");
}
/* end of their block */
out.println(" }");
/* if this was the start production, do action for accept */
if (prod == start_prod)
{
out.println(" /* ACCEPT */");
out.println(" " + pre("parser") + ".done_parsing();");
}
/* code to return lhs symbol */
out.println(" return " + pre("result") + ";");
out.println();
}
/* end of switch */
out.println(" /* . . . . . .*/");
out.println(" default:");
out.println(" throw new Exception(");
out.println(" \"Invalid action number found in " +
"internal parse table\");");
out.println();
out.println(" }");
/* end of method */
out.println(" }");
/* end of class */
out.println("}");
out.println();
action_code_time = System.currentTimeMillis() - start_time;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Emit the production table.
* @param out stream to produce output on.
*/
protected static void emit_production_table(PrintWriter out)
{
production all_prods[];
production prod;
long start_time = System.currentTimeMillis();
/* collect up the productions in order */
all_prods = new production[production.number()];
for (Enumeration p = production.all(); p.hasMoreElements(); )
{
prod = (production)p.nextElement();
all_prods[prod.index()] = prod;
}
// make short[][]
short[][] prod_table = new short[production.number()][2];
for (int i = 0; i
*
* This class provides fairly conventional set oriented operations (union,
* sub/super-set tests, etc.), as well as an LALR "closure" operation (see
* compute_closure()).
*
* @see java_cup.lalr_item
* @see java_cup.lalr_state
* @version last updated: 3/6/96
* @author Scott Hudson
*/
public class lalr_item_set {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Constructor for an empty set. */
public lalr_item_set() { }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Constructor for cloning from another set.
* @param other indicates set we should copy from.
*/
public lalr_item_set(lalr_item_set other)
throws internal_error
{
not_null(other);
_all = (Hashtable)other._all.clone();
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** A hash table to implement the set. We store the items using themselves
* as keys.
*/
protected Hashtable _all = new Hashtable(11);
/** Access to all elements of the set. */
public Enumeration all() {return _all.elements();}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Cached hashcode for this set. */
protected Integer hashcode_cache = null;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Size of the set */
public int size() {return _all.size();}
/*-----------------------------------------------------------*/
/*--- Set Operation Methods ---------------------------------*/
/*-----------------------------------------------------------*/
/** Does the set contain a particular item?
* @param itm the item in question.
*/
public boolean contains(lalr_item itm) {return _all.containsKey(itm);}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Return the item in the set matching a particular item (or null if not
* found)
* @param itm the item we are looking for.
*/
public lalr_item find(lalr_item itm) {return (lalr_item)_all.get(itm);}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Is this set an (improper) subset of another?
* @param other the other set in question.
*/
public boolean is_subset_of(lalr_item_set other) throws internal_error
{
not_null(other);
/* walk down our set and make sure every element is in the other */
for (Enumeration e = all(); e.hasMoreElements(); )
if (!other.contains((lalr_item)e.nextElement()))
return false;
/* they were all there */
return true;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Is this set an (improper) superset of another?
* @param other the other set in question.
*/
public boolean is_superset_of(lalr_item_set other) throws internal_error
{
not_null(other);
return other.is_subset_of(this);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Add a singleton item, merging lookahead sets if the item is already
* part of the set. returns the element of the set that was added or
* merged into.
* @param itm the item being added.
*/
public lalr_item add(lalr_item itm) throws internal_error
{
lalr_item other;
not_null(itm);
/* see if an item with a matching core is already there */
other = (lalr_item)_all.get(itm);
/* if so, merge this lookahead into the original and leave it */
if (other != null)
{
other.lookahead().add(itm.lookahead());
return other;
}
/* otherwise we just go in the set */
else
{
/* invalidate cached hashcode */
hashcode_cache = null;
_all.put(itm,itm);
return itm;
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Remove a single item if it is in the set.
* @param itm the item to remove.
*/
public void remove(lalr_item itm) throws internal_error
{
not_null(itm);
/* invalidate cached hashcode */
hashcode_cache = null;
/* remove it from hash table implementing set */
_all.remove(itm);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Add a complete set, merging lookaheads where items are already in
* the set
* @param other the set to be added.
*/
public void add(lalr_item_set other) throws internal_error
{
not_null(other);
/* walk down the other set and do the adds individually */
for (Enumeration e = other.all(); e.hasMoreElements(); )
add((lalr_item)e.nextElement());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Remove (set subtract) a complete set.
* @param other the set to remove.
*/
public void remove(lalr_item_set other) throws internal_error
{
not_null(other);
/* walk down the other set and do the removes individually */
for (Enumeration e = other.all(); e.hasMoreElements(); )
remove((lalr_item)e.nextElement());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Remove and return one item from the set (done in hash order). */
public lalr_item get_one() throws internal_error
{
Enumeration the_set;
lalr_item result;
the_set = all();
if (the_set.hasMoreElements())
{
result = (lalr_item)the_set.nextElement();
remove(result);
return result;
}
else
return null;
}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Helper function for null test. Throws an interal_error exception if its
* parameter is null.
* @param obj the object we are testing.
*/
protected void not_null(Object obj) throws internal_error
{
if (obj == null)
throw new internal_error("Null object used in set operation");
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Compute the closure of the set using the LALR closure rules. Basically
* for every item of the form:
*
* At runtime, the parser uses a viable prefix recognition machine made up
* of these states to parse. The parser has two operations, shift and reduce.
* In a shift, it consumes one Symbol and makes a transition to a new state.
* This corresponds to "moving the dot past" a terminal in one or more items
* in the state (these new shifted items will then be found in the state at
* the end of the transition). For a reduce operation, the parser is
* signifying that it is recognizing the RHS of some production. To do this
* it first "backs up" by popping a stack of previously saved states. It
* pops off the same number of states as are found in the RHS of the
* production. This leaves the machine in the same state is was in when the
* parser first attempted to find the RHS. From this state it makes a
* transition based on the non-terminal on the LHS of the production. This
* corresponds to placing the parse in a configuration equivalent to having
* replaced all the symbols from the the input corresponding to the RHS with
* the symbol on the LHS.
*
* @see java_cup.lalr_item
* @see java_cup.lalr_item_set
* @see java_cup.lalr_transition
* @version last updated: 7/3/96
* @author Frank Flannery
*
*/
public class lalr_state {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Constructor for building a state from a set of items.
* @param itms the set of items that makes up this state.
*/
public lalr_state(lalr_item_set itms) throws internal_error
{
/* don't allow null or duplicate item sets */
if (itms == null)
throw new internal_error(
"Attempt to construct an LALR state from a null item set");
if (find_state(itms) != null)
throw new internal_error(
"Attempt to construct a duplicate LALR state");
/* assign a unique index */
_index = next_index++;
/* store the items */
_items = itms;
/* add to the global collection, keyed with its item set */
_all.put(_items,this);
}
/*-----------------------------------------------------------*/
/*--- (Access to) Static (Class) Variables ------------------*/
/*-----------------------------------------------------------*/
/** Collection of all states. */
protected static Hashtable _all = new Hashtable();
/** Collection of all states. */
public static Enumeration all() {return _all.elements();}
//Hm Added clear to clear all static fields
public static void clear() {
_all.clear();
_all_kernels.clear();
next_index=0;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Indicate total number of states there are. */
public static int number() {return _all.size();}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Hash table to find states by their kernels (i.e, the original,
* unclosed, set of items -- which uniquely define the state). This table
* stores state objects using (a copy of) their kernel item sets as keys.
*/
protected static Hashtable _all_kernels = new Hashtable();
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Find and return state with a given a kernel item set (or null if not
* found). The kernel item set is the subset of items that were used to
* originally create the state. These items are formed by "shifting the
* dot" within items of other states that have a transition to this one.
* The remaining elements of this state's item set are added during closure.
* @param itms the kernel set of the state we are looking for.
*/
public static lalr_state find_state(lalr_item_set itms)
{
if (itms == null)
return null;
else
return (lalr_state)_all.get(itms);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Static counter for assigning unique state indexes. */
protected static int next_index = 0;
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The item set for this state. */
protected lalr_item_set _items;
/** The item set for this state. */
public lalr_item_set items() {return _items;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** List of transitions out of this state. */
protected lalr_transition _transitions = null;
/** List of transitions out of this state. */
public lalr_transition transitions() {return _transitions;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Index of this state in the parse tables */
protected int _index;
/** Index of this state in the parse tables */
public int index() {return _index;}
/*-----------------------------------------------------------*/
/*--- Static Methods ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Helper routine for debugging -- produces a dump of the given state
* onto System.out.
*/
protected static void dump_state(lalr_state st) throws internal_error
{
lalr_item_set itms;
lalr_item itm;
production_part part;
if (st == null)
{
System.out.println("NULL lalr_state");
return;
}
System.out.println("lalr_state [" + st.index() + "] {");
itms = st.items();
for (Enumeration e = itms.all(); e.hasMoreElements(); )
{
itm = (lalr_item)e.nextElement();
System.out.print(" [");
System.out.print(itm.the_production().lhs().the_symbol().name());
System.out.print(" ::= ");
for (int i = 0; i
*
* The process of building the viable prefix recognizer terminates when no
* new states can be added. However, in order to build a smaller number of
* states (i.e., corresponding to LALR rather than canonical LR) the state
* building process does not maintain full loookaheads in all items.
* Consequently, after the machine is built, we go back and propagate
* lookaheads through the constructed machine using a call to
* propagate_all_lookaheads(). This makes use of propagation links
* constructed during the closure and transition process.
*
* @param start_prod the start production of the grammar
* @see java_cup.lalr_item_set#compute_closure
* @see java_cup.lalr_state#propagate_all_lookaheads
*/
public static lalr_state build_machine(production start_prod)
throws internal_error
{
lalr_state start_state;
lalr_item_set start_items;
lalr_item_set new_items;
lalr_item_set linked_items;
lalr_item_set kernel;
Stack work_stack = new Stack();
lalr_state st, new_st;
symbol_set outgoing;
lalr_item itm, new_itm, existing, fix_itm;
symbol sym, sym2;
Enumeration i, s, fix;
/* sanity check */
if (start_prod == null)
throw new internal_error(
"Attempt to build viable prefix recognizer using a null production");
/* build item with dot at front of start production and EOF lookahead */
start_items = new lalr_item_set();
itm = new lalr_item(start_prod);
itm.lookahead().add(terminal.EOF);
start_items.add(itm);
/* create copy the item set to form the kernel */
kernel = new lalr_item_set(start_items);
/* create the closure from that item set */
start_items.compute_closure();
/* build a state out of that item set and put it in our work set */
start_state = new lalr_state(start_items);
work_stack.push(start_state);
/* enter the state using the kernel as the key */
_all_kernels.put(kernel, start_state);
/* continue looking at new states until we have no more work to do */
while (!work_stack.empty())
{
/* remove a state from the work set */
st = (lalr_state)work_stack.pop();
/* gather up all the symbols that appear before dots */
outgoing = new symbol_set();
for (i = st.items().all(); i.hasMoreElements(); )
{
itm = (lalr_item)i.nextElement();
/* add the symbol before the dot (if any) to our collection */
sym = itm.symbol_after_dot();
if (sym != null) outgoing.add(sym);
}
/* now create a transition out for each individual symbol */
for (s = outgoing.all(); s.hasMoreElements(); )
{
sym = (symbol)s.nextElement();
/* will be keeping the set of items with propagate links */
linked_items = new lalr_item_set();
/* gather up shifted versions of all the items that have this
symbol before the dot */
new_items = new lalr_item_set();
for (i = st.items().all(); i.hasMoreElements();)
{
itm = (lalr_item)i.nextElement();
/* if this is the symbol we are working on now, add to set */
sym2 = itm.symbol_after_dot();
if (sym.equals(sym2))
{
/* add to the kernel of the new state */
new_items.add(itm.shift());
/* remember that itm has propagate link to it */
linked_items.add(itm);
}
}
/* use new items as state kernel */
kernel = new lalr_item_set(new_items);
/* have we seen this one already? */
new_st = (lalr_state)_all_kernels.get(kernel);
/* if we haven't, build a new state out of the item set */
if (new_st == null)
{
/* compute closure of the kernel for the full item set */
new_items.compute_closure();
/* build the new state */
new_st = new lalr_state(new_items);
/* add the new state to our work set */
work_stack.push(new_st);
/* put it in our kernel table */
_all_kernels.put(kernel, new_st);
}
/* otherwise relink propagation to items in existing state */
else
{
/* walk through the items that have links to the new state */
for (fix = linked_items.all(); fix.hasMoreElements(); )
{
fix_itm = (lalr_item)fix.nextElement();
/* look at each propagate link out of that item */
for (int l =0; l < fix_itm.propagate_items().size(); l++)
{
/* pull out item linked to in the new state */
new_itm =
(lalr_item)fix_itm.propagate_items().elementAt(l);
/* find corresponding item in the existing state */
existing = new_st.items().find(new_itm);
/* fix up the item so it points to the existing set */
if (existing != null)
fix_itm.propagate_items().setElementAt(existing ,l);
}
}
}
/* add a transition from current state to that state */
st.add_transition(sym, new_st);
}
}
/* all done building states */
/* propagate complete lookahead sets throughout the states */
propagate_all_lookaheads();
return start_state;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Propagate lookahead sets out of this state. This recursively
* propagates to all items that have propagation links from some item
* in this state.
*/
protected void propagate_lookaheads() throws internal_error
{
/* recursively propagate out from each item in the state */
for (Enumeration itm = items().all(); itm.hasMoreElements(); )
((lalr_item)itm.nextElement()).propagate_lookaheads(null);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Fill in the parse table entries for this state. There are two
* parse tables that encode the viable prefix recognition machine, an
* action table and a reduce-goto table. The rows in each table
* correspond to states of the machine. The columns of the action table
* are indexed by terminal symbols and correspond to either transitions
* out of the state (shift entries) or reductions from the state to some
* previous state saved on the stack (reduce entries). All entries in the
* action table that are not shifts or reduces, represent errors. The
* reduce-goto table is indexed by non terminals and represents transitions
* out of a state on that non-terminal.
* Conflicts occur if more than one action needs to go in one entry of the
* action table (this cannot happen with the reduce-goto table). Conflicts
* are resolved by always shifting for shift/reduce conflicts and choosing
* the lowest numbered production (hence the one that appeared first in
* the specification) in reduce/reduce conflicts. All conflicts are
* reported and if more conflicts are detected than were declared by the
* user, code generation is aborted.
*
* @param act_table the action table to put entries in.
* @param reduce_table the reduce-goto table to put entries in.
*/
public void build_table_entries(
parse_action_table act_table,
parse_reduce_table reduce_table)
throws internal_error
{
parse_action_row our_act_row;
parse_reduce_row our_red_row;
lalr_item itm;
parse_action act, other_act;
symbol sym;
terminal_set conflict_set = new terminal_set();
/* pull out our rows from the tables */
our_act_row = act_table.under_state[index()];
our_red_row = reduce_table.under_state[index()];
/* consider each item in our state */
for (Enumeration i = items().all(); i.hasMoreElements(); )
{
itm = (lalr_item)i.nextElement();
/* if its completed (dot at end) then reduce under the lookahead */
if (itm.dot_at_end())
{
act = new reduce_action(itm.the_production());
/* consider each lookahead symbol */
for (int t = 0; t < terminal.number(); t++)
{
/* skip over the ones not in the lookahead */
if (!itm.lookahead().contains(t)) continue;
/* if we don't already have an action put this one in */
if (our_act_row.under_term[t].kind() ==
parse_action.ERROR)
{
our_act_row.under_term[t] = act;
}
else
{
/* we now have at least one conflict */
terminal term = terminal.find(t);
other_act = our_act_row.under_term[t];
/* if the other act was not a shift */
if ((other_act.kind() != parse_action.SHIFT) &&
(other_act.kind() != parse_action.NONASSOC))
{
/* if we have lower index hence priority, replace it*/
if (itm.the_production().index() <
((reduce_action)other_act).reduce_with().index())
{
/* replace the action */
our_act_row.under_term[t] = act;
}
} else {
/* Check precedences,see if problem is correctable */
if(fix_with_precedence(itm.the_production(),
t, our_act_row, act)) {
term = null;
}
}
if(term!=null) {
conflict_set.add(term);
}
}
}
}
}
/* consider each outgoing transition */
for (lalr_transition trans=transitions(); trans!=null; trans=trans.next())
{
/* if its on an terminal add a shift entry */
sym = trans.on_symbol();
if (!sym.is_non_term())
{
act = new shift_action(trans.to_state());
/* if we don't already have an action put this one in */
if ( our_act_row.under_term[sym.index()].kind() ==
parse_action.ERROR)
{
our_act_row.under_term[sym.index()] = act;
}
else
{
/* we now have at least one conflict */
production p = ((reduce_action)our_act_row.under_term[sym.index()]).reduce_with();
/* shift always wins */
if (!fix_with_precedence(p, sym.index(), our_act_row, act)) {
our_act_row.under_term[sym.index()] = act;
conflict_set.add(terminal.find(sym.index()));
}
}
}
else
{
/* for non terminals add an entry to the reduce-goto table */
our_red_row.under_non_term[sym.index()] = trans.to_state();
}
}
/* if we end up with conflict(s), report them */
if (!conflict_set.empty())
report_conflicts(conflict_set);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Procedure that attempts to fix a shift/reduce error by using
* precedences. --frankf 6/26/96
*
* if a production (also called rule) or the lookahead terminal
* has a precedence, then the table can be fixed. if the rule
* has greater precedence than the terminal, a reduce by that rule
* in inserted in the table. If the terminal has a higher precedence,
* it is shifted. if they have equal precedence, then the associativity
* of the precedence is used to determine what to put in the table:
* if the precedence is left associative, the action is to reduce.
* if the precedence is right associative, the action is to shift.
* if the precedence is non associative, then it is a syntax error.
*
* @param p the production
* @param term_index the index of the lokahead terminal
* @param parse_action_row a row of the action table
* @param act the rule in conflict with the table entry
*/
protected boolean fix_with_precedence(
production p,
int term_index,
parse_action_row table_row,
parse_action act)
throws internal_error {
terminal term = terminal.find(term_index);
/* if the production has a precedence number, it can be fixed */
if (p.precedence_num() > assoc.no_prec) {
/* if production precedes terminal, put reduce in table */
if (p.precedence_num() > term.precedence_num()) {
table_row.under_term[term_index] =
insert_reduce(table_row.under_term[term_index],act);
return true;
}
/* if terminal precedes rule, put shift in table */
else if (p.precedence_num() < term.precedence_num()) {
table_row.under_term[term_index] =
insert_shift(table_row.under_term[term_index],act);
return true;
}
else { /* they are == precedence */
/* equal precedences have equal sides, so only need to
look at one: if it is right, put shift in table */
if (term.precedence_side() == assoc.right) {
table_row.under_term[term_index] =
insert_shift(table_row.under_term[term_index],act);
return true;
}
/* if it is left, put reduce in table */
else if (term.precedence_side() == assoc.left) {
table_row.under_term[term_index] =
insert_reduce(table_row.under_term[term_index],act);
return true;
}
/* if it is nonassoc, we're not allowed to have two nonassocs
of equal precedence in a row, so put in NONASSOC */
else if (term.precedence_side() == assoc.nonassoc) {
table_row.under_term[term_index] = new nonassoc_action();
return true;
} else {
/* something really went wrong */
throw new internal_error("Unable to resolve conflict correctly");
}
}
}
/* check if terminal has precedence, if so, shift, since
rule does not have precedence */
else if (term.precedence_num() > assoc.no_prec) {
table_row.under_term[term_index] =
insert_shift(table_row.under_term[term_index],act);
return true;
}
/* otherwise, neither the rule nor the terminal has a precedence,
so it can't be fixed. */
return false;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/* given two actions, and an action type, return the
action of that action type. give an error if they are of
the same action, because that should never have tried
to be fixed
*/
protected parse_action insert_action(
parse_action a1,
parse_action a2,
int act_type)
throws internal_error
{
if ((a1.kind() == act_type) && (a2.kind() == act_type)) {
throw new internal_error("Conflict resolution of bogus actions");
} else if (a1.kind() == act_type) {
return a1;
} else if (a2.kind() == act_type) {
return a2;
} else {
throw new internal_error("Conflict resolution of bogus actions");
}
}
/* find the shift in the two actions */
protected parse_action insert_shift(
parse_action a1,
parse_action a2)
throws internal_error
{
return insert_action(a1, a2, parse_action.SHIFT);
}
/* find the reduce in the two actions */
protected parse_action insert_reduce(
parse_action a1,
parse_action a2)
throws internal_error
{
return insert_action(a1, a2, parse_action.REDUCE);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce warning messages for all conflicts found in this state. */
protected void report_conflicts(terminal_set conflict_set)
throws internal_error
{
lalr_item itm, compare;
symbol shift_sym;
boolean after_itm;
/* consider each element */
for (Enumeration itms = items().all(); itms.hasMoreElements(); )
{
itm = (lalr_item)itms.nextElement();
/* clear the S/R conflict set for this item */
/* if it results in a reduce, it could be a conflict */
if (itm.dot_at_end())
{
/* not yet after itm */
after_itm = false;
/* compare this item against all others looking for conflicts */
for (Enumeration comps = items().all(); comps.hasMoreElements(); )
{
compare = (lalr_item)comps.nextElement();
/* if this is the item, next one is after it */
if (itm == compare) after_itm = true;
/* only look at it if its not the same item */
if (itm != compare)
{
/* is it a reduce */
if (compare.dot_at_end())
{
/* only look at reduces after itm */
if (after_itm)
/* does the comparison item conflict? */
if (compare.lookahead().intersects(itm.lookahead()))
/* report a reduce/reduce conflict */
report_reduce_reduce(itm, compare);
}
}
}
/* report S/R conflicts under all the symbols we conflict under */
for (int t = 0; t < terminal.number(); t++)
if (conflict_set.contains(t))
report_shift_reduce(itm,t);
}
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a warning message for one reduce/reduce conflict.
*
* @param itm1 first item in conflict.
* @param itm2 second item in conflict.
*/
protected void report_reduce_reduce(lalr_item itm1, lalr_item itm2)
throws internal_error
{
boolean comma_flag = false;
String message = "*** Reduce/Reduce conflict found in state #"+index()+"\n" +
" between " + itm1.to_simple_string() + "\n" +
" and " + itm2.to_simple_string() + "\n" +
" under symbols: {";
for (int t = 0; t < terminal.number(); t++)
{
if (itm1.lookahead().contains(t) && itm2.lookahead().contains(t))
{
if (comma_flag) message+=(", "); else comma_flag = true;
message += (terminal.find(t).name());
}
}
message += "}\n Resolved in favor of ";
if (itm1.the_production().index() < itm2.the_production().index())
message+="the first production.\n";
else
message+="the second production.\n";
/* count the conflict */
emit.num_conflicts++;
ErrorManager.getManager().emit_warning(message);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a warning message for one shift/reduce conflict.
*
* @param red_itm the item with the reduce.
* @param conflict_sym the index of the symbol conflict occurs under.
*/
protected void report_shift_reduce(
lalr_item red_itm,
int conflict_sym)
throws internal_error
{
lalr_item itm;
symbol shift_sym;
/* emit top part of message including the reduce item */
String message = "*** Shift/Reduce conflict found in state #"+index()+"\n" +
" between " + red_itm.to_simple_string()+"\n";
/* find and report on all items that shift under our conflict symbol */
for (Enumeration itms = items().all(); itms.hasMoreElements(); )
{
itm = (lalr_item)itms.nextElement();
/* only look if its not the same item and not a reduce */
if (itm != red_itm && !itm.dot_at_end())
{
/* is it a shift on our conflicting terminal */
shift_sym = itm.symbol_after_dot();
if (!shift_sym.is_non_term() && shift_sym.index() == conflict_sym)
{
/* yes, report on it */
message += " and " + itm.to_simple_string()+"\n";
}
}
}
message += " under symbol "+ terminal.find(conflict_sym).name() + "\n"+
" Resolved in favor of shifting.\n";
/* count the conflict */
emit.num_conflicts++;
ErrorManager.getManager().emit_warning(message);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison. */
public boolean equals(lalr_state other)
{
/* we are equal if our item sets are equal */
return other != null && items().equals(other.items());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof lalr_state))
return false;
else
return equals((lalr_state)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a hash code. */
public int hashCode()
{
/* just use the item set hash code */
return items().hashCode();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to a string. */
public String toString()
{
String result;
lalr_transition tr;
/* dump the item set */
result = "lalr_state [" + index() + "]: " + _items + "\n";
/* do the transitions */
for (tr = transitions(); tr != null; tr = tr.next())
{
result += tr;
result += "\n";
}
return result;
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/production_part.java 0000644 0001750 0001750 00000005146 10250537770 021674 0 ustar twerner twerner package java_cup;
/** This class represents one part (either a symbol or an action) of a
* production. In this base class it contains only an optional label
* string that the user can use to refer to the part within actions.
*
* This is an abstract class.
*
* @see java_cup.production
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public abstract class production_part {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Simple constructor. */
public production_part(String lab)
{
_label = lab;
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** Optional label for referring to the part within an action (null for
* no label).
*/
protected String _label;
/** Optional label for referring to the part within an action (null for
* no label).
*/
public String label() {return _label;}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Indicate if this is an action (rather than a symbol). Here in the
* base class, we don't this know yet, so its an abstract method.
*/
public abstract boolean is_action();
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison. */
public boolean equals(production_part other)
{
if (other == null) return false;
/* compare the labels */
if (label() != null)
return label().equals(other.label());
else
return other.label() == null;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof production_part))
return false;
else
return equals((production_part)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a hash code. */
public int hashCode()
{
return label()==null ? 0 : label().hashCode();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to a string. */
public String toString()
{
if (label() != null)
return label() + ":";
else
return " ";
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/reduce_action.java 0000644 0001750 0001750 00000004575 10250537770 021271 0 ustar twerner twerner
package java_cup;
/** This class represents a reduce action within the parse table.
* The action simply stores the production that it reduces with and
* responds to queries about its type.
*
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class reduce_action extends parse_action {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Simple constructor.
* @param prod the production this action reduces with.
*/
public reduce_action(production prod ) throws internal_error
{
/* sanity check */
if (prod == null)
throw new internal_error(
"Attempt to create a reduce_action with a null production");
_reduce_with = prod;
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The production we reduce with. */
protected production _reduce_with;
/** The production we reduce with. */
public production reduce_with() {return _reduce_with;}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Quick access to type of action. */
public int kind() {return REDUCE;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality test. */
public boolean equals(reduce_action other)
{
return other != null && other.reduce_with() == reduce_with();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality test. */
public boolean equals(Object other)
{
if (other instanceof reduce_action)
return equals((reduce_action)other);
else
return false;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Compute a hash code. */
public int hashCode()
{
/* use the hash code of the production we are reducing with */
return reduce_with().hashCode();
}
/** Convert to string. */
public String toString()
{
return "REDUCE(with prod " + reduce_with().index() + ")";
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/symbol_set.java 0000644 0001750 0001750 00000014303 10250537770 020633 0 ustar twerner twerner
package java_cup;
import java.util.Hashtable;
import java.util.Enumeration;
/** This class represents a set of symbols and provides a series of
* set operations to manipulate them.
*
* @see java_cup.symbol
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class symbol_set {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Constructor for an empty set. */
public symbol_set() { }
/** Constructor for cloning from another set.
* @param other the set we are cloning from.
*/
public symbol_set(symbol_set other) throws internal_error
{
not_null(other);
_all = (Hashtable)other._all.clone();
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** A hash table to hold the set. Symbols are keyed using their name string.
*/
protected Hashtable _all = new Hashtable(11);
/** Access to all elements of the set. */
public Enumeration all() {return _all.elements();}
/** size of the set */
public int size() {return _all.size();}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** Helper function to test for a null object and throw an exception
* if one is found.
* @param obj the object we are testing.
*/
protected void not_null(Object obj) throws internal_error
{
if (obj == null)
throw new internal_error("Null object used in set operation");
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Determine if the set contains a particular symbol.
* @param sym the symbol we are looking for.
*/
public boolean contains(symbol sym) {return _all.containsKey(sym.name());}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Determine if this set is an (improper) subset of another.
* @param other the set we are testing against.
*/
public boolean is_subset_of(symbol_set other) throws internal_error
{
not_null(other);
/* walk down our set and make sure every element is in the other */
for (Enumeration e = all(); e.hasMoreElements(); )
if (!other.contains((symbol)e.nextElement()))
return false;
/* they were all there */
return true;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Determine if this set is an (improper) superset of another.
* @param other the set we are are testing against.
*/
public boolean is_superset_of(symbol_set other) throws internal_error
{
not_null(other);
return other.is_subset_of(this);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Add a single symbol to the set.
* @param sym the symbol we are adding.
* @return true if this changes the set.
*/
public boolean add(symbol sym) throws internal_error
{
Object previous;
not_null(sym);
/* put the object in */
previous = _all.put(sym.name(),sym);
/* if we had a previous, this is no change */
return previous == null;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Remove a single symbol if it is in the set.
* @param sym the symbol we are removing.
*/
public void remove(symbol sym) throws internal_error
{
not_null(sym);
_all.remove(sym.name());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Add (union) in a complete set.
* @param other the set we are adding in.
* @return true if this changes the set.
*/
public boolean add(symbol_set other) throws internal_error
{
boolean result = false;
not_null(other);
/* walk down the other set and do the adds individually */
for (Enumeration e = other.all(); e.hasMoreElements(); )
result = add((symbol)e.nextElement()) || result;
return result;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Remove (set subtract) a complete set.
* @param other the set we are removing.
*/
public void remove(symbol_set other) throws internal_error
{
not_null(other);
/* walk down the other set and do the removes individually */
for (Enumeration e = other.all(); e.hasMoreElements(); )
remove((symbol)e.nextElement());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison. */
public boolean equals(symbol_set other)
{
if (other == null || other.size() != size()) return false;
/* once we know they are the same size, then improper subset does test */
try {
return is_subset_of(other);
} catch (internal_error e) {
/* can't throw the error (because super class doesn't), so we crash */
e.crash();
return false;
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof symbol_set))
return false;
else
return equals((symbol_set)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Compute a hash code. */
public int hashCode()
{
int result = 0;
int cnt;
Enumeration e;
/* hash together codes from at most first 5 elements */
for (e = all(), cnt=0 ; e.hasMoreElements() && cnt<5; cnt++)
result ^= ((symbol)e.nextElement()).hashCode();
return result;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to a string. */
public String toString()
{
String result;
boolean comma_flag;
result = "{";
comma_flag = false;
for (Enumeration e = all(); e.hasMoreElements(); )
{
if (comma_flag)
result += ", ";
else
comma_flag = true;
result += ((symbol)e.nextElement()).name();
}
result += "}";
return result;
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/parse_action_table.java 0000644 0001750 0001750 00000010232 10250551266 022262 0 ustar twerner twerner
package java_cup;
import java.util.Enumeration;
/** This class represents the complete "action" table of the parser.
* It has one row for each state in the parse machine, and a column for
* each terminal symbol. Each entry in the table represents a shift,
* reduce, or an error.
*
* @see java_cup.parse_action
* @see java_cup.parse_action_row
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class parse_action_table {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Simple constructor. All terminals, non-terminals, and productions must
* already have been entered, and the viable prefix recognizer should
* have been constructed before this is called.
*/
public parse_action_table()
{
/* determine how many states we are working with */
_num_states = lalr_state.number();
/* allocate the array and fill it in with empty rows */
under_state = new parse_action_row[_num_states];
for (int i=0; i<_num_states; i++)
under_state[i] = new parse_action_row();
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** How many rows/states are in the machine/table. */
protected int _num_states;
/** How many rows/states are in the machine/table. */
public int num_states() {return _num_states;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Actual array of rows, one per state. */
public parse_action_row[] under_state;
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Check the table to ensure that all productions have been reduced.
* Issue a warning message (to System.err) for each production that
* is never reduced.
*/
public void check_reductions()
throws internal_error
{
parse_action act;
production prod;
/* tabulate reductions -- look at every table entry */
for (int row = 0; row < num_states(); row++)
{
for (int col = 0; col < parse_action_row.size(); col++)
{
/* look at the action entry to see if its a reduce */
act = under_state[row].under_term[col];
if (act != null && act.kind() == parse_action.REDUCE)
{
/* tell production that we used it */
((reduce_action)act).reduce_with().note_reduction_use();
}
}
}
/* now go across every production and make sure we hit it */
for (Enumeration p = production.all(); p.hasMoreElements(); )
{
prod = (production)p.nextElement();
/* if we didn't hit it give a warning */
if (prod.num_reductions() == 0)
{
/* count it *
emit.not_reduced++;
/* give a warning if they haven't been turned off */
if (!emit.nowarn)
{
ErrorManager.getManager().emit_warning("*** Production \"" +
prod.to_simple_string() + "\" never reduced");
}
}
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*
/** Convert to a string. */
public String toString()
{
String result;
int cnt;
result = "-------- ACTION_TABLE --------\n";
for (int row = 0; row < num_states(); row++)
{
result += "From state #" + row + "\n";
cnt = 0;
for (int col = 0; col < parse_action_row.size(); col++)
{
/* if the action is not an error print it */
if (under_state[row].under_term[col].kind() != parse_action.ERROR)
{
result += " [term " + col + ":" + under_state[row].under_term[col] + "]";
/* end the line after the 2nd one */
cnt++;
if (cnt == 2)
{
result += "\n";
cnt = 0;
}
}
}
/* finish the line if we haven't just done that */
if (cnt != 0) result += "\n";
}
result += "------------------------------";
return result;
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/internal_error.java 0000644 0001750 0001750 00000001072 10252326462 021473 0 ustar twerner twerner
package java_cup;
/** Exception subclass for reporting internal errors in JavaCup. */
public class internal_error extends Exception
{
/** Constructor with a message */
public internal_error(String msg)
{
super(msg);
}
/** Method called to do a forced error exit on an internal error
for cases when we can't actually throw the exception. */
public void crash()
{
ErrorManager.getManager().emit_fatal("JavaCUP Internal Error Detected: "+getMessage());
printStackTrace();
System.exit(-1);
}
}
cup-0.11a+20060608/src/java_cup/action_production.java 0000644 0001750 0001750 00000003413 10441773704 022177 0 ustar twerner twerner
package java_cup;
/** A specialized version of a production used when we split an existing
* production in order to remove an embedded action. Here we keep a bit
* of extra bookkeeping so that we know where we came from.
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class action_production extends production {
/** Constructor.
* @param base the production we are being factored out of.
* @param lhs_sym the LHS symbol for this production.
* @param rhs_parts array of production parts for the RHS.
* @param rhs_len how much of the rhs_parts array is valid.
* @param action_str the trailing reduce action for this production.
* @param indexOfIntermediateResult the index of the result of the previous intermediate action on the stack relative to top, -1 if no previous action
*/
public action_production(
production base,
non_terminal lhs_sym,
production_part rhs_parts[],
int rhs_len,
String action_str,
int indexOfIntermediateResult)
throws internal_error
{
super(lhs_sym, rhs_parts, rhs_len, action_str);
_base_production = base;
this.indexOfIntermediateResult = indexOfIntermediateResult;
}
private int indexOfIntermediateResult;
/**
* @return the index of the result of the previous intermediate action on the stack relative to top, -1 if no previous action
*/
public int getIndexOfIntermediateResult(){
return indexOfIntermediateResult;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** The production we were taken out of. */
protected production _base_production;
/** The production we were taken out of. */
public production base_production() {return _base_production;}
}
cup-0.11a+20060608/src/java_cup/lalr_item.java 0000644 0001750 0001750 00000024536 10250537770 020434 0 ustar twerner twerner package java_cup;
import java.util.Stack;
import java.util.Enumeration;
/** This class represents an LALR item. Each LALR item consists of
* a production, a "dot" at a position within that production, and
* a set of lookahead symbols (terminal). (The first two of these parts
* are provide by the super class). An item is designed to represent a
* configuration that the parser may be in. For example, an item of the
* form:
*
* Items may initially be missing some items from their lookahead sets.
* Links are maintained from each item to the set of items that would need
* to be updated if symbols are added to its lookahead set. During
* "lookahead propagation", we add symbols to various lookahead sets and
* propagate these changes across these dependency links as needed.
*
* @see java_cup.lalr_item_set
* @see java_cup.lalr_state
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class lalr_item extends lr_item_core {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Full constructor.
* @param prod the production for the item.
* @param pos the position of the "dot" within the production.
* @param look the set of lookahead symbols.
*/
public lalr_item(production prod, int pos, terminal_set look)
throws internal_error
{
super(prod, pos);
_lookahead = look;
_propagate_items = new Stack();
needs_propagation = true;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Constructor with default position (dot at start).
* @param prod the production for the item.
* @param look the set of lookahead symbols.
*/
public lalr_item(production prod, terminal_set look) throws internal_error
{
this(prod,0,look);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Constructor with default position and empty lookahead set.
* @param prod the production for the item.
*/
public lalr_item(production prod) throws internal_error
{
this(prod,0,new terminal_set());
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The lookahead symbols of the item. */
protected terminal_set _lookahead;
/** The lookahead symbols of the item. */
public terminal_set lookahead() {return _lookahead;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Links to items that the lookahead needs to be propagated to. */
protected Stack _propagate_items;
/** Links to items that the lookahead needs to be propagated to */
public Stack propagate_items() {return _propagate_items;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Flag to indicate that this item needs to propagate its lookahead
* (whether it has changed or not).
*/
protected boolean needs_propagation;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Add a new item to the set of items we propagate to. */
public void add_propagate(lalr_item prop_to)
{
_propagate_items.push(prop_to);
needs_propagation = true;
}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Propagate incoming lookaheads through this item to others need to
* be changed.
* @params incoming symbols to potentially be added to lookahead of this item.
*/
public void propagate_lookaheads(terminal_set incoming) throws internal_error
{
boolean change = false;
/* if we don't need to propagate, then bail out now */
if (!needs_propagation && (incoming == null || incoming.empty()))
return;
/* if we have null incoming, treat as an empty set */
if (incoming != null)
{
/* add the incoming to the lookahead of this item */
change = lookahead().add(incoming);
}
/* if we changed or need it anyway, propagate across our links */
if (change || needs_propagation)
{
/* don't need to propagate again */
needs_propagation = false;
/* propagate our lookahead into each item we are linked to */
for (int i = 0; i < propagate_items().size(); i++)
((lalr_item)propagate_items().elementAt(i))
.propagate_lookaheads(lookahead());
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce the new lalr_item that results from shifting the dot one position
* to the right.
*/
public lalr_item shift() throws internal_error
{
lalr_item result;
/* can't shift if we have dot already at the end */
if (dot_at_end())
throw new internal_error("Attempt to shift past end of an lalr_item");
/* create the new item w/ the dot shifted by one */
result = new lalr_item(the_production(), dot_pos()+1,
new terminal_set(lookahead()));
/* change in our lookahead needs to be propagated to this item */
add_propagate(result);
return result;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Calculate lookahead representing symbols that could appear after the
* symbol that the dot is currently in front of. Note: this routine must
* not be invoked before first sets and nullability has been calculated
* for all non terminals.
*/
public terminal_set calc_lookahead(terminal_set lookahead_after)
throws internal_error
{
terminal_set result;
int pos;
production_part part;
symbol sym;
/* sanity check */
if (dot_at_end())
throw new internal_error(
"Attempt to calculate a lookahead set with a completed item");
/* start with an empty result */
result = new terminal_set();
/* consider all nullable symbols after the one to the right of the dot */
for (pos = dot_pos()+1; pos < the_production().rhs_length(); pos++)
{
part = the_production().rhs(pos);
/* consider what kind of production part it is -- skip actions */
if (!part.is_action())
{
sym = ((symbol_part)part).the_symbol();
/* if its a terminal add it in and we are done */
if (!sym.is_non_term())
{
result.add((terminal)sym);
return result;
}
else
{
/* otherwise add in first set of the non terminal */
result.add(((non_terminal)sym).first_set());
/* if its nullable we continue adding, if not, we are done */
if (!((non_terminal)sym).nullable())
return result;
}
}
}
/* if we get here everything past the dot was nullable
we add in the lookahead for after the production and we are done */
result.add(lookahead_after);
return result;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Determine if everything from the symbol one beyond the dot all the
* way to the end of the right hand side is nullable. This would indicate
* that the lookahead of this item must be included in the lookaheads of
* all items produced as a closure of this item. Note: this routine should
* not be invoked until after first sets and nullability have been
* calculated for all non terminals.
*/
public boolean lookahead_visible() throws internal_error
{
production_part part;
symbol sym;
/* if the dot is at the end, we have a problem, but the cleanest thing
to do is just return true. */
if (dot_at_end()) return true;
/* walk down the rhs and bail if we get a non-nullable symbol */
for (int pos = dot_pos() + 1; pos < the_production().rhs_length(); pos++)
{
part = the_production().rhs(pos);
/* skip actions */
if (!part.is_action())
{
sym = ((symbol_part)part).the_symbol();
/* if its a terminal we fail */
if (!sym.is_non_term()) return false;
/* if its not nullable we fail */
if (!((non_terminal)sym).nullable()) return false;
}
}
/* if we get here its all nullable */
return true;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison -- here we only require the cores to be equal since
* we need to do sets of items based only on core equality (ignoring
* lookahead sets).
*/
public boolean equals(lalr_item other)
{
if (other == null) return false;
return super.equals(other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof lalr_item))
return false;
else
return equals((lalr_item)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Return a hash code -- here we only hash the core since we only test core
* matching in LALR items.
*/
public int hashCode()
{
return super.hashCode();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to string. */
public String toString()
{
String result = "";
// additional output for debugging:
// result += "(" + obj_hash() + ")";
result += "[";
result += super.toString();
result += ", ";
if (lookahead() != null)
{
result += "{";
for (int t = 0; t < terminal.number(); t++)
if (lookahead().contains(t))
result += terminal.find(t).name() + " ";
result += "}";
}
else
result += "NULL LOOKAHEAD!!";
result += "]";
// additional output for debugging:
// result += " -> ";
// for (int i = 0; i
Although this manual covers all aspects of the CUP system, it is relatively
brief, and assumes you have at least a little bit of knowledge of LR
parsing. A working knowledge of YACC is also very helpful in
understanding how CUP specifications work.
A number of compiler construction textbooks (such as
[2,3]) cover this material,
and discuss the YACC system (which is quite similar to this one) as a
specific example.
Using CUP involves creating a simple specification based on the
grammar for which a parser is needed, along with construction of a
scanner capable of breaking characters up into meaningful tokens (such
as keywords, numbers, and special symbols).
As a simple example, consider a
system for evaluating simple arithmetic expressions over integers.
This system would read expressions from standard input (each terminated
with a semicolon), evaluate them, and print the result on standard output.
A grammar for the input to such a system might look like:
To produce a parser from this specification we use the CUP generator.
If this specification were stored in a file parser.cup, then
(on a Unix system at least) we might invoke CUP using a command like:
The specification above, while constructing a full parser, does not perform
any semantic actions &emdash; it will only indicate success or failure of a parse.
To calculate and print values of each expression, we must embed Java
code within the parser to carry out actions at various points. In CUP,
actions are contained in code strings which are surrounded by delimiters
of the form {: and :} (we can see examples of this in the
init with and scan with clauses above). In general, the
system records all characters within the delimiters, but does not try to check
that it contains valid Java code.
A more complete CUP specification for our example system (with actions
embedded at various points in the grammar) is shown below:
The final step in creating a working parser is to create a scanner (also
known as a lexical analyzer or simply a lexer). This routine is
responsible for reading individual characters, removing things things like
white space and comments, recognizing which terminal symbols from the
grammar each group of characters represents, then returning Symbol objects
representing these symbols to the parser.
The terminals will be retrieved with a call to the
scanner function. In the example, the parser will call
scanner.next_token(). The scanner should return objects of
type java_cup.runtime.Symbol. This type is very different than
older versions of CUP's java_cup.runtime.symbol. These Symbol
objects contains the instance variable value of type Object,
which should be
set by the lexer. This variable refers to the value of that symbol, and
the type of object in value should be of the same type as declared in
the terminal and non terminal declarations. In the
above example, if the lexer wished to pass a NUMBER token, it should
create a Symbol with the value instance variable
filled with an object of type Integer.
In the next section a more detailed and formal
explanation of all parts of a CUP specification will be given.
Section 3 describes options for running the
CUP system. Section 4 discusses the details
of how to customize a CUP parser, while section 5
discusses the scanner interface added in CUP 0.10j. Section
6 considers error recovery. Finally, Section 7
provides a conclusion.
After an optional package declaration, there can be zero or more
import declarations. As in a Java program these have the form:
After the action code declaration is an optional
parser code declaration. This declaration allows methods and
variable to be placed directly within the generated parser class.
Although this is less common, it can be helpful when customizing the
parser &emdash; it is possible for example, to include scanning methods inside
the parser and/or override the default error reporting routines. This
declaration is very similar to the action code declaration and
takes the form:
Next in the specification is the optional init declaration
which has the form:
The final (optional) user code section of the specification indicates how
the parser should ask for the next token from the scanner. This has the
form:
As of CUP 0.10j the action code, parser code, init code, and scan with
sections may appear in any order. They must, however, precede the
symbol lists.
Names of terminals and non-terminals cannot be CUP reserved words;
these include "code", "action", "parser", "terminal", "non",
"nonterminal", "init", "scan", "with", "start", "precedence", "left",
"right", "nonassoc", "import", and "package".
CUP assigns each one of its terminals a precedence according to these
declarations. Any terminals not in this declaration have lowest
precedence. CUP also assigns each of its productions a precedence.
That precedence is equal to the precedence of the last terminal in that
production. If the production has no terminals, then it has lowest
precedence. For example, expr ::= expr TIMES expr would have
the same precedence as TIMES. When there is a shift/reduce
conflict, the parser determines whether the terminal to be shifted has a
higher precedence, or if the production to reduce by does. If the
terminal has higher precedence, it it shifted, if the production has
higher precedence, a reduce is performed. If they have equal
precedence, associativity of the terminal determine what happens.
An associativity is assigned to each terminal used in the
precedence/associativity declarations. The three associativities are
left, right and nonassoc Associativities are also
used to resolve shift/reduce conflicts, but only in the case of equal
precedences. If the associativity of the terminal that can be shifted
is left, then a reduce is performed. This means, if the input
is a string of additions, like 3 + 4 + 5 + 6 + 7, the parser
will always reduce them from left to right, in this case,
starting with 3 + 4. If the associativity of the terminal is
right, it is shifted onto the stack. hence, the reductions
will take place from right to left. So, if PLUS were declared with
associativity of right, the 6 + 7 would be reduced
first in the above string. If a terminal is declared as
nonassoc, then two consecutive occurrences of equal precedence
non-associative terminals generates an error. This is useful for
comparison operations. For example, if the input string is
6 == 7 == 8 == 9, the parser should generate an error. If '=='
is declared as nonassoc then an error will be generated.
All terminals not used in the precedence/associativity declarations are
treated as lowest precedence. If a shift/reduce error results,
involving two such terminals, it cannot be resolved, as the above
conflicts are, so it will be reported.
The grammar itself follows the optional start declaration. Each
production in the grammar has a left hand side non-terminal followed by
the symbol "::=", which is then followed by a series of zero or more
actions, terminal, or non-terminal
symbols, followed by an optional contextual precedence assignment,
and terminated with a semicolon (;).
In addition to the specification file, CUP's behavior can also be changed
by passing various options to it. Legal options are documented in
The parser class contains the actual generated parser. It is
a subclass of java_cup.runtime.lr_parser which implements a
general table driven framework for an LR parser. The generated parser
class provides a series of tables for use by the general framework.
Three tables are provided:
Beyond the parse tables, generated (or inherited) code provides a series
of methods that can be used to customize the generated parser. Some of these
methods are supplied by code found in part of the specification and can
be customized directly in that fashion. The others are provided by the
lr_parser base class and can be overridden with new versions (via
the parser code declaration) to customize the system. Methods
available for customization include:
In addition to the normal parser, the runtime system also provides a debugging
version of the parser. This operates in exactly the same way as the normal
parser, but prints debugging messages (by calling
public void debug_message(String mess) whose default implementation
prints a message to System.err).
Based on these routines, invocation of a CUP parser is typically done
with code such as:
To use the new code, your scanner should implement the
In addition to the methods described in section
4, the
The generated parser also contains a constructor which takes a
Note that because the parser uses look-ahead, resetting the scanner in
the middle of a parse is not recommended. If you attempt to use the
default implementation of
As an example of scanner integration, the following three lines in the
lexer-generator input are all that is required to use a
JLex
scanner with CUP:
Note that you still have to handle EOF correctly; the JLex code to do
so is something like:
The simple_calc example in the CUP distribution illustrates the use of
the scanner integration features with a hand-coded scanner. Since CUP v11a we offer the possibility of advanced symbol handling in CUP.
Therefore, You can implement Your own SymbolFactory, derived from
All You have to do is providing Your CUP-generated parser with the new
SymbolFactory which can be done like this: Also, You can use the factory methods in Your SymbolFactory to have
callbacks/hooks into the semantic action methods. That is especially usefull,
when You want to equip Your syntax tree with Location information as You can do
as follows:
The error symbol only comes into play if a syntax error is
detected. If a syntax error is detected then the parser tries to replace
some portion of the input token stream with error and then
continue parsing. For example, we might have productions such as:
Specifically, the parser first looks for the closest state to the top
of the parse stack that has an outgoing transition under
error. This generally corresponds to working from
productions that represent more detailed constructs (such as a specific
kind of statement) up to productions that represent more general or
enclosing constructs (such as the general production for all
statements or a production representing a whole section of declarations)
until we get to a place where an error recovery production
has been provided for. Once the parser is placed into a configuration
that has an immediate error recovery (by popping the stack to the first
such state), the parser begins skipping tokens to find a point at
which the parse can be continued. After discarding each token, the
parser attempts to parse ahead in the input (without executing any
embedded semantic actions). If the parser can successfully parse past
the required number of tokens, then the input is backed up to the point
of recovery and the parse is resumed normally (executing all actions).
If the parse cannot be continued far enough, then another token is
discarded and the parser again tries to parse ahead. If the end of
input is reached without making a successful recovery (or there was no
suitable error recovery state found on the parse stack to begin with)
then error recovery fails.
This document covers version 0.10j of the system. Check the CUP home
page:
http://www.cs.princeton.edu/~appel/modern/java/CUP/
for the latest release information, instructions for downloading the
system, and additional news about CUP. Bug reports and other
comments for the developers should be sent to the CUP maintainer,
C. Scott Ananian, at
cananian@alumni.princeton.edu
CUP was originally written by
Scott Hudson, in August of 1995.
It was extended to support precedence by
Frank Flannery, in July of 1996.
On-going improvements have been done by
C. Scott Ananian, the CUP maintainer, from December of 1997 to the
present.
For more information, refer to the manual on scanners.
For more information, refer to the manual on declarations.
For more information, refer to the manual on labels.
For more information, refer to the manual on RESULT.
For more information, refer to the manual on positions.
For more information, refer to the manual on precedence.
For more information, refer to the manual on contextual
precedence.
These changes implemented by:
This is because the parsing tables (and parsing engine) are in one object (belonging to
class parser or whatever name is specified by the -parser directive),
and the semantic actions are in another object (of class CUP$actions).
However, there is a way to do it, though it's a bit inelegant.
The action object has a private final field named
parser that points to the parsing object. Thus,
methods and instance variables of the parser can be accessed within semantic actions as:
Perhaps this will not be necessary in a future release, and that
such methods and variables as report_error and
mydata will be available
directly from the semantic actions; we will achieve this by combining the
"parser" object and the "actions" object together.
For a list of any other currently known bugs in CUP, see
http://www.cs.princeton.edu/~appel/modern/java/CUP/bugs.html.
reduce_goto table. */");
out.println(" public short[][] reduce_table() {return _reduce_table;}");
out.println();
goto_table_time = System.currentTimeMillis() - start_time;
}
// print a string array encoding the given short[][] array.
protected static void do_table_as_string(PrintWriter out, short[][] sa) {
out.println("new String[] {");
out.print(" \"");
int nchar=0, nbytes=0;
nbytes+=do_escaped(out, (char)(sa.length>>16));
nchar =do_newline(out, nchar, nbytes);
nbytes+=do_escaped(out, (char)(sa.length&0xFFFF));
nchar =do_newline(out, nchar, nbytes);
for (int i=0; iEOF Symbol index. */");
out.println(" public int EOF_sym() {return " + terminal.EOF.index() +
";}");
out.println();
out.println(" /** error Symbol index. */");
out.println(" public int error_sym() {return " + terminal.error.index() +
";}");
out.println();
/* user supplied code for user_init() */
if (init_code != null)
{
out.println();
out.println(" /** User initialization code. */");
out.println(" public void user_init() throws java.lang.Exception");
out.println(" {");
out.println(init_code);
out.println(" }");
}
/* user supplied code for scan */
if (scan_code != null)
{
out.println();
out.println(" /** Scan to get the next Symbol. */");
out.println(" public java_cup.runtime.Symbol scan()");
out.println(" throws java.lang.Exception");
out.println(" {");
out.println(scan_code);
out.println(" }");
}
/* user supplied code */
if (parser_code != null)
{
out.println();
out.println(parser_code);
}
/* end of class */
out.println("}");
/* put out the action code class */
emit_action_code(out, start_prod);
parser_time = System.currentTimeMillis() - start_time;
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/action_part.java 0000644 0001750 0001750 00000005466 10250537770 020770 0 ustar twerner twerner
package java_cup;
/**
* This class represents a part of a production which contains an
* action. These are eventually eliminated from productions and converted
* to trailing actions by factoring out with a production that derives the
* empty string (and ends with this action).
*
* @see java_cup.production
* @version last update: 11/25/95
* @author Scott Hudson
*/
public class action_part extends production_part {
/*-----------------------------------------------------------*/
/*--- Constructors ------------------------------------------*/
/*-----------------------------------------------------------*/
/** Simple constructor.
* @param code_str string containing the actual user code.
*/
public action_part(String code_str)
{
super(/* never have a label on code */null);
_code_string = code_str;
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** String containing code for the action in question. */
protected String _code_string;
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** String containing code for the action in question. */
public String code_string() {return _code_string;}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Set the code string. */
public void set_code_string(String new_str) {_code_string = new_str;}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Override to report this object as an action. */
public boolean is_action() { return true; }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison for properly typed object. */
public boolean equals(action_part other)
{
/* compare the strings */
return other != null && super.equals(other) &&
other.code_string().equals(code_string());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof action_part))
return false;
else
return equals((action_part)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a hash code. */
public int hashCode()
{
return super.hashCode() ^
(code_string()==null ? 0 : code_string().hashCode());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to a string. */
public String toString()
{
return super.toString() + "{" + code_string() + "}";
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/symbol_part.java 0000644 0001750 0001750 00000005556 10250537770 021020 0 ustar twerner twerner package java_cup;
/** This class represents a part of a production which is a symbol (terminal
* or non terminal). This simply maintains a reference to the symbol in
* question.
*
* @see java_cup.production
* @version last updated: 11/25/95
* @author Scott Hudson
*/
public class symbol_part extends production_part {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Full constructor.
* @param sym the symbol that this part is made up of.
* @param lab an optional label string for the part.
*/
public symbol_part(symbol sym, String lab) throws internal_error
{
super(lab);
if (sym == null)
throw new internal_error(
"Attempt to construct a symbol_part with a null symbol");
_the_symbol = sym;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Constructor with no label.
* @param sym the symbol that this part is made up of.
*/
public symbol_part(symbol sym) throws internal_error
{
this(sym,null);
}
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** The symbol that this part is made up of. */
protected symbol _the_symbol;
/** The symbol that this part is made up of. */
public symbol the_symbol() {return _the_symbol;}
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Respond that we are not an action part. */
public boolean is_action() { return false; }
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison. */
public boolean equals(symbol_part other)
{
return other != null && super.equals(other) &&
the_symbol().equals(other.the_symbol());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof symbol_part))
return false;
else
return equals((symbol_part)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Produce a hash code. */
public int hashCode()
{
return super.hashCode() ^
(the_symbol()==null ? 0 : the_symbol().hashCode());
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to a string. */
public String toString()
{
if (the_symbol() != null)
return super.toString() + the_symbol();
else
return super.toString() + "$$MISSING-SYMBOL$$";
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/lalr_item_set.java 0000644 0001750 0001750 00000025375 10250537770 021311 0 ustar twerner twerner
package java_cup;
import java.util.Hashtable;
import java.util.Enumeration;
/** This class represents a set of LALR items. For purposes of building
* these sets, items are considered unique only if they have unique cores
* (i.e., ignoring differences in their lookahead sets).
* [L ::= a *N alpha, l]
*
* (where N is a a non terminal and alpha is a string of symbols) make
* sure there are also items of the form:
* [N ::= *beta, first(alpha l)]
*
* corresponding to each production of N. Items with identical cores but
* differing lookahead sets are merged by creating a new item with the same
* core and the union of the lookahead sets (the LA in LALR stands for
* "lookahead merged" and this is where the merger is). This routine
* assumes that nullability and first sets have been computed for all
* productions before it is called.
*/
public void compute_closure()
throws internal_error
{
lalr_item_set consider;
lalr_item itm, new_itm, add_itm;
non_terminal nt;
terminal_set new_lookaheads;
Enumeration p;
production prod;
boolean need_prop;
/* invalidate cached hashcode */
hashcode_cache = null;
/* each current element needs to be considered */
consider = new lalr_item_set(this);
/* repeat this until there is nothing else to consider */
while (consider.size() > 0)
{
/* get one item to consider */
itm = consider.get_one();
/* do we have a dot before a non terminal */
nt = itm.dot_before_nt();
if (nt != null)
{
/* create the lookahead set based on first after dot */
new_lookaheads = itm.calc_lookahead(itm.lookahead());
/* are we going to need to propagate our lookahead to new item */
need_prop = itm.lookahead_visible();
/* create items for each production of that non term */
for (p = nt.productions(); p.hasMoreElements(); )
{
prod = (production)p.nextElement();
/* create new item with dot at start and that lookahead */
new_itm = new lalr_item(prod,
new terminal_set(new_lookaheads));
/* add/merge item into the set */
add_itm = add(new_itm);
/* if propagation is needed link to that item */
if (need_prop)
itm.add_propagate(add_itm);
/* was this was a new item*/
if (add_itm == new_itm)
{
/* that may need further closure, consider it also */
consider.add(new_itm);
}
}
}
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Equality comparison. */
public boolean equals(lalr_item_set other)
{
if (other == null || other.size() != size()) return false;
/* once we know they are the same size, then improper subset does test */
try {
return is_subset_of(other);
} catch (internal_error e) {
/* can't throw error from here (because superclass doesn't) so crash */
e.crash();
return false;
}
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Generic equality comparison. */
public boolean equals(Object other)
{
if (!(other instanceof lalr_item_set))
return false;
else
return equals((lalr_item_set)other);
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Return hash code. */
public int hashCode()
{
int result = 0;
Enumeration e;
int cnt;
/* only compute a new one if we don't have it cached */
if (hashcode_cache == null)
{
/* hash together codes from at most first 5 elements */
// CSA fix! we'd *like* to hash just a few elements, but
// that means equal sets will have inequal hashcodes, which
// we're not allowed (by contract) to do. So hash them all.
for (e = all(), cnt=0 ; e.hasMoreElements() /*&& cnt<5*/; cnt++)
result ^= ((lalr_item)e.nextElement()).hashCode();
hashcode_cache = new Integer(result);
}
return hashcode_cache.intValue();
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Convert to string. */
public String toString()
{
StringBuffer result = new StringBuffer();
result.append("{\n");
for (Enumeration e=all(); e.hasMoreElements(); )
{
result.append(" " + (lalr_item)e.nextElement() + "\n");
}
result.append("}");
return result.toString();
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/parse_action_row.java 0000644 0001750 0001750 00000007213 10250545245 022007 0 ustar twerner twerner
package java_cup;
/** This class represents one row (corresponding to one machine state) of the
* parse action table.
*/
public class parse_action_row {
/*-----------------------------------------------------------*/
/*--- Constructor(s) ----------------------------------------*/
/*-----------------------------------------------------------*/
/** Simple constructor. Note: this should not be used until the number of
* terminals in the grammar has been established.
*/
public parse_action_row()
{
/* make sure the size is set */
if (_size <= 0 ) _size = terminal.number();
/* allocate the array */
under_term = new parse_action[size()];
/* set each element to an error action */
for (int i=0; i<_size; i++)
under_term[i] = new parse_action();
}
/*-----------------------------------------------------------*/
/*--- (Access to) Static (Class) Variables ------------------*/
/*-----------------------------------------------------------*/
/** Number of columns (terminals) in every row. */
protected static int _size = 0;
/** Number of columns (terminals) in every row. */
public static int size() {return _size;}
//Hm Added clear to clear all static fields
public static void clear() {
_size = 0;
reduction_count = null;
}
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Table of reduction counts (reused by compute_default()). */
protected static int reduction_count[] = null;
/*-----------------------------------------------------------*/
/*--- (Access to) Instance Variables ------------------------*/
/*-----------------------------------------------------------*/
/** Actual action entries for the row. */
public parse_action under_term[];
/*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
/** Default (reduce) action for this row. -1 will represent default
* of error.
*/
public int default_reduce;
/*-----------------------------------------------------------*/
/*--- General Methods ---------------------------------------*/
/*-----------------------------------------------------------*/
/** Compute the default (reduce) action for this row and store it in
* default_reduce. In the case of non-zero default we will have the
* effect of replacing all errors by that reduction. This may cause
* us to do erroneous reduces, but will never cause us to shift past
* the point of the error and never cause an incorrect parse. -1 will
* be used to encode the fact that no reduction can be used as a
* default (in which case error will be used).
*/
public void compute_default()
{
int i, prod, max_prod, max_red;
/* if we haven't allocated the count table, do so now */
if (reduction_count == null)
reduction_count = new int[production.number()];
/* clear the reduction count table and maximums */
for (i = 0; i < production.number(); i++)
reduction_count[i] = 0;
max_prod = -1;
max_red = 0;
/* walk down the row and look at the reduces */
for (i = 0; i < size(); i++)
if (under_term[i].kind() == parse_action.REDUCE)
{
/* count the reduce in the proper production slot and keep the
max up to date */
prod = ((reduce_action)under_term[i]).reduce_with().index();
reduction_count[prod]++;
if (reduction_count[prod] > max_red)
{
max_red = reduction_count[prod];
max_prod = prod;
}
}
/* record the max as the default (or -1 for not found) */
default_reduce = max_prod;
}
/*-----------------------------------------------------------*/
}
cup-0.11a+20060608/src/java_cup/anttask/ 0000755 0001750 0001750 00000000000 11075720102 017241 5 ustar twerner twerner cup-0.11a+20060608/src/java_cup/anttask/CUPTask.java 0000644 0001750 0001750 00000034577 10332672646 021414 0 ustar twerner twerner /**
* java_cup.anttask.CUPTask.java
*
* @author Michael Petter, 2003
*
* Ant-Task for CUP Parser Generator for Java
* -- tested with Ant 1.5.1;
* -- compiles with javac -classpath .:${ANT_HOME}/lib/ant.jar java_cup.anttask.CUPTask.java
* -- overrides org.apache.tools.ant.taskdefs.Java
* -- providing cool interface to CUP
* -- mapping all existing parameters to attributes
* -- trys to add new useful features to CUP, like
* - automatic package discovery
* - re-generate .java only when necessary
* - possibility to generate into a dest-directory
*
* my code is not perfect (in some cases it is pretty
* ugly :-) ), but i didn't encounter any major error
* until now
*/
package java_cup.anttask;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.Path;
import java.util.List;
import java.util.ArrayList;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.net.URL;
import java_cup.version;
public class CUPTask extends Task
{
private String srcfile=null;
private String parser=null;
private String _package=null;
private String symbols=null;
private String destdir=null;
private boolean _interface=false;
private boolean nonterms=false;
private String expect=null;
private boolean compact_red=false;
private boolean nowarn=false;
private boolean nosummary=false;
private boolean progress=false;
private boolean dump_grammar=false;
private boolean dump_states=false;
private boolean dump_tables=false;
private boolean dump=false;
private boolean time=false;
private boolean debug=false;
private boolean nopositions=false;
private boolean noscanner=false;
private boolean force=false;
private boolean quiet=false;
/**
* executes the task
* parses all attributes and validates options...
*
*/
public void execute() throws BuildException
{
List sc = new ArrayList(); // sc = simulated commandline
// here, we parse our elements
if (parser!=null) { sc.add("-parser"); sc.add(parser);}
else parser="parser"; // set the default name to check actuality
if (_package!=null){ sc.add("-package"); sc.add(_package); }
if (symbols!=null) { sc.add("-symbols"); sc.add(symbols); }
else symbols="sym";
if (expect!=null) { sc.add("-expect"); sc.add(expect); }
if (_interface) { sc.add("-interface"); }
if (nonterms) { sc.add("-nonterms"); }
if (compact_red) { sc.add("-compact_red"); }
if (nowarn) { sc.add("-nowarn"); }
if (nosummary) { sc.add("-nosummary");}
if (progress) { sc.add("-progress"); }
if (dump_grammar) { sc.add("-dump_grammar"); }
if (dump_states) { sc.add("-dump_states"); }
if (dump_tables) { sc.add("-dump_tables"); }
if (dump) { sc.add("-dump"); }
if (time) { sc.add("-time"); }
if (debug) { sc.add("-debug"); }
if (nopositions) { sc.add("-nopositions"); }
if (noscanner) { sc.add("-noscanner"); }
if (!quiet) log ("This is "+version.title_str);
if (!quiet) log ("Authors : "+version.author_str);
if (!quiet) log ("Bugreports to petter@cs.tum.edu");
// look for package name and add to destdir
String packagename = inspect(srcfile);
// now, that's sweet:
if (destdir==null) {
destdir=System.getProperty("user.dir");
if (!quiet) log("No destination directory specified; using working directory: "+destdir);
}
File dest = new File(destdir+packagename);
if (!(dest).exists()) {
if (!quiet) log("Destination directory didn't exist; creating new one: "+destdir+packagename);
dest.mkdirs();
force=true;
}
else {
if (force&& !quiet) { log("anyway, this generation will be processed because of option force set to \"true\""); }
else { if (!quiet) log("checking, whether this run is necessary"); }
// let's check, whether there exists any Parser fragment...
File parserfile = new File(destdir+packagename,parser+".java");
File symfile = new File(destdir+packagename,symbols+".java");
File cupfile = new File(srcfile);
if (!parserfile.exists() || !symfile.exists()) {
if (!quiet) log("Either Parserfile or Symbolfile didn't exist");
force=true;
}else { if (!quiet) log("Parserfile and symbolfile are existing"); }
if (parserfile.lastModified()<=cupfile.lastModified()) {
if (!quiet) log("Parserfile "+parserfile+" isn't actual");
force=true;
}else { if (!quiet) log("Parserfile "+parserfile+" is actual"); }
if (symfile.lastModified()<=cupfile.lastModified()) {
if (!quiet) log("Symbolfile "+symfile+" isn't actual");
force=true;
}else { if (!quiet) log("Symbolfile"+symfile+" is actual"); }
if (!force) {
if (!quiet) log("skipping generation of "+srcfile);
if (!quiet) log("use option force=\"true\" to override");
return;
}
}
sc.add("-destdir");
sc.add(dest.getAbsolutePath());
// also catch the not existing input file
if (srcfile==null) throw new BuildException("Input file needed: Specify
* [C ::= * X e Z, {d}]
* [X ::= * f, {e}]
*
* to indicate that it was currently looking for a C followed by a d (which
* would be reduced into a C, matching the first symbol in our production
* above), and the terminal f followed by e.
* [A ::= a b X * c, {d,e}]
* [B ::= a b X * Y, {a,b}]
*
* The full state would then be formed by "closing" this kernel set of
* items so that it included items that represented productions of things
* the parser was now looking for. In this case we would items
* corresponding to productions of Y, since various forms of Y are expected
* next when in this state (see lalr_item_set.compute_closure() for details
* on closure).
* [A ::= B * C d E , {a,b,c}]
*
* indicates that the parser is in the middle of parsing the production
* A ::= B C d E
*
* that B has already been parsed, and that we will expect to see a lookahead
* of either a, b, or c once the complete RHS of this production has been
* found.
![[CUP Logo Image]](manual_dateien/cup_logo.gif){kind=logo}
CUP User's Manual
Scott E. Hudson
Modified by Frank
Flannery, C. Scott Ananian,
Dan Wang with advice from
Andrew W. Appel
Graphics Visualization and Usability Center
Georgia Institute of Technology
Now actualized by Michael Petter
Last updated March 2006 (v0.11a)
Table of Contents
i. About CUP Version 0.10
Version
0.10 of CUP adds many new changes and features over the previous releases
of version 0.9. These changes attempt to make CUP more like its
predecessor, YACC. As a result, the old 0.9 parser specifications for CUP are
not compatible and a reading of appendix C of the new
manual will be necessary to write new specifications. The new version,
however, gives the user more power and options, making parser specifications
easier to write.
ii. About CUP Version 0.11
in version 0.11 the TUM team tries to continue the success story of CUP 0.10,
beginning with the introduction of generic data types for non-terminal symbols
as well as a modernisation of the user interface with a comfortable ANT plugin
structure.
1. Introduction and Example
This manual describes the basic operation and use of the
Java(tm)
Based Constructor of Useful Parsers (CUP for short).
CUP is a system for generating LALR parsers from simple specifications.
It serves the same role as the widely used program YACC
[1] and in fact offers most of the features of YACC.
However, CUP is written in Java, uses specifications including embedded
Java code, and produces parsers which are implemented in Java. expr_list ::= expr_list expr_part | expr_part
expr_part ::= expr ';'
expr ::= expr '+' expr | expr '-' expr | expr '*' expr
| expr '/' expr | expr '%' expr | '(' expr ')'
| '-' expr | number
To specify a parser based on this grammar, our first step is to identify and
name the set of terminal symbols that will appear on input, and the set of
non-terminal symbols. In this case, the non-terminals are:
expr_list, expr_part and expr .
For terminal names we might choose:
SEMI, PLUS, MINUS, TIMES, DIVIDE, MOD, NUMBER, LPAREN,
and RPAREN
The experienced user will note a problem with the above grammar. It is
ambiguous. An ambiguous grammar is a grammar which, given a certain
input, can reduce the parts of the input in two different ways such as
to give two different answers. Take the above grammar, for
example. given the following input:
3 + 4 * 6
The grammar can either evaluate the 3 + 4 and then multiply
seven by six, or it can evaluate 4 * 6 and then add three.
Older versions of CUP forced the user to write unambiguous grammars, but
now there is a construct allowing the user to specify precedences and
associativities for terminals. This means that the above ambiguous
grammar can be used, after specifying precedences and associativities.
There is more explanation later.
Based on these namings we can construct a small CUP specification
as follows:
// CUP specification for a simple expression evaluator (no actions)
import java_cup.runtime.*;
/* Preliminaries to set up and use the scanner. */
init with {: scanner.init(); :};
scan with {: return scanner.next_token(); :};
/* Terminals (tokens returned by the scanner). */
terminal SEMI, PLUS, MINUS, TIMES, DIVIDE, MOD;
terminal UMINUS, LPAREN, RPAREN;
terminal Integer NUMBER;
/* Non terminals */
non terminal expr_list, expr_part;
non terminal Integer expr, term, factor;
/* Precedences */
precedence left PLUS, MINUS;
precedence left TIMES, DIVIDE, MOD;
precedence left UMINUS;
/* The grammar */
expr_list ::= expr_list expr_part |
expr_part;
expr_part ::= expr SEMI;
expr ::= expr PLUS expr
| expr MINUS expr
| expr TIMES expr
| expr DIVIDE expr
| expr MOD expr
| MINUS expr %prec UMINUS
| LPAREN expr RPAREN
| NUMBER
;
We will consider each part of the specification syntax in detail later.
However, here we can quickly see that the specification contains four
main parts. The first part provides preliminary and miscellaneous declarations
to specify how the parser is to be generated, and supply parts of the
runtime code. In this case we indicate that the java_cup.runtime
classes should be imported, then supply a small bit of initialization code,
and some code for invoking the scanner to retrieve the next input token.
The second part of the specification declares terminals and non-terminals,
and associates object classes with each. In this case, the terminals
are declared as either with no type, or of type
Integer. The specified type of the
terminal or non-terminal is the type of the value of those terminals or
non-terminals. If no type is specified, the terminal or non-terminal
carries no value. Here, no type indicates that these
terminals and non-terminals hold no value.
The third part specifies the precedence and
associativity of terminals. The last precedence declaration give its
terminals the highest precedence. The final
part of the specification contains the grammar. java -jar java-cup-11a.jar parser.cup
In this case, the system will produce two Java source files containing
parts of the generated parser: sym.java and parser.java.
As you might expect, these two files contain declarations for the classes
sym and parser. The sym class contains a series of
constant declarations, one for each terminal symbol. This is typically used
by the scanner to refer to symbols (e.g. with code such as
"return new Symbol(sym.SEMI);" ). The parser class
implements the parser itself.
// CUP specification for a simple expression evaluator (w/ actions)
import java_cup.runtime.*;
/* Preliminaries to set up and use the scanner. */
init with {: scanner.init(); :};
scan with {: return scanner.next_token(); :};
/* Terminals (tokens returned by the scanner). */
terminal SEMI, PLUS, MINUS, TIMES, DIVIDE, MOD;
terminal UMINUS, LPAREN, RPAREN;
terminal Integer NUMBER;
/* Non-terminals */
non terminal expr_list, expr_part;
non terminal Integer expr;
/* Precedences */
precedence left PLUS, MINUS;
precedence left TIMES, DIVIDE, MOD;
precedence left UMINUS;
/* The grammar */
expr_list ::= expr_list expr_part
|
expr_part;
expr_part ::= expr:e
{: System.out.println("= " + e); :}
SEMI
;
expr ::= expr:e1 PLUS expr:e2
{: RESULT = new Integer(e1.intValue() + e2.intValue()); :}
|
expr:e1 MINUS expr:e2
{: RESULT = new Integer(e1.intValue() - e2.intValue()); :}
|
expr:e1 TIMES expr:e2
{: RESULT = new Integer(e1.intValue() * e2.intValue()); :}
|
expr:e1 DIVIDE expr:e2
{: RESULT = new Integer(e1.intValue() / e2.intValue()); :}
|
expr:e1 MOD expr:e2
{: RESULT = new Integer(e1.intValue() % e2.intValue()); :}
|
NUMBER:n
{: RESULT = n; :}
|
MINUS expr:e
{: RESULT = new Integer(0 - e.intValue()); :}
%prec UMINUS
|
LPAREN expr:e RPAREN
{: RESULT = e; :}
;
Here we can see several changes. Most importantly, code to be executed at
various points in the parse is included inside code strings delimited by
{: and :}. In addition, labels have been placed on various
symbols in the right hand side of productions. For example in:
expr:e1 PLUS expr:e2
{: RESULT = new Integer(e1.intValue() + e2.intValue()); :}
the first non-terminal expr has been labeled with e1, and
the second with e2. The left hand side value
of each production is always implicitly labeled as RESULT.Symbol
objects corresponding to terminals and non-terminals with no value
have a null value field.2. Specification Syntax
Now that we have seen a small example, we present a complete description of all
parts of a CUP specification. A specification has four sections with
a total of eight specific parts (however, most of these are optional).
A specification consists of:
Each of these parts must appear in the order presented here. (A complete
grammar for the specification language is given in
Appendix A.) The particulars of each part of
the specification are described in the subsections below.Package and Import Specifications
A specification begins with optional package and import
declarations. These have the same syntax, and play the same
role, as the package and import declarations found in a normal Java program.
A package declaration is of the form:
package name;
where name name is a Java package identifier, possibly in
several parts separated by ".". In general, CUP employs Java lexical
conventions. So for example, both styles of Java comments are supported,
and identifiers are constructed beginning with a letter, dollar
sign ($), or underscore (_), which can then be followed by zero or more
letters, numbers, dollar signs, and underscores. import package_name.class_name;
or
import package_name.*;
The package declaration indicates what package the sym and
parser classes that are generated by the system will be in.
Any import declarations that appear in the specification will also appear
in the source file for the parser class allowing various names from
that package to be used directly in user supplied action code.
User Code Components
Following the optional package and import declarations
are a series of optional declarations that allow user code to be included
as part of the generated parser (see Section 4 for a
full description of how the parser uses this code). As a part of the parser
file, a separate non-public class to contain all embedded user actions is
produced. The first action code declaration section allows code to
be included in this class. Routines and variables for use by the code
embedded in the grammar would normally be placed in this section (a typical
example might be symbol table manipulation routines). This declaration takes
the form:
action code {: ... :};
where {: ... :} is a code string whose contents will be placed
directly within the action class class declaration. parser code {: ... :};
Again, code from the code string is placed directly into the generated parser
class definition. init with {: ... :};
This declaration provides code that will be executed by the parser
before it asks for the first token. Typically, this is used to initialize
the scanner as well as various tables and other data structures that might
be needed by semantic actions. In this case, the code given in the code
string forms the body of a void method inside the parser
class. scan with {: ... :};
As with the init clause, the contents of the code string forms
the body of a method in the generated parser. However, in this case
the method returns an object of type java_cup.runtime.Symbol.
Consequently the code found in the scan with clause should
return such a value. See section 5 for
information on the default behavior if the scan with
section is omitted.Symbol Lists
Following user supplied code comes the first required part of the
specification: the symbol lists. These declarations are responsible
for naming and supplying a type for each terminal and non-terminal
symbol that appears in the grammar. As indicated above, each terminal
and non-terminal symbol is represented at runtime with a Symbol
object. In
the case of terminals, these are returned by the scanner and placed on
the parse stack. The lexer should put the value of the terminal in the
value instance variable.
In the case of non-terminals these replace a series
of Symbol objects on the parse stack whenever the right hand side of
some production is recognized. In order to tell the parser which object
types should be used for which symbol, terminal and
non terminal declarations are used. These take the forms:
terminal classname name1, name2, ...;
non terminal classname name1, name2, ...;
terminal name1, name2, ...;
and
non terminal name1, name2, ...;
where classname can be a multiple part name separated with
"."s. The
classname specified represents the type of the value of
that terminal or non-terminal. When accessing these values through
labels, the users uses the type declared. the classname
can be of any type. If no classname is given, then the
terminal or non-terminal holds no value. a label referring to such a
symbol with have a null value. As of CUP 0.10j, you may specify
non-terminals the declaration "nonterminal" (note, no
space) as well as the original "non terminal" spelling.Precedence and Associativity declarations
The third section, which is optional, specifies the precedences and
associativity of terminals. This is useful for parsing with ambiguous
grammars, as done in the example above. There are three type of
precedence/associativity declarations:
precedence left terminal[, terminal...];
precedence right terminal[, terminal...];
precedence nonassoc terminal[, terminal...];
The comma separated list indicates that those terminals should have the
associativity specified at that precedence level and the precedence of
that declaration. The order of precedence, from highest to lowest, is
bottom to top. Hence, this declares that multiplication and division have
higher precedence than addition and subtraction:
precedence left ADD, SUBTRACT;
precedence left TIMES, DIVIDE;
Precedence resolves shift reduce problems. For example, given the input
to the above example parser 3 + 4 * 8, the parser doesn't know
whether to reduce 3 + 4 or shift the '*' onto the stack.
However, since '*' has a higher precedence than '+', it will be shifted
and the multiplication will be performed before the addition.The Grammar
The final section of a CUP declaration provides the grammar. This
section optionally starts with a declaration of the form:
start with non-terminal;
This indicates which non-terminal is the start or goal
non-terminal for parsing. If a start non-terminal is not explicitly
declared, then the non-terminal on the left hand side of the first
production will be used. At the end of a successful parse, CUP returns
an object of type java_cup.runtime.Symbol. This
Symbol's value instance variable contains the final reduction
result.
precedence left PLUS, MINUS;
precedence left TIMES, DIVIDE, MOD;
precedence left UMINUS;
expr ::= MINUS expr:e
{: RESULT = new Integer(0 - e.intValue()); :}
%prec UMINUS
Here, there production is declared as having the precedence of UMINUS.
Hence, the parser can give the MINUS sign two different precedences,
depending on whether it is a unary minus or a subtraction operation.
3. Running CUP
3.1 Command line interface
As mentioned above, CUP is written in Java. To invoke it, one needs
to use the Java interpreter to invoke the static method
java_cup.Main(), passing an array of strings containing options.
Assuming a Unix machine, the simplest way to do this is typically to invoke it
directly from the command line with a command such as:
java -jar java-cup-11a.jar options inputfile
Once running, CUP expects to find a specification file on standard input
and produces two Java source files as output. Main.java and include:
interface
rather than as a class.
This option is typically used to work-around the java bytecode
limitations on table initialization code sizes. However, CUP
0.10h introduced a string-encoding for the parser tables which
is not subject to the standard method-size limitations.
Consequently, use of this option should no longer be required
for large grammars.
java_cup.runtime.Scanner. By default, the
generated parser refers to this interface, which means you cannot
use these parsers with CUP runtimes older than 0.10j. If your
parser does not use the new scanner integration features, then you
may specify the -noscanner option to suppress the
java_cup.runtime.Scanner references and allow
compatibility with old runtimes. Not many people should have reason
to do this.
-version flag will cause it
to print out the working version of CUP and halt. This allows
automated CUP version checking for Makefiles, install scripts and
other applications which may require it.
3.2 Integrating CUP into an ANT
script
To use cup in an ANT script, You have to add the following task definition to
Your build.xml file:
<taskdef name="cup"
classname="java_cup.anttask.CUPTask"
classpathref="cupclasspath"
/>
Now, You are ready to use Your new <cup/> task to generate own parsers
from within ANT. Such a generation statement could look like:
<target name="cup">
<cup srcfile="path/to/cupfile/Parser.cup"
destdir="path/to/javafiles"
interface="true"
/>
</target>
You can specify all commandline flags from chapter 4. Customizing the Parser
Each generated parser consists of three generated classes. The
sym class (which can be renamed using the -symbols
option) simply contains a series of int constants,
one for each terminal. Non-terminals are also included if the -nonterms
option is given. The source file for the parser class (which can
be renamed using the -parser option) actually contains two
class definitions, the public parser class that implements the
actual parser, and another non-public class (called CUP$action) which
encapsulates all user actions contained in the grammar, as well as code from
the action code declaration. In addition to user supplied code, this
class contains one method: CUP$do_action which consists of a large
switch statement for selecting and executing various fragments of user
supplied action code. In general, all names beginning with the prefix of
CUP$ are reserved for internal uses by CUP generated code.
(Note that the action and reduce-goto tables are not stored as simple arrays,
but use a compacted "list" structure to save a significant amount of space.
See comments the runtime system source code for details.)
Parsing itself is performed by the method public Symbol parse().
This method starts by getting references to each of the parse tables,
then initializes a CUP$action object (by calling
protected void init_actions()). Next it calls user_init(),
then fetches the first lookahead token with a call to scan().
Finally, it begins parsing. Parsing continues until done_parsing()
is called (this is done automatically, for example, when the parser
accepts). It then returns a Symbol with the value
instance variable containing the RESULT of the start production, or
null, if there is no value.getScanner().next_token().
/* create a parsing object */
parser parser_obj = new parser();
/* open input files, etc. here */
Symbol parse_tree = null;
try {
if (do_debug_parse)
parse_tree = parser_obj.debug_parse();
else
parse_tree = parser_obj.parse();
} catch (Exception e) {
/* do cleanup here - - possibly rethrow e */
} finally {
/* do close out here */
}
5. Scanner Interface
5.1 Basic Symbol management
In CUP 0.10j, scanner integration was improved according to
suggestions made by David MacMahon.
The changes make it easier to incorporate JLex and other
automatically-generated scanners into CUP parsers.java_cup.runtime.Scanner interface, defined as:
package java_cup.runtime;
public interface Scanner {
public Symbol next_token() throws java.lang.Exception;
}
java_cup.runtime.lr_parser class has two new
accessor methods, setScanner() and getScanner().
The default implementation of scan()
is:
public Symbol scan() throws java.lang.Exception {
return getScanner().next_token();
}
Scanner and calls setScanner() with it. In
most cases, then, the init with and scan
with directives may be omitted. You can simply create the
parser with a reference to the desired scanner:
/* create a parsing object */
parser parser_obj = new parser(new my_scanner());
or set the scanner after the parser is created:
/* create a parsing object */
parser parser_obj = new parser();
/* set the default scanner */
parser_obj.setScanner(new my_scanner());
scan() without first calling
setScanner(), a NullPointerException will be
thrown.%implements java_cup.runtime.Scanner
%function next_token
%type java_cup.runtime.Symbol
It is anticipated that the JLex directive %cup will
abbreviate the above three directive in the next version of JLex.
Invoking the parser with the JLex scanner is then simply:
parser parser_obj = new parser( new Yylex( some_InputStream_or_Reader));
%eofval{
return sym.EOF;
%eofval}
where sym is the name of the symbol class for your
generated parser.5.2 Advanced Symbol management
java_cup.runtime.SymbolFactory, and have CUP manage Your own type of
symbols. We've done that for You already in the pre-defined
java_cup.runtime.ComplexSymbolFactory, which provides support for
detailed location information in the symbol class. Just have a look at CUPs own
Lexer.jflex, which is already using the new feature.
SymbolFactory symbolFactory = new ComplexSymbolFactory();
MyParser parser = new MyParser(new Lexer(inputfile,symbolFactory),symbolFactory);
public Symbol newSymbol(String name, Symbol left, Symbol right, Object value){
ComplexSymbol sym = (ComplexSymbol)super.newSymbol(name,left,right,value);
SyntaxTreeNode node = (SyntaxTreeNode) value;
node.setLeft(left.getLeft());
node.setRight(right.getRight());
return sym;
}
6. Error Recovery
A final important aspect of building parsers with CUP is
support for syntactic error recovery. CUP uses the same
error recovery mechanisms as YACC. In particular, it supports
a special error symbol (denoted simply as error).
This symbol plays the role of a special non-terminal which, instead of
being defined by productions, instead matches an erroneous input
sequence. stmt ::= expr SEMI | while_stmt SEMI | if_stmt SEMI | ... |
error SEMI
;
This indicates that if none of the normal productions for stmt can
be matched by the input, then a syntax error should be declared, and recovery
should be made by skipping erroneous tokens (equivalent to matching and
replacing them with error) up to a point at which the parse can
be continued with a semicolon (and additional context that legally follows a
statement). An error is considered to be recovered from if and only if a
sufficient number of tokens past the error symbol can be successfully
parsed. (The number of tokens required is determined by the
error_sync_size() method of the parser and defaults to 3). 7. Conclusion
This manual has briefly described the CUP LALR parser generation system.
CUP is designed to fill the same role as the well known YACC parser
generator system, but is written in and operates entirely with Java code
rather than C or C++. Additional details on the operation of the system can
be found in the parser generator and runtime source code. See the CUP
home page below for access to the API documentation for the system and its
runtime.
Appendix A. Grammar for CUP Specification Files (0.10j)
java_cup_spec ::= package_spec import_list code_parts
symbol_list precedence_list start_spec
production_list
package_spec ::= PACKAGE multipart_id SEMI | empty
import_list ::= import_list import_spec | empty
import_spec ::= IMPORT import_id SEMI
code_part ::= action_code_part | parser_code_part |
init_code | scan_code
code_parts ::= code_parts code_part | empty
action_code_part ::= ACTION CODE CODE_STRING opt_semi
parser_code_part ::= PARSER CODE CODE_STRING opt_semi
init_code ::= INIT WITH CODE_STRING opt_semi
scan_code ::= SCAN WITH CODE_STRING opt_semi
symbol_list ::= symbol_list symbol | symbol
symbol ::= TERMINAL type_id declares_term |
NON TERMINAL type_id declares_non_term |
NONTERMINAL type_id declares_non_term |
TERMINAL declares_term |
NON TERMINAL declares_non_term |
NONTERMIANL declared_non_term
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
declares_term ::= term_name_list SEMI
declares_non_term ::= non_term_name_list SEMI
precedence_list ::= precedence_l | empty
precedence_l ::= precedence_l preced + preced;
preced ::= PRECEDENCE LEFT terminal_list SEMI
| PRECEDENCE RIGHT terminal_list SEMI
| PRECEDENCE NONASSOC terminal_list SEMI
terminal_list ::= terminal_list COMMA terminal_id | terminal_id
start_spec ::= START WITH nt_id SEMI | empty
production_list ::= production_list production | production
production ::= nt_id COLON_COLON_EQUALS rhs_list SEMI
rhs_list ::= rhs_list BAR rhs | rhs
rhs ::= prod_part_list PERCENT_PREC term_id |
prod_part_list
prod_part_list ::= prod_part_list prod_part | empty
prod_part ::= symbol_id opt_label | CODE_STRING
opt_label ::= COLON label_id | empty
multipart_id ::= multipart_id DOT ID | ID
import_id ::= multipart_id DOT STAR | multipart_id
type_id ::= multipart_id
terminal_id ::= term_id
term_id ::= symbol_id
new_term_id ::= ID
new_non_term_id ::= ID
nt_id ::= ID
symbol_id ::= ID
label_id ::= ID
opt_semi ::= SEMI | empty
Appendix B. A Very Simple Example Scanner
// Simple Example Scanner Class
import java_cup.runtime.*;
import sym;
public class scanner {
/* single lookahead character */
protected static int next_char;
// since cup v11 we use SymbolFactories rather than Symbols
private SymbolFactory sf = new DefaultSymbolFactory();
/* advance input by one character */
protected static void advance()
throws java.io.IOException
{ next_char = System.in.read(); }
/* initialize the scanner */
public static void init()
throws java.io.IOException
{ advance(); }
/* recognize and return the next complete token */
public static Symbol next_token()
throws java.io.IOException
{
for (;;)
switch (next_char)
{
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* parse a decimal integer */
int i_val = 0;
do {
i_val = i_val * 10 + (next_char - '0');
advance();
} while (next_char >= '0' && next_char <= '9');
return sf.newSymbol("NUMBER",sym.NUMBER, new Integer(i_val));
case ';': advance(); return sf.newSymbol("SEMI",sym.SEMI);
case '+': advance(); return sf.newSymbol("PLUS",sym.PLUS);
case '-': advance(); return sf.newSymbol("MINUS",sym.MINUS);
case '*': advance(); return sf.newSymbol("TIMES",sym.TIMES);
case '/': advance(); return sf.newSymbol("DIVIDE",sym.DIVIDE);
case '%': advance(); return sf.newSymbol("MOD",sym.MOD);
case '(': advance(); return sf.newSymbol("LPAREN",sym.LPAREN);
case ')': advance(); return sf.newSymbol("RPAREN",sym.RPAREN);
case -1: return return sf.newSymbol("EOF",sym.EOF);
default:
/* in this simple scanner we just ignore everything else */
advance();
break;
}
}
};
Appendix C: Incompatibilites between CUP 0.9 and CUP 0.10
CUP version 0.10a is a major overhaul of CUP. The changes are severe,
meaning no backwards compatibility to older versions.
The changes consist of:
Lexical Interface
CUP now interfaces with the lexer in a completely different
manner. In the previous releases, a new class was used for every
distinct type of terminal. This release, however, uses only one class:
The Symbol class. The Symbol class has three instance
variables which
are significant to the parser when passing information from the lexer.
The first is the value instance variable. This variable
contains the
value of that terminal. It is of the type declared as the terminal type
in the parser specification file. The second two are the instance
variables left and right. They should be filled with
the int value of
where in the input file, character-wise, that terminal was found.Terminal/Non-Terminal Declarations
Terminal and non-terminal declarations now can be declared in two
different ways to indicate the values of the terminals or
non-terminals. The previous declarations of the form
terminal classname terminal [, terminal ...];
still works. The classname, however indicates the type of the value of
the terminal or non-terminal, and does not indicate the type of object
placed on the parse stack.
A declaration, such as:
terminal terminal [, terminal ...];
indicates the terminals in the list hold no value.Label References
Label references do not refer to the object on the parse stack, as in
the old CUP, but rather to the value of the value
instance variable of
the Symbol that represents that terminal or non-terminal. Hence,
references to terminal and non-terminal values is direct, as opposed to
the old CUP, where the labels referred to objects containing the value
of the terminal or non-terminal.RESULT Value
The RESULT variable refers directly to the value of the
non-terminal
to which a rule reduces, rather than to the object on the parse stack.
Hence, RESULT is of the same type the non-terminal to which
it reduces,
as declared in the non-terminal declaration. Again, the reference is
direct, rather than to something that will contain the data.Position Propagation
For every label, two more variables are declared, which are the label
plus left or the label plus right. These correspond
to the left and
right locations in the input stream to which that terminal or
non-terminal came from. These values are propagated from the input
terminals, so that the starting non-terminal should have a left value of
0 and a right value of the location of the last character read.Return Value
A call to parse() or debug_parse() returns a
Symbol. This Symbol is the start non-terminal, so the value
instance variable contains the final RESULT assignment.
Precedence
CUP now has precedenced terminals. a new declaration section,
occurring between the terminal and non-terminal declarations and the
grammar specifies the precedence and associativity of rules. The
declarations are of the form:
precedence {left| right | nonassoc} terminal[, terminal ...];
...
The terminals are assigned a precedence, where terminals on the same
line have equal precedences, and the precedence declarations farther
down the list of precedence declarations have higher precedence.
left, right and nonassoc specify the associativity
of these terminals. left
associativity corresponds to a reduce on conflict, right to a shift on
conflict, and nonassoc to an error on conflict. Hence, ambiguous
grammars may now be used.Contextual Precedence
Finally the new CUP adds contextual precedence. A production may be
declare as followed:
lhs ::= {right hand side list of terminals, non-terminals and actions}
%prec {terminal};
this production would then have a precedence equal to the terminal
specified after the %prec. Hence, shift/reduce conflicts can be
contextually resolved. Note that the %prec terminal
part comes after all actions strings. It does not come before the
last action string.
Frank Flannery
Department of Computer Science
Princeton University
Appendix D: Bugs
In this version of CUP it's difficult for the semantic action phrases (Java code attached
to productions) to access the report_error method and other similar methods and
objects defined in the parser code directive.
parser.report_error(message,info);
x = parser.mydata;
Appendix E: Change log
java_cup.runtime.Scanner interface.
Java and HotJava are
trademarks of Sun Microsystems, Inc.,
and refer to Sun's Java programming language and HotJava browser
technologies.
CUP is not sponsored by or affiliated with Sun Microsystems, Inc.
cup-0.11a+20060608/build.xml 0000644 0001750 0001750 00000005045 10412217534 015046 0 ustar twerner twerner