//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
package hlt.language.syntax;
import java.util.HashMap;
import java.util.Iterator;
import hlt.language.util.Comparable;
import hlt.language.util.ArrayList;
import hlt.language.util.SetOf;
import hlt.language.tools.Misc;
/**
* This is the class of nonterminal symbols used by the grammar
* at parser construction time.
*
* @see GrammarSymbol
*
* @version Last modified on Fri Apr 13 20:05:47 2012 by hak
* @author Hassan Aït-Kaci
* @copyright © by the author
*/
public class NonTerminal extends GrammarSymbol
{
NonTerminal (String name)
{
super(name,grammar.nonterminals,grammar.ncount++);
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
/**
* The rules for this non-terminal
*/
ArrayList rules = new ArrayList();
/**
* When true, this nonterminal is a dynamic operator category.
*/
boolean isOperator = false;
/**
* The class name of a parse stack node for this symbol
* (if != null, the name of a subclass of ParseNode).
*/
public String nodeType = null;
/**
* Set of nonterminals N such that this L* N.
*/
SetOf LSet;
/**
* Table of nonterminals and rules N, N -> this ...
* such that N L this.
*/
HashMap LTable;
/**
* Returns the appropriate set of rules from LTable
* for the given nonterminal, or null if none exists.
*/
final SetOf getLRules (NonTerminal n)
{
return (SetOf)LTable.get(n);
}
/**
* Add the given rule for the given nonterminal in this
* symbol's LTable.
*/
final void addLRule (NonTerminal n, Rule r)
{
if (LTable == null) LTable = new HashMap();
SetOf rules = getLRules(n);
if (rules == null)
{
rules = new SetOf(grammar.rules);
LTable.put(n,rules);
}
rules.add(r.index());
}
/**
* This table is similar to the LTable, but the entry keys
* are nonterminals that are L*-related to this one. Also,
* unlike in LTable, the links for pathTable are
* kept in the right direction. A key in N.pathTable is a
* nonterminal P such that N L* P and its entry is an
* ArrayList of RulePath objects. Namely, let N be this
* node and P be a node such that N L* P. Each path
* between N and P is characterized by the sequence
* of rules leading from N to P. Since there may be
* several differents paths between N and P, each
* such path must be recorded in an ArrayList which the stored as
* N.pathTable(P).
*/
HashMap pathTable;
/**
* For convenient iteration over all paths starting at this nonterminal
* we also maintain this ArrayList.
*/
ArrayList paths;
/**
* This initializes the path structures, creates an empty path
* from this nonterminal to itself, and records it where appropriate.
*/
final void initPaths ()
{
paths = new ArrayList();
pathTable = new HashMap();
pathTable.put(this, new Paths(new RulePath(this)));
}
/**
* Adds the given path to the paths starting at this nonterminal if
* it is not already there. Returns true if the given path
* contributes to the FIRST set of the paths between this nonterminal
* and the end of the path.
*/
final boolean addPath (RulePath path)
{
Paths paths = (Paths)pathTable.get(path.end);
if (paths == null)
{
pathTable.put(path.end,new Paths(path));
return true;
}
return paths.add(path);
}
/**
* Returns the FIRST set of terminals in PATH(this,n).
* NB: By construction this will always be well-defined
* by the time it is called because all nonterminals
* have their paths initialized when the grammar builds
* its L-graph. This cannot be done in the constructor
* because then the grammar may not have been read all
* its data yet.
*/
final SetOf path (NonTerminal n)
{
return ((Paths)pathTable.get(n)).first;
}
/**
* Returns true iff this.path(n) derives EMPTY.
*/
final boolean pathIsNullable (NonTerminal n)
{
return ((Paths)pathTable.get(n)).isNullable;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
private boolean isStart = false;
final boolean isStart ()
{
return isStart;
}
final void makeStart ()
{
isStart = true;
}
private boolean isRoot = false;
final boolean isRoot ()
{
return isRoot;
}
final void makeRoot ()
{
isRoot = true;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
final String label ()
{
String label = ""+Misc.htmlString(name)+"";
return isStart ? ""+label+"" : label;
}
final String ruleLabel (Rule r)
{
int index = 1;
String head = Misc.htmlString(name);
for (Iterator rls=rules.iterator(); rls.hasNext();)
{
if (r == rls.next())
return ""+head+"_"+index+"";
index++;
}
return head;
}
final void link (Rule rule)
{
if (isSpecial()
|| rule.sequence[0].isSpecial()
|| this == rule.sequence[0])
return;
if (ruleOccurrences == null)
ruleOccurrences = new SetOf(grammar.rules);
ruleOccurrences.add(rule);
}
final String refName ()
{
if (refName == null)
refName = Options.getGrammarPrefix()
+ "_NT_"+Misc.zeroPaddedString(index(),
Misc.numWidth(grammar.ncount));
return refName;
}
public boolean equals (Object other)
{
if (!(other instanceof NonTerminal)) return false;
NonTerminal n = (NonTerminal)other;
return (index() == n.index());
}
public final boolean lessThan (Comparable other)
{
if (grammar.RULE_ORDER_MODE)
{
if (!(other instanceof NonTerminal))
return false;
NonTerminal n = (NonTerminal)other;
if (rules.isEmpty() || n.rules.isEmpty())
return false;
return ((Rule)rules.get(0)).index() < ((Rule)n.rules.get(0)).index();
}
return super.lessThan(other);
}
}