001: package java_cup;
002:
003: /** This abstract class serves as the base class for grammar symbols (i.e.,
004: * both terminals and non-terminals). Each symbol has a name string, and
005: * a string giving the type of object that the symbol will be represented by
006: * on the runtime parse stack. In addition, each symbol maintains a use count
007: * in order to detect symbols that are declared but never used, and an index
008: * number that indicates where it appears in parse tables (index numbers are
009: * unique within terminals or non terminals, but not across both).
010: *
011: * @see java_cup.terminal
012: * @see java_cup.non_terminal
013: * @version last updated: 7/3/96
014: * @author Frank Flannery
015: */
016: public abstract class symbol {
017: /*-----------------------------------------------------------*/
018: /*--- Constructor(s) ----------------------------------------*/
019: /*-----------------------------------------------------------*/
020:
021: /** Full constructor.
022: * @param nm the name of the symbol.
023: * @param tp a string with the type name.
024: */
025: public symbol(String nm, String tp) {
026: /* sanity check */
027: if (nm == null)
028: nm = "";
029:
030: /* apply default if no type given */
031: if (tp == null)
032: tp = "Object";
033:
034: _name = nm;
035: _stack_type = tp;
036: }
037:
038: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
039:
040: /** Constructor with default type.
041: * @param nm the name of the symbol.
042: */
043: public symbol(String nm) {
044: this (nm, null);
045: }
046:
047: /*-----------------------------------------------------------*/
048: /*--- (Access to) Instance Variables ------------------------*/
049: /*-----------------------------------------------------------*/
050:
051: /** String for the human readable name of the symbol. */
052: protected String _name;
053:
054: /** String for the human readable name of the symbol. */
055: public String name() {
056: return _name;
057: }
058:
059: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
060:
061: /** String for the type of object used for the symbol on the parse stack. */
062: protected String _stack_type;
063:
064: /** String for the type of object used for the symbol on the parse stack. */
065: public String stack_type() {
066: return _stack_type;
067: }
068:
069: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
070:
071: /** Count of how many times the symbol appears in productions. */
072: protected int _use_count = 0;
073:
074: /** Count of how many times the symbol appears in productions. */
075: public int use_count() {
076: return _use_count;
077: }
078:
079: /** Increment the use count. */
080: public void note_use() {
081: _use_count++;
082: }
083:
084: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
085:
086: /** Index of this symbol (terminal or non terminal) in the parse tables.
087: * Note: indexes are unique among terminals and unique among non terminals,
088: * however, a terminal may have the same index as a non-terminal, etc.
089: */
090: protected int _index;
091:
092: /** Index of this symbol (terminal or non terminal) in the parse tables.
093: * Note: indexes are unique among terminals and unique among non terminals,
094: * however, a terminal may have the same index as a non-terminal, etc.
095: */
096: public int index() {
097: return _index;
098: }
099:
100: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
101:
102: /** Indicate if this is a non-terminal. Here in the base class we
103: * don't know, so this is abstract.
104: */
105: public abstract boolean is_non_term();
106:
107: /*. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .*/
108:
109: /** Convert to a string. */
110: public String toString() {
111: return name();
112: }
113:
114: /*-----------------------------------------------------------*/
115:
116: }
|