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