protected virtual void GetPreOrderedGrammarListCore(IList <Grammar> grammars)
{
grammars.Add(this.grammar);
for (int i = 0; children != null && i < children.Count; i++)
{
CompositeGrammarTree child = children[i];
child.GetPreOrderedGrammarListCore(grammars);
}
}
public virtual Grammar GetGrammar(string grammarName)
{
CompositeGrammarTree t = delegateGrammarTreeRoot.FindNode(grammarName);
if (t != null)
{
return(t.grammar);
}
return(null);
}
/** Find a rule by looking in current grammar then down towards the
* delegate grammars.
*/
public virtual Rule GetRule(string ruleName)
{
Rule r = grammar.GetLocallyDefinedRule(ruleName);
for (int i = 0; r == null && children != null && i < children.Count; i++)
{
CompositeGrammarTree child = children[i];
r = child.GetRule(ruleName);
}
return(r);
}
/** Get list of all delegates from all grammars in the delegate subtree of g.
* The grammars are in delegation tree preorder. Don't include g itself
* in list as it is not a delegate of itself.
*/
public virtual IList <Grammar> GetDelegates(Grammar g)
{
CompositeGrammarTree t = delegateGrammarTreeRoot.FindNode(g);
if (t == null)
{
return(null); // no delegates
}
IList <Grammar> grammars = t.GetPostOrderedGrammarList();
grammars.RemoveAt(grammars.Count - 1); // remove g (last one)
return(grammars);
}
public virtual void AddChild(CompositeGrammarTree t)
{
//Console.Out.WriteLine("add "+t.toStringTree()+" as child to "+this.toStringTree());
if (t == null)
{
return; // do nothing upon addChild(null)
}
if (children == null)
{
children = new List <CompositeGrammarTree>();
}
children.Add(t);
t.parent = this;
}
/** Get parent of this grammar */
public virtual Grammar GetDelegator(Grammar g)
{
CompositeGrammarTree me = delegateGrammarTreeRoot.FindNode(g);
if (me == null)
{
return(null); // not found
}
if (me.parent != null)
{
return(me.parent.grammar);
}
return(null);
}
public virtual void AddChild( CompositeGrammarTree t )
{
//Console.Out.WriteLine("add "+t.toStringTree()+" as child to "+this.toStringTree());
if ( t == null )
{
return; // do nothing upon addChild(null)
}
if ( children == null )
{
children = new List<CompositeGrammarTree>();
}
children.Add( t );
t.parent = this;
}
public virtual void TrimLexerImportsIntoCombined()
{
CompositeGrammarTree p = this;
if (p.grammar.type == GrammarType.Lexer && p.parent != null &&
p.parent.grammar.type == GrammarType.Combined)
{
//System.Console.Out.WriteLine( "wacking " + p.grammar.name + " from " + p.parent.grammar.name );
p.parent.children.Remove(this);
}
for (int i = 0; children != null && i < children.Count; i++)
{
CompositeGrammarTree child = children[i];
child.TrimLexerImportsIntoCombined();
}
}
/** Return list of delegate grammars from root down to g.
* Order is root, ..., g.parent. (g not included).
*/
public virtual IList <Grammar> GetDelegators(Grammar g)
{
if (g == delegateGrammarTreeRoot.grammar)
{
return(null);
}
List <Grammar> grammars = new List <Grammar>();
CompositeGrammarTree t = delegateGrammarTreeRoot.FindNode(g);
// walk backwards to root, collecting grammars
CompositeGrammarTree p = t.parent;
while (p != null)
{
grammars.Insert(0, p.grammar); // add to head so in order later
p = p.parent;
}
return(grammars);
}
public virtual IList <Grammar> GetDirectDelegates(Grammar g)
{
CompositeGrammarTree t = delegateGrammarTreeRoot.FindNode(g);
IList <CompositeGrammarTree> children = t.children;
if (children == null)
{
return(null);
}
IList <Grammar> grammars = new List <Grammar>();
for (int i = 0; children != null && i < children.Count; i++)
{
CompositeGrammarTree child = (CompositeGrammarTree)children[i];
grammars.Add(child.grammar);
}
return(grammars);
}
public virtual CompositeGrammarTree FindNode(string grammarName)
{
if (grammarName == null)
{
return(null);
}
if (grammarName.Equals(this.grammar.name))
{
return(this);
}
CompositeGrammarTree n = null;
for (int i = 0; n == null && children != null && i < children.Count; i++)
{
CompositeGrammarTree child = children[i];
n = child.FindNode(grammarName);
}
return(n);
}
public virtual CompositeGrammarTree FindNode(Grammar g)
{
if (g == null)
{
return(null);
}
if (this.grammar == g)
{
return(this);
}
CompositeGrammarTree n = null;
for (int i = 0; n == null && children != null && i < children.Count; i++)
{
CompositeGrammarTree child = children[i];
n = child.FindNode(g);
}
return(n);
}
/** Get all rule definitions from all direct/indirect delegate grammars
* of g.
*/
public virtual HashSet <Rule> GetAllImportedRules(Grammar g)
{
HashSet <string> ruleNames = new HashSet <string>();
HashSet <Rule> rules = new HashSet <Rule>();
CompositeGrammarTree subtreeRoot = delegateGrammarTreeRoot.FindNode(g);
IList <Grammar> grammars = subtreeRoot.GetPreOrderedGrammarList();
// walk all grammars preorder, priority given to grammar listed first.
foreach (Grammar grammar in grammars)
{
// for each rule in grammar, add to rules if no rule with that
// name as been seen. (can't use removeAll; wrong hashcode/equals on Rule)
foreach (Rule r in grammar.Rules)
{
if (!ruleNames.Contains(r.Name))
{
ruleNames.Add(r.Name); // track that we've seen this
rules.Add(r);
}
}
}
return(rules);
}
public virtual HashSet <Rule> _minimizeRuleSet(CompositeGrammarTree p)
{
var refs = new HashSet <Rule>();
foreach (GrammarAST refAST in p.grammar.ruleRefs)
{
System.Console.Out.WriteLine("ref " + refAST.Text + ": " + refAST.NFAStartState +
" enclosing rule: " + refAST.NFAStartState.enclosingRule +
" invoking rule: " + ((NFAState)refAST.NFAStartState.transition[0].target).enclosingRule);
refs.Add(((NFAState)refAST.NFAStartState.transition[0].target).enclosingRule);
}
if (p.children != null)
{
foreach (CompositeGrammarTree @delegate in p.children)
{
var delegateRuleRefs = _minimizeRuleSet(@delegate);
refs.addAll(delegateRuleRefs);
}
}
return(refs);
}
protected virtual void MinimizeRuleSetCore(HashSet <string> ruleDefs,
CompositeGrammarTree p)
{
HashSet <string> localRuleDefs = new HashSet <string>();
HashSet <string> overrides = new HashSet <string>();
// compute set of non-overridden rules for this delegate
foreach (Rule r in p.grammar.Rules)
{
if (!ruleDefs.Contains(r.Name))
{
localRuleDefs.Add(r.Name);
}
else if (!r.Name.Equals(Grammar.ArtificialTokensRuleName))
{
// record any overridden rule 'cept tokens rule
overrides.Add(r.Name);
}
}
//System.Console.Out.WriteLine( "rule defs for " + p.grammar.name + ": " + localRuleDefs );
//System.Console.Out.WriteLine( "overridden rule for " + p.grammar.name + ": " + overrides );
p.grammar.overriddenRules = overrides;
// make set of all rules defined thus far walking delegation tree.
// the same rule in two delegates resolves in favor of first found
// in tree therefore second must not be included
ruleDefs.addAll(localRuleDefs);
// pass larger set of defined rules to delegates
if (p.children != null)
{
foreach (CompositeGrammarTree @delegate in p.children)
{
MinimizeRuleSetCore(ruleDefs, @delegate);
}
}
}
protected virtual void MinimizeRuleSetCore( HashSet<string> ruleDefs,
CompositeGrammarTree p )
{
HashSet<string> localRuleDefs = new HashSet<string>();
HashSet<string> overrides = new HashSet<string>();
// compute set of non-overridden rules for this delegate
foreach ( Rule r in p.Grammar.Rules )
{
if ( !ruleDefs.Contains( r.Name ) )
{
localRuleDefs.Add( r.Name );
}
else if ( !r.Name.Equals( Grammar.ArtificialTokensRuleName ) )
{
// record any overridden rule 'cept tokens rule
overrides.Add( r.Name );
}
}
//System.Console.Out.WriteLine( "rule defs for " + p.grammar.name + ": " + localRuleDefs );
//System.Console.Out.WriteLine( "overridden rule for " + p.grammar.name + ": " + overrides );
p.Grammar.overriddenRules = overrides;
// make set of all rules defined thus far walking delegation tree.
// the same rule in two delegates resolves in favor of first found
// in tree therefore second must not be included
ruleDefs.UnionWith( localRuleDefs );
// pass larger set of defined rules to delegates
if ( p.children != null )
{
foreach ( CompositeGrammarTree @delegate in p.children )
{
MinimizeRuleSetCore( ruleDefs, @delegate );
}
}
}
public virtual void SetDelegationRoot( Grammar root )
{
delegateGrammarTreeRoot = new CompositeGrammarTree( root );
root.compositeTreeNode = delegateGrammarTreeRoot;
}
public virtual HashSet<Rule> _minimizeRuleSet( CompositeGrammarTree p )
{
var refs = new HashSet<Rule>();
foreach ( GrammarAST refAST in p.grammar.ruleRefs )
{
System.Console.Out.WriteLine( "ref " + refAST.Text + ": " + refAST.NFAStartState +
" enclosing rule: " + refAST.NFAStartState.enclosingRule +
" invoking rule: " + ( (NFAState)refAST.NFAStartState.transition[0].target ).enclosingRule );
refs.Add( ( (NFAState)refAST.NFAStartState.transition[0].target ).enclosingRule );
}
if ( p.children != null )
{
foreach ( CompositeGrammarTree @delegate in p.children )
{
var delegateRuleRefs = _minimizeRuleSet( @delegate );
refs.addAll( delegateRuleRefs );
}
}
return refs;
}
public virtual void SetDelegationRoot(Grammar root)
{
delegateGrammarTreeRoot = new CompositeGrammarTree(root);
root.compositeTreeNode = delegateGrammarTreeRoot;
}
public virtual void _minimizeRuleSet( HashSet<string> ruleDefs, HashSet<string> ruleRefs, CompositeGrammarTree p )
{
var localRuleDefs = new HashSet<string>();
foreach ( Rule r in p.grammar.Rules )
{
if ( !ruleDefs.contains( r.name ) )
{
localRuleDefs.add( r.name );
ruleDefs.add( r.name );
}
}
System.Console.Out.WriteLine( "rule defs for " + p.grammar.name + ": " + localRuleDefs );
// remove locally-defined rules not in ref set
// find intersection of local rules and references from delegator
// that is set of rules needed by delegator
HashSet<string> localRuleDefsSatisfyingRefsFromBelow = new HashSet<string>();
foreach ( string r in ruleRefs )
{
if ( localRuleDefs.contains( r ) )
{
localRuleDefsSatisfyingRefsFromBelow.add( r );
}
}
// now get list of refs from localRuleDefsSatisfyingRefsFromBelow.
// Those rules are also allowed in this delegate
foreach ( GrammarAST refAST in p.grammar.ruleRefs )
{
if ( localRuleDefsSatisfyingRefsFromBelow.contains( refAST.enclosingRuleName ) )
{
// found rule ref within needed rule
}
}
// remove rule refs not in the new rule def set
// walk all children, adding rules not already defined
if ( p.children != null )
{
foreach ( CompositeGrammarTree @delegate in p.children )
{
_minimizeRuleSet( ruleDefs, ruleRefs, @delegate );
}
}
}
public virtual void _minimizeRuleSet(HashSet <string> ruleDefs, HashSet <string> ruleRefs, CompositeGrammarTree p)
{
var localRuleDefs = new HashSet <string>();
foreach (Rule r in p.grammar.Rules)
{
if (!ruleDefs.contains(r.name))
{
localRuleDefs.add(r.name);
ruleDefs.add(r.name);
}
}
System.Console.Out.WriteLine("rule defs for " + p.grammar.name + ": " + localRuleDefs);
// remove locally-defined rules not in ref set
// find intersection of local rules and references from delegator
// that is set of rules needed by delegator
HashSet <string> localRuleDefsSatisfyingRefsFromBelow = new HashSet <string>();
foreach (string r in ruleRefs)
{
if (localRuleDefs.contains(r))
{
localRuleDefsSatisfyingRefsFromBelow.add(r);
}
}
// now get list of refs from localRuleDefsSatisfyingRefsFromBelow.
// Those rules are also allowed in this delegate
foreach (GrammarAST refAST in p.grammar.ruleRefs)
{
if (localRuleDefsSatisfyingRefsFromBelow.contains(refAST.enclosingRuleName))
{
// found rule ref within needed rule
}
}
// remove rule refs not in the new rule def set
// walk all children, adding rules not already defined
if (p.children != null)
{
foreach (CompositeGrammarTree @delegate in p.children)
{
_minimizeRuleSet(ruleDefs, ruleRefs, @delegate);
}
}
}
