private void EliminarProducoesUnitarias()
{
GrammarNoUnitarianProductions = new Grammar();
GrammarNoUnitarianProductions.Terminals.AddRange(GrammarNoEmpty.Terminals);
GrammarNoUnitarianProductions.Variables.AddRange(GrammarNoEmpty.Variables);
for (int i = 0; i < GrammarNoEmpty.Rules.Count; i++)
{
RuleProduction rgAtual = GrammarNoEmpty.Rules[i];
GrammarNoUnitarianProductions.AddRule(rgAtual.Source, rgAtual.Destiny.Copy());
}
bool trocou = true;
while (trocou)
{
trocou = false;
for (int i = GrammarNoUnitarianProductions.Rules.Count - 1; i >= 0; i--)
{
RuleProduction rgAtual = GrammarNoUnitarianProductions.Rules[i];
if (rgAtual.IsUnityVariable())
{
var regras = GrammarNoUnitarianProductions.GetRules(rgAtual.FirstDestiny().Name);
foreach (var item in regras)
{
GrammarNoUnitarianProductions.AddRule(rgAtual.Source, item.Destiny.Copy());
}
trocou = true;
GrammarNoUnitarianProductions.Rules.Remove(rgAtual);
}
}
}
}
private void FillClosures()
{
Fasteners = new Dictionary <Symbol, SymbolList>();
FastenersString = new List <string>();
for (int i = 0; i < GrammarNoEmpty.Rules.Count; i++)
{
RuleProduction rgAtual = GrammarNoEmpty.Rules[i];
if (rgAtual.IsUnityVariable())
{
if (Fasteners.ContainsKey(rgAtual.Source))
{
if (!Fasteners[rgAtual.Source].Contains(rgAtual.Destiny[0]))
{
Fasteners[rgAtual.Source].Add(rgAtual.Destiny[0]);
}
}
else
{
Fasteners.Add(rgAtual.Source, new SymbolList());
Fasteners[rgAtual.Source].Add(rgAtual.Destiny[0]);
}
}
}
foreach (var item in Fasteners)
{
string fecho = "{";
foreach (var charItem in item.Value)
{
fecho += charItem.Name + ",";
}
FastenersString.Add(string.Format("Fecho({0}) = {1}}}", item.Key.Name, fecho.Trim(',')));
}
}
private void PreencherRegrasArParaArEArParaMaiorAr()
{
RolesArToGreatAs = new List <RuleProduction>();
RolesArToAr = new List <RuleProduction>();
RolesSubstituiArGreatAs = new List <RuleProduction>();
RolesReplaceArParaAr = new List <RuleProduction>();
for (int i = 0; i < Normalized.Rules.Count; i++)
{
RuleProduction rAtual = Normalized.Rules[i];
var destino = rAtual.Destiny.Copy();
if (rAtual.IsFirstVariable())
{
if (NewNames.ContainsKey(rAtual.Source))
{
if (NewNames[rAtual.Source].Id > NewNames[rAtual.FirstDestiny()].Id)
{
Normalized.Rules.Remove(rAtual);
i--;
List <RuleProduction> regrasDestino = Normalized.GetRules(rAtual.FirstDestiny());
RolesArToGreatAs.Add(rAtual);
//Remoção de Regra, decrementa i
for (int j = 0; j < regrasDestino.Count; j++)
{
RuleProduction regraTemp = Normalized.AddRule(rAtual.Source,
regrasDestino[j].Destiny.AddRange(rAtual.SkipFirstDestiny()));
RolesSubstituiArGreatAs.Add(regraTemp);
}
}
else if (NewNames[rAtual.Source].Name == NewNames[rAtual.FirstDestiny()].Name)
{
RolesArToAr.Add(rAtual);
var bAtual = new Symbol(GetNewId(), string.Empty, false);
Normalized.Variables.Add(bAtual);
destino = destino.SkipFirst();
RuleProduction regraTemp = Normalized.AddRule(bAtual, destino);
RolesReplaceArParaAr.Add(regraTemp);
regraTemp = Normalized.AddRule(bAtual, destino.Add(bAtual));
RolesReplaceArParaAr.Add(regraTemp);
//Removi volta o i
Normalized.Rules.Remove(rAtual);
i--;
List <RuleProduction> regrasOrigem = Normalized.GetRules(rAtual.Source);
for (int j = 0; j < regrasOrigem.Count; j++)
{
regraTemp = Normalized.AddRule(rAtual.Source, regrasOrigem[j].Destiny.Add(bAtual));
RolesReplaceArParaAr.Add(regraTemp);
}
}
}
}
}
}
public void EliminarProducoesVazio()
{
GrammarNoEmpty = new Grammar();
GrammarNoEmpty.Terminals.AddRange(Source.Terminals);
GrammarNoEmpty.Variables.AddRange(Source.Variables);
for (int i = 0; i < Source.Rules.Count; i++)
{
RuleProduction regraAtual = Source.Rules[i];
Symbol orig = regraAtual.Source;
List <SymbolList> destinos = new List <SymbolList>();
if (Source.Rules[i].Destiny.Count == 1 && Source.Rules[i].Destiny[0] == Symbol.EmptyTerminal)
{
//Do Nothing
}
else
{
if (regraAtual.Destiny.Count > 0)
{
destinos.Add(regraAtual.Destiny);
for (int j = 0; j < destinos.Count; j++)
{
for (int k = 0; k < VariablesEmpty.Count; k++)
{
if (destinos[j].Contains(VariablesEmpty[k]))
{
var destino = regraAtual.Destiny;
while (destino.Contains(VariablesEmpty[k]))
{
destino = destino.RemoveFirst(VariablesEmpty[k]);
if (destinos.FirstOrDefault(list => list == destino) == null &&
!destino.IsEmpty())
{
destinos.Add(destino);
}
}
}
}
}
}
for (int j = 0; j < destinos.Count; j++)
{
var destino = destinos[j].Copy();
GrammarNoEmpty.AddRule(orig, destino);
}
}
}
}
private void GenerateSimplified()
{
Simplified = new Grammar();
Simplified.Terminals.AddRange(AcessiblesTerminals);
Simplified.Variables.AddRange(AcessiblesVariables);
Simplified.VariableStart = GrammarNoUnitarianProductions.VariableStart;
Simplified.VariablesEmpty = VariablesEmpty;
bool change = true;
Simplified.Rules.AddRange(GrammarNoUnitarianProductions.Rules.Select(r => new RuleProduction()
{
Destiny = r.Destiny, Source = r.Source
}));
while (change)
{
change = false;
if (Simplified.Terminals.RemoveAll(terminal => !AcessiblesTerminals.Contains(terminal)) > 0)
{
change = true;
}
if (Simplified.Variables.RemoveAll(variavel => !AcessiblesVariables.Contains(variavel)) > 0)
{
change = true;
}
for (int i = Simplified.Rules.Count - 1; i >= 0; i--)
{
RuleProduction rAtual = Simplified.Rules[i];
if (!AcessiblesVariables.Contains(rAtual.Source) ||
rAtual.Destiny.Exists
(simbolo =>
(
(simbolo.Terminal && !AcessiblesTerminals.Contains(simbolo)) ||
(!simbolo.Terminal && !AcessiblesVariables.Contains(simbolo))
)
)
)
{
change = true;
Simplified.Rules.Remove(rAtual);
}
}
FillAcessibles(Simplified);
}
}
public RuleProduction AddRule(Symbol source, SymbolList destiny)
{
if (Rules.Count == 0)
{
VariableStart = source;
}
RuleProduction rule = Rules.FirstOrDefault(r => r.Destiny == destiny && r.Source == source && r.Pertinence == 1);
if (rule == null)
{
rule = new RuleProduction();
rule.Source = source;
rule.Destiny.AddRange(destiny.ToList());
rule.Pertinence = 1;
Rules.Add(rule);
}
return(rule);
}
private void ColocarTerminalInicio()
{
for (int i = 0; i < Normalized.Rules.Count; i++)
{
RuleProduction rAtual = Normalized.Rules[i];
if (!rAtual.Destiny[0].Terminal)
{
//Removi regra volta regra
Normalized.Rules.Remove(rAtual);
i--;
var destino = rAtual.SkipFirstDestiny();
List <RuleProduction> regras = Normalized.GetRules(rAtual.FirstDestiny());
for (int j = 0; j < regras.Count; j++)
{
RuleProduction regraTemp = Normalized.AddRule(rAtual.Source, regras[j].Destiny.Copy().AddRange(destino));
}
}
}
}
//Removendo terminais no meio
private void RemoveTerminalsNoMeio()
{
for (int i = 0; i < Normalized.Rules.Count; i++)
{
RuleProduction rAtual = Normalized.Rules[i];
for (int j = 1; j < rAtual.Destiny.Count; j++)
{
if (rAtual.Destiny[j].Terminal)
{
var variavelExclusiva = Normalized.CapturarVariavelExclusiva(rAtual.Destiny[j]);
if (variavelExclusiva == Symbol.EmptyVariable)
{
variavelExclusiva = new Symbol(GetNewId(), string.Empty, false);
Normalized.Variables.Add(variavelExclusiva);
Normalized.AddRule(variavelExclusiva, rAtual.Destiny);
}
rAtual.Destiny[j] = variavelExclusiva;
}
}
}
}
private void Normalize()
{
Normalized.VariableStart = simplified.VariableStart;
Normalized.Terminals.AddRange(simplified.Terminals);
Normalized.Variables.AddRange(simplified.Variables);
for (int i = 0; i < simplified.Rules.Count; i++)
{
RuleProduction rgActual = simplified.Rules[i];
var destiny = rgActual.Destiny;
foreach (var item in DicVariablesTerminals)
{
destiny = destiny.Replace(item.Key, item.Value);
}
if (destiny.Unitary)
{
Normalized.AddRule(rgActual.Source, destiny);
}
else
{
if (destiny.Count == 2 && !rgActual.DestinyContainsTerminal())
{
Normalized.AddRule(rgActual.Source, destiny);
}
else
{
List <SymbolList> destinys = new List <SymbolList>();
while (destiny.Count > 2)
{
destinys.Clear();
for (int k = 0; k < destiny.Count; k += 2)
{
if (k + 1 < destiny.Count)
{
destinys.Add(new SymbolList(destiny[k], destiny[k + 1]));
}
else
{
destinys.Add(new SymbolList(destiny[k]));
}
}
destiny = new SymbolList();
foreach (var des in destinys)
{
Symbol destinyVariable = des[0];
if (!des.Unitary)
{
destinyVariable = Normalized.GetExclusiveVars(des);
if (destinyVariable == Symbol.EmptyVariable)
{
destinyVariable = new Symbol(GetNewId(), string.Empty, false);
Normalized.Variables.Add(destinyVariable);
Normalized.AddRule(destinyVariable, des);
}
}
destiny.Add(destinyVariable);
}
}
Normalized.AddRule(rgActual.Source, destiny);
}
}
}
}
