public Grammar removeERules(Grammar g) { Grammar g1 = new Grammar(); Grammar tmpGrammar = removeNonterminalProdusesOnlyERules(g); List<Rule> newRules = new List<Rule>(); _nonterminalSymbolStringMap = new Dictionary<string, List<Symbol>>(); _nonterminalsForGrammarWithoutERules = new List<Nonterminal>(); Queue<Nonterminal> newNonterminals = new Queue<Nonterminal>(); List<Symbol> symStr = new List<Symbol>(); symStr.Add(tmpGrammar.DistinguishedSymbol); newNonterminals.Enqueue(symbolStringToNonterminal(symStr)); g1.Terminals = new List<Terminal>(tmpGrammar.Terminals); g1.DistinguishedSymbol = new Nonterminal(newNonterminals.Peek()); _nonterminalsForGrammarWithoutERules.Add(g1.DistinguishedSymbol); while (newNonterminals.Count > 0) { Nonterminal curNonterminal = newNonterminals.Dequeue(); if (!g1.Nonterminals.Exists(A => A.Sym == curNonterminal.Sym)) { g1.Nonterminals.Add(curNonterminal); g1.Rules.AddRange(buildRulesForNonterminal(curNonterminal, tmpGrammar)); foreach (Nonterminal nt in _nonterminalsForGrammarWithoutERules) newNonterminals.Enqueue(nt); } } return g1; }
public Grammar(Grammar g) { _nonterminals = new List<Nonterminal>(g.Nonterminals); _terminals = new List<Terminal>(g.Terminals); _rules = new List<Rule>(g.Rules); _distinguishedSymbol = new Nonterminal(g.DistinguishedSymbol); _vanishingSymbols = new List<Nonterminal>(g.VanishingSymbols); }
public Grammar transformToNonnullableGrammar(Grammar g) { List<Nonterminal> nonterminals = bulidNonterminalsForNonnullableGrammar(g); Nonterminal distinguishedSymbol = distinguishedSymbolForNonnullableGrammar(g); List<Rule> rules = buildRulesForNonnullableGrammar(g); Grammar g1 = new Grammar(nonterminals, g.Terminals, rules, distinguishedSymbol); g1.removeUnreachableSymbols(); g1.findVanishingSymbols(); return g1; }
private void breakRuleForNonnullableGrammar(Rule r, Grammar g, out List<Nonterminal> firstVanishing, out List<Symbol> rest) { firstVanishing = new List<Nonterminal>(); rest = new List<Symbol>(); foreach (Symbol s in r.Right) { if (rest.Count > 0) rest.Add(s); else if (g.isVanishingSymbol(s)) firstVanishing.Add((Nonterminal)s); else rest.Add(s); } }
public override Grammar read(string fname) { Grammar g = new Grammar(); StreamReader sr = new StreamReader(fname); string line; // читаем нетерминалы List<string> nonTerms = readBlock(sr); nonTerms.ForEach(s => g.Nonterminals.Add(new Nonterminal(s))); // читаем терминалы List<string> terms = readBlock(sr); terms.ForEach(s => g.Terminals.Add(new Terminal(s))); // читаем правила List<string> rules = readBlock(sr); g.Rules = parseRules(rules, terms, nonTerms); // читаем аксиому string axiom = readAxiom(sr); if (!nonTerms.Contains(axiom)) throw new FormatException("Некорректный формат файла."); g.DistinguishedSymbol = new Nonterminal(axiom); sr.Close(); g.findVanishingSymbols(); return g; }
public void transformToNonnullableGrammar() { GrammarTransformer gt = new GrammarTransformer(); _grammar = gt.transformToNonnullableGrammar(_grammar); }
public void removeERules() { GrammarTransformer gt = new GrammarTransformer(); _grammar = gt.removeERules(_grammar); }
public void loadGrammar(string fname) { TextGrammarReader gr = new TextGrammarReader(); _grammar = gr.read(fname); }
public Dispatcher() { _grammar = new Grammar(); }
private List<Rule> buildRulesForNonnullableGrammar(Grammar g) { List<Rule> rules = new List<Rule>(); List<Rule> newRules = new List<Rule>(); foreach (Rule r in g.Rules) { if (r.isERule()) rules.Add(r); else { newRules.Clear(); List<Nonterminal> firstVanishing; List<Symbol> rest; breakRuleForNonnullableGrammar(r, g, out firstVanishing, out rest); if (firstVanishing.Count > 0) newRules.AddRange(createNewRulesForFisrtVanishing(r, firstVanishing, rest)); if (rest.Count > 0) newRules.Add(createRuleWithNoFisrtVanishing(r, rest)); if (g.isVanishingSymbol(r.Left)) newRules.AddRange(createRulesForLeftVanishing(newRules, r.Left)); rules.AddRange(newRules); } } return rules; }
private Grammar removeNonterminalProdusesOnlyERules(Grammar g) { Grammar newG = new Grammar(g); List<Nonterminal> toBeRemoved = new List<Nonterminal>(); foreach (Rule r in newG.Rules) if (r.isERule() && !newG.Rules.Exists(rule => rule.Left.Sym == r.Left.Sym)) toBeRemoved.Add(r.Left); foreach (Rule r in newG.Rules) r.Right.RemoveAll(s => toBeRemoved.Exists(A => A.Sym == s.Sym)); newG.Rules.RemoveAll(r => toBeRemoved.Exists(A => A.Sym == r.Left.Sym)); newG.Nonterminals.RemoveAll(nt => toBeRemoved.Exists(A => A.Sym == nt.Sym)); return newG; }
private Nonterminal distinguishedSymbolForNonnullableGrammar(Grammar g) { Nonterminal S; if (g.isVanishingSymbol(g.DistinguishedSymbol)) S = _nonnullableNonterminalsMap[g.DistinguishedSymbol.Sym]; else S = g.DistinguishedSymbol; return S; }
private List<Nonterminal> bulidNonterminalsForNonnullableGrammar(Grammar g) { _nonnullableNonterminalsMap = new Dictionary<string, Nonterminal>(); List<Nonterminal> N = new List<Nonterminal>(g.Nonterminals); foreach (Nonterminal vs in g.VanishingSymbols) { Nonterminal newNonterminal = new Nonterminal(String.Format("{0}*", vs.Sym)); N.Add(newNonterminal); _nonnullableNonterminalsMap.Add(vs.Sym, newNonterminal); } return N; }
private List<Rule> buildRulesForNonterminal(Nonterminal nonterminal, Grammar g) { List<Rule> newRules = new List<Rule>(); List<Rule> rules = new List<Rule>(); List<Symbol> symStr = nonterminalToSymbolString(nonterminal); List<Symbol> firstTerminals = symStr.TakeWhile(ss => ss is Terminal).ToList(); foreach (Symbol nt in symStr) if (nt is Nonterminal) { int ind = symStr.IndexOf(nt); List<Symbol> restOfString = symStr.GetRange(ind + 1, symStr.Count - ind - 1); foreach (Rule r in g.Rules) { if (r.Left.Sym == nt.Sym && !r.isERule()) { Rule newRule = new Rule(); newRule.Left = new Nonterminal(nonterminal); newRule.Right = buildRightPartOfNewRule(firstTerminals, restOfString, r); newRules.Add(newRule); } } if (ind == 0) break; } if (firstTerminals.Count != 0) newRules.Add(new Rule((Nonterminal)nonterminal, firstTerminals)); return newRules; }