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); } } }