public void CreateTreeContainer(Container parent, Node <Symbol, double> nodeParent)
{
RuleProduction rule = null;
// if (prod < Productions.Count)
{
rule = nodeParent.GetCustomOject <RuleProduction>("Rule");
if (nodeParent.Edges.Count > 0)
{
for (int i = nodeParent.Edges.Count - 1; i >= 0; i--)
{
var transition = nodeParent.Edges[i];
//if (!DestinyIsTerminal(transition.Destiny))
// prod++;
var next = CreateContainer(transition.Destiny);
//rule = transition.Destiny.GetCustomOject<RuleProduction>("Rule");
next.Name = NamesVars[rule.Id][i];
if (!parent.ContainsKey(next.Name))
{
parent.Add(next.Name, next);
}
else
{
parent[next.Name] = next;
}
CreateTreeContainer(next, transition.Destiny);
}
}
else
{
if (nodeParent.CustomOject.ContainsKey("Destiny"))
{
var next = CreateContainer(nodeParent.GetCustomOject <Symbol>("Destiny"));
next.Name = NamesVars[nodeParent.GetCustomOject <RuleProduction>("Rule").Id][0];
if (!parent.ContainsKey(next.Name))
{
parent.Add(next.Name, next);
}
else
{
parent[next.Name] = next;
}
//parent.Add(next.Name, next);
}
}
}
}
private Graph <Symbol, double> CreateTreeSyntax(List <RuleProduction> rules, List <Symbol> tokens)
{
iToken = 0;
Stack <Node <Symbol, double> > stack = new Stack <Node <Symbol, double> >();
int iRule = rules.Count - 1;
var nodeActual = new Node <Symbol, double>(rules[iRule].Source.Name + (iRule), rules[iRule].Source);
var firstNode = nodeActual;
stack.Push(nodeActual);
Graph <Symbol, double> result = new Graph <Symbol, double>();
while (stack.Count > 0)
{
nodeActual = stack.Pop();
RuleProduction ruleActual = rules[iRule--];
nodeActual.SetCustomOject("Rule", ruleActual);
for (int j = 0; j < ruleActual.Destiny.Count; j++)
{
Node <Symbol, double> nodeChild = new Node <Symbol, double>(ruleActual.Destiny[j].Name, ruleActual.Destiny[j]);
if (ruleActual.Destiny[j].Terminal)
{
if (ruleActual.Destiny[j].Id == tokens[iToken].Id)
{
nodeChild.Info = ruleActual.Destiny[j];
}
}
else
{
stack.Push(nodeChild);
}
nodeActual.AddEdge(ruleActual.Pertinence, nodeChild, ruleActual.Pertinence);
}
}
iToken = 0;
FillTerminals(firstNode, tokens);
result = firstNode.ToGraph();
return(result);
}
private Container CreateContainer(Node <Symbol, double> node)
{
RuleProduction rule = node.GetCustomOject <RuleProduction>("Rule");
Container container = new Container();
container.Value = string.Empty;
if (DestinyIsTerminal(node))
{
var token = node.Info.GetCustomValue <Token>("Token");
RecognitionToken recToken = null;
if (token != null)
{
recToken = token.RecToken;
container.Value = token.Word;
container.Column = token.Collumn;
container.Line = token.Line;
}
if (recToken == null)
{
recToken = node.Info.GetCustomValue <RecognitionToken>("RecToken");
}
if ((recToken != null) &&
(token == null || recToken.RegexFuzzy.Match(token.Word) < 1)
)
{
container.Value = recToken.RegexFuzzy.RegexFuzzy;
}
container.TypeName = node.Info.Name;
}
else
{
if (rule != null)
{
container.TypeName = rule.TypeName;
}
}
return(container);
}
private Node <Symbol, double> CreateNode(Node <Symbol, double> node)
{
RuleProduction rule = node.GetCustomOject <RuleProduction>("Rule");
if (rule != null && rule.Parent != null)
{
var parent = rule.Parent;
node.SetCustomOject("Rule", rule.Parent);
List <Node <Symbol, double> > founds = new List <Node <Symbol, double> >();
for (int i = 0; i < parent.Destiny.Count; i++)
{
bool found = false;
for (int j = node.Edges.Count - 1; j >= 0; j--)
{
if (parent.Destiny[i].Id == node.Edges[j].Destiny.Info.Id && !founds.Contains(node.Edges[j].Destiny))
{
found = true;
node.Edges[j].Destiny.SetCustomOject("CostEdge", node.Edges[j].Cost);
founds.Add(node.Edges[j].Destiny);
break;
}
}
if (!found)
{
var n = CreateNotFoundNode(parent.Destiny[i], rule.Pertinence);
n.SetCustomOject("CostEdge", rule.Pertinence);
founds.Add(n);
}
}
node.Edges.Clear();
for (int i = 0; i < founds.Count; i++)
{
var cost = founds[i].GetCustomOject <double>("CostEdge");
node.AddEdge(cost, founds[i], cost);
}
}
return(node);
}
public CompilerXmlParser(string filename)
{
NamesVars = new Dictionary<int, List<string>>();
RecsTokens = new List<RecognitionToken>();
Grammar = new Grammar();
using (FileStream file = File.OpenRead(filename))
{
XDocument xdoc = XDocument.Load(file, LoadOptions.None);
var settings = xdoc.Element("Compiler").Element("Settings");
NormAbstract norm;
switch (settings.Element("Norm").Value)
{
case "MIN":
norm = new MinNorm();
break;
default:
norm = new MultiplyNorm();
break;
}
ConormAbstract conorm;
switch (settings.Element("Conorm").Value)
{
case "SUM":
conorm = new SumMinusProductConorm();
break;
default:
conorm = new MaxConorm();
break;
}
var recTokens = xdoc.Element("Compiler").Element("RecTokens").Elements("RecToken");
int idTokens = 1;
foreach (var token in recTokens)
{
int id = idTokens++;
if (token.Attributes("id").Any() && !string.IsNullOrWhiteSpace(token.Attribute("id").Value))
{
id = Convert.ToInt32(token.Attribute("id").Value);
}
string name = token.Attribute("name").Value;
string fregex = token.Attribute("fregex").Value;
string hexColor = string.Empty;
if (token.Attributes("color").Any())
{
hexColor = token.Attribute("color").Value;
}
RecsTokens.Add(new RecognitionToken(id, name, fregex, hexColor, norm, conorm));
}
int idSymbols = 100;
var symbolsXml = xdoc.Element("Compiler").Element("Grammar").Element("Symbols").Elements("Symbol");
foreach (var symbolXml in symbolsXml)
{
int id = idSymbols++;
if (symbolXml.Attributes("id").Any() && !string.IsNullOrWhiteSpace(symbolXml.Attribute("id").Value))
{
id = Convert.ToInt32(symbolXml.Attribute("id").Value);
}
string name = symbolXml.Attribute("name").Value;
bool terminal = false;
if (symbolXml.Attributes("terminal").Any())
{
terminal = Convert.ToBoolean(symbolXml.Attribute("terminal").Value);
}
string tempTokenReference = string.Empty;
int recTokenId = 0;
if (symbolXml.Attributes("recTokenId").Any())
{
tempTokenReference = symbolXml.Attribute("recTokenId").Value;
if (!string.IsNullOrWhiteSpace(tempTokenReference))
recTokenId = Convert.ToInt32(tempTokenReference);
}
if (string.IsNullOrWhiteSpace(tempTokenReference) && symbolXml.Attributes("recTokenName").Any())
{
tempTokenReference = symbolXml.Attribute("recTokenName").Value;
}
string temp = symbolXml.Attribute("charValue").Value;
if (string.IsNullOrWhiteSpace(temp))
{
temp = "\0";
}
char value = temp[0];
Symbol symbol = new Symbol(id, name, terminal, value);
if (terminal)
{
if (recTokenId > 0)
{
symbol.SetCustomValue("RecToken", RecsTokens.First(rt => rt.Id == recTokenId));
}
else if (!string.IsNullOrWhiteSpace(tempTokenReference))
{
symbol.SetCustomValue("RecToken", RecsTokens.First(rt => rt.Name == tempTokenReference));
}
Grammar.Terminals.Add(symbol);
}
else
{
bool variableInitial = false;
if (symbolXml.Attribute("variableInitial") != null)
variableInitial = Convert.ToBoolean(symbolXml.Attribute("variableInitial").Value);
if (variableInitial)
{
Grammar.VariableStart = symbol;
}
Grammar.Variables.Add(symbol);
}
}
int idRules = 100;
var rulesXml = xdoc.Element("Compiler").Element("Grammar").Element("Rules").Elements("Rule");
foreach (var ruleXml in rulesXml)
{
bool gotoEmpty = false;
string sourceName = ruleXml.Attribute("sourceName").Value;
if (sourceName.Contains("normalAnnotation"))
{
}
double pertinence = Convert.ToDouble(ruleXml.Attribute("pertinence").Value.Replace(",", "."), CultureInfo.InvariantCulture);
SymbolList destinys = new SymbolList();
var destinysXml = ruleXml.Element("Destinys").Elements("Destiny");
List<string> nameVars = new List<string>();
foreach (var destinyXml in destinysXml)
{
string name = destinyXml.Attribute("name").Value;
if (name != "Empty")
{
var symbol = Grammar.Symbols.FirstOrDefault(s => s.Name == name);
if (symbol == null)
{
symbol = new Symbol(idSymbols++, name, false, '\0');
Grammar.Variables.Add(symbol);
}
destinys.Add(symbol);
}
else
{
gotoEmpty = destinysXml.Count() == 1;
destinys.Add(Symbol.EmptySymbol);
if (!Grammar.Terminals.Contains(Symbol.EmptySymbol))
{
Grammar.Terminals.Add(Symbol.EmptySymbol);
}
}
string namevar = name;
if (destinyXml.Attribute("var") != null && !string.IsNullOrWhiteSpace(destinyXml.Attribute("var").Value))
{
namevar = destinyXml.Attribute("var").Value.Trim();
}
nameVars.Add(namevar);
}
var sourceSymbol = Grammar.Variables.FirstOrDefault(s => s.Name == sourceName);
if (sourceSymbol == null)
{
if (sourceSymbol == null)
{
sourceSymbol = new Symbol(idSymbols++, sourceName, false, '\0');
}
Grammar.Variables.Add(sourceSymbol);
}
sourceSymbol.GoToEmpty = gotoEmpty;
RuleProduction rule = new RuleProduction(sourceSymbol, destinys, pertinence);
rule.Description = ruleXml.Element("Description").Value;
foreach (var attr in ruleXml.Attributes())
{
if (attr.Name == "typeName")
rule.TypeName = attr.Value;
if (attr.Name == "id")
{
if (!string.IsNullOrWhiteSpace(attr.Value))
{
rule.Id = Convert.ToInt32(attr.Value);
}
}
if (attr.Name == "default")
rule.Default = Convert.ToBoolean(attr.Value);
}
if (rule.Id == 0)
{
rule.Id = idRules++;
}
string temp = ruleXml.Attribute("idRuleParent").Value;
int idRuleParent = 0;
if (!string.IsNullOrWhiteSpace(temp))
idRuleParent = Convert.ToInt32(temp);
if (idRuleParent > 0)
{
rule.Parent = Grammar.Rules.First(r => r.Id == idRuleParent);
}
//Adicionando Nome das variáveis
NamesVars.Add(rule.Id, nameVars);
Grammar.Rules.Add(rule);
}
this.Compiler = new CompilerFuzzy(RecsTokens, Grammar, NamesVars, null, norm, conorm);
switch (settings.Element("Parser").Value)
{
case "SyntacticAnalysisCYK":
this.Compiler.Syn = new SyntacticAnalysisCYK(Grammar);
break;
case "SyntacticAnalysisLR1":
default:
this.Compiler.Syn = new SyntacticAnalysisLR1(Grammar, norm, conorm);
break;
}
switch (settings.Element("Lexer").Value)
{
case "FullLexicalAnalysis":
this.Compiler.Lex = new FullLexicalAnalysis(RecsTokens, norm, conorm);
break;
case "TokenizerLexicalAnalysis":
default:
this.Compiler.Lex = new TokenizerLexicalAnalysis(RecsTokens, norm, conorm);
break;
}
}
}
private void AddInDic(Symbol source, int i, int j, double pertinence, Symbol destiny, RuleProduction rule)
{
KeyDicCYK key = new KeyDicCYK(source, i, j);
if (!DicCYK.ContainsKey(key))
{
DicCYK.Add(key, null);
}
DicCYK[key] = new Node <Symbol, double>(string.Empty, source);
DicCYK[key].SetCustomOject("Prob", pertinence);
DicCYK[key].SetCustomOject("Start", i);
DicCYK[key].SetCustomOject("End", i);
DicCYK[key].SetCustomOject("Destiny", destiny);
DicCYK[key].SetCustomOject("Rule", rule);
}
public CompilerXmlParser(string filename)
{
NamesVars = new Dictionary <int, List <string> >();
RecsTokens = new List <RecognitionToken>();
Grammar = new Grammar();
using (FileStream file = File.OpenRead(filename))
{
XDocument xdoc = XDocument.Load(file, LoadOptions.None);
var settings = xdoc.Element("Compiler").Element("Settings");
NormAbstract norm;
switch (settings.Element("Norm").Value)
{
case "MIN":
norm = new MinNorm();
break;
default:
norm = new MultiplyNorm();
break;
}
ConormAbstract conorm;
switch (settings.Element("Conorm").Value)
{
case "SUM":
conorm = new SumMinusProductConorm();
break;
default:
conorm = new MaxConorm();
break;
}
var recTokens = xdoc.Element("Compiler").Element("RecTokens").Elements("RecToken");
int idTokens = 1;
foreach (var token in recTokens)
{
int id = idTokens++;
if (token.Attributes("id").Any() && !string.IsNullOrWhiteSpace(token.Attribute("id").Value))
{
id = Convert.ToInt32(token.Attribute("id").Value);
}
string name = token.Attribute("name").Value;
string fregex = token.Attribute("fregex").Value;
string hexColor = string.Empty;
if (token.Attributes("color").Any())
{
hexColor = token.Attribute("color").Value;
}
RecsTokens.Add(new RecognitionToken(id, name, fregex, hexColor, norm, conorm));
}
int idSymbols = 100;
var symbolsXml = xdoc.Element("Compiler").Element("Grammar").Element("Symbols").Elements("Symbol");
foreach (var symbolXml in symbolsXml)
{
int id = idSymbols++;
if (symbolXml.Attributes("id").Any() && !string.IsNullOrWhiteSpace(symbolXml.Attribute("id").Value))
{
id = Convert.ToInt32(symbolXml.Attribute("id").Value);
}
string name = symbolXml.Attribute("name").Value;
bool terminal = false;
if (symbolXml.Attributes("terminal").Any())
{
terminal = Convert.ToBoolean(symbolXml.Attribute("terminal").Value);
}
string tempTokenReference = string.Empty;
int recTokenId = 0;
if (symbolXml.Attributes("recTokenId").Any())
{
tempTokenReference = symbolXml.Attribute("recTokenId").Value;
if (!string.IsNullOrWhiteSpace(tempTokenReference))
{
recTokenId = Convert.ToInt32(tempTokenReference);
}
}
if (string.IsNullOrWhiteSpace(tempTokenReference) && symbolXml.Attributes("recTokenName").Any())
{
tempTokenReference = symbolXml.Attribute("recTokenName").Value;
}
string temp = symbolXml.Attribute("charValue").Value;
if (string.IsNullOrWhiteSpace(temp))
{
temp = "\0";
}
char value = temp[0];
Symbol symbol = new Symbol(id, name, terminal, value);
if (terminal)
{
if (recTokenId > 0)
{
symbol.SetCustomValue("RecToken", RecsTokens.First(rt => rt.Id == recTokenId));
}
else if (!string.IsNullOrWhiteSpace(tempTokenReference))
{
symbol.SetCustomValue("RecToken", RecsTokens.First(rt => rt.Name == tempTokenReference));
}
Grammar.Terminals.Add(symbol);
}
else
{
bool variableInitial = false;
if (symbolXml.Attribute("variableInitial") != null)
{
variableInitial = Convert.ToBoolean(symbolXml.Attribute("variableInitial").Value);
}
if (variableInitial)
{
Grammar.VariableStart = symbol;
}
Grammar.Variables.Add(symbol);
}
}
int idRules = 100;
var rulesXml = xdoc.Element("Compiler").Element("Grammar").Element("Rules").Elements("Rule");
foreach (var ruleXml in rulesXml)
{
bool gotoEmpty = false;
string sourceName = ruleXml.Attribute("sourceName").Value;
if (sourceName.Contains("normalAnnotation"))
{
}
double pertinence = Convert.ToDouble(ruleXml.Attribute("pertinence").Value.Replace(",", "."), CultureInfo.InvariantCulture);
SymbolList destinys = new SymbolList();
var destinysXml = ruleXml.Element("Destinys").Elements("Destiny");
List <string> nameVars = new List <string>();
foreach (var destinyXml in destinysXml)
{
string name = destinyXml.Attribute("name").Value;
if (name != "Empty")
{
var symbol = Grammar.Symbols.FirstOrDefault(s => s.Name == name);
if (symbol == null)
{
symbol = new Symbol(idSymbols++, name, false, '\0');
Grammar.Variables.Add(symbol);
}
destinys.Add(symbol);
}
else
{
gotoEmpty = destinysXml.Count() == 1;
destinys.Add(Symbol.EmptySymbol);
if (!Grammar.Terminals.Contains(Symbol.EmptySymbol))
{
Grammar.Terminals.Add(Symbol.EmptySymbol);
}
}
string namevar = name;
if (destinyXml.Attribute("var") != null && !string.IsNullOrWhiteSpace(destinyXml.Attribute("var").Value))
{
namevar = destinyXml.Attribute("var").Value.Trim();
}
nameVars.Add(namevar);
}
var sourceSymbol = Grammar.Variables.FirstOrDefault(s => s.Name == sourceName);
if (sourceSymbol == null)
{
if (sourceSymbol == null)
{
sourceSymbol = new Symbol(idSymbols++, sourceName, false, '\0');
}
Grammar.Variables.Add(sourceSymbol);
}
sourceSymbol.GoToEmpty = gotoEmpty;
RuleProduction rule = new RuleProduction(sourceSymbol, destinys, pertinence);
rule.Description = ruleXml.Element("Description").Value;
foreach (var attr in ruleXml.Attributes())
{
if (attr.Name == "typeName")
{
rule.TypeName = attr.Value;
}
if (attr.Name == "id")
{
if (!string.IsNullOrWhiteSpace(attr.Value))
{
rule.Id = Convert.ToInt32(attr.Value);
}
}
if (attr.Name == "default")
{
rule.Default = Convert.ToBoolean(attr.Value);
}
}
if (rule.Id == 0)
{
rule.Id = idRules++;
}
string temp = ruleXml.Attribute("idRuleParent").Value;
int idRuleParent = 0;
if (!string.IsNullOrWhiteSpace(temp))
{
idRuleParent = Convert.ToInt32(temp);
}
if (idRuleParent > 0)
{
rule.Parent = Grammar.Rules.First(r => r.Id == idRuleParent);
}
//Adicionando Nome das variáveis
NamesVars.Add(rule.Id, nameVars);
Grammar.Rules.Add(rule);
}
this.Compiler = new CompilerFuzzy(RecsTokens, Grammar, NamesVars, null, norm, conorm);
switch (settings.Element("Parser").Value)
{
case "SyntacticAnalysisCYK":
this.Compiler.Syn = new SyntacticAnalysisCYK(Grammar);
break;
case "SyntacticAnalysisLR1":
default:
this.Compiler.Syn = new SyntacticAnalysisLR1(Grammar, norm, conorm);
break;
}
switch (settings.Element("Lexer").Value)
{
case "FullLexicalAnalysis":
this.Compiler.Lex = new FullLexicalAnalysis(RecsTokens, norm, conorm);
break;
case "TokenizerLexicalAnalysis":
default:
this.Compiler.Lex = new TokenizerLexicalAnalysis(RecsTokens, norm, conorm);
break;
}
}
}
private void AddInDic(Symbol source, int i, int j, double pertinence, Symbol destiny, RuleProduction rule)
{
KeyDicCYK key = new KeyDicCYK(source, i, j);
if (!DicCYK.ContainsKey(key))
{
DicCYK.Add(key, null);
}
DicCYK[key] = new Node<Symbol, double>(string.Empty, source);
DicCYK[key].SetCustomOject("Prob", pertinence);
DicCYK[key].SetCustomOject("Start", i);
DicCYK[key].SetCustomOject("End", i);
DicCYK[key].SetCustomOject("Destiny", destiny);
DicCYK[key].SetCustomOject("Rule", rule);
}
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;
}
public override double Validate(List <Symbol> tokens)
{
CacheFirst = null;
try
{
GraphsSyntactic = new List <Graph <Symbol, double> >();
tokens.Add(Symbol.TapeFinal);
Productions = new List <RuleProduction>();
Graph <State <Symbol>, double> graph = new Graph <State <Symbol>, double>();
FirstState.PertinenceInitial = 1;
var firstNode = graph.AddNode("First", FirstState);
firstNode.Parent = null;
List <Node <State <Symbol>, double> > leafs = new List <Node <State <Symbol>, double> >();
int idNode = 1;
List <Node <State <Symbol>, double> > newLeafs = new List <Node <State <Symbol>, double> >();
CustomValueStateNodeLR1 customValueStateNodeLR1 = new CustomValueStateNodeLR1();
customValueStateNodeLR1.CoutPaths = 1;
//customValueStateNodeLR1.Tokens.Add(tokens[0]);
customValueStateNodeLR1.IToken = 1;
customValueStateNodeLR1.ASymbol = tokens[0];
customValueStateNodeLR1.ASymbolReal = tokens[0];
firstNode.SetCustomOject("CustomValueStateNodeLR1", customValueStateNodeLR1);
leafs.Add(firstNode);
double maxAcept = 0;
while (true)
{
for (int iLeaf = 0; iLeaf < leafs.Count; iLeaf++)
{
var sLeaf = leafs[iLeaf];
customValueStateNodeLR1 = sLeaf.GetCustomOject <CustomValueStateNodeLR1>("CustomValueStateNodeLR1");
#region GETOP
double pertinenceS = sLeaf.Info.PertinenceInitial;
double newPertinence = 1;
var operations = Table[sLeaf.Info][customValueStateNodeLR1.ASymbol];
var emptyrule = false;
if (operations.Count == 0)
{
if (Table[sLeaf.Info].ContainsKey(Symbol.EmptySymbol))
{
operations = Table[sLeaf.Info][Symbol.EmptySymbol];
emptyrule = true;
}
}
if (operations.Count == 0)
{
operations = Table[sLeaf.Info][Symbol.TapeFinal];
emptyrule = true;
}
#endregion GETOP
if (operations.Count > 0)
{
for (int iOp = 0; iOp < operations.Count; iOp++)
{
customValueStateNodeLR1 = sLeaf.GetCustomOject <CustomValueStateNodeLR1>("CustomValueStateNodeLR1");
Operation op = operations[iOp];
#region FOREACH
if (op.Type == TypeOperation.Shift)
{
#region SHIFT
newPertinence = Norm.Calculate(pertinenceS, op.Pertinence);
var newLeaf = graph.AddNode(idNode++, op.State, sLeaf, newPertinence);
CustomValueStateNodeLR1 newCustomValueStateNodeLR1 = new CustomValueStateNodeLR1(customValueStateNodeLR1);
newCustomValueStateNodeLR1.IndexInParent = iOp;
List <Symbol> sNewTokens = new List <Symbol>();
if (!emptyrule)
{
if (newCustomValueStateNodeLR1.IToken >= tokens.Count)
{
newCustomValueStateNodeLR1.ASymbol = Symbol.TapeFinal;
}
else
{
newCustomValueStateNodeLR1.ASymbol = tokens[newCustomValueStateNodeLR1.IToken];
}
newCustomValueStateNodeLR1.IToken++;
}
newLeaf.Info.PertinenceInitial = newPertinence;
newLeaf.SetCustomOject("CustomValueStateNodeLR1", newCustomValueStateNodeLR1);
newLeafs.Add(newLeaf);
#endregion SHIFT
}
else if (op.Type == TypeOperation.Reduce)
{
#region REDEUCE 1
RuleProduction rule = op.Rule;
var prox = sLeaf;
int popStack = op.Rule.Destiny.Count;
int countNodes = rule.Destiny.Count;
for (int i = 0; i < popStack; i++)
{
newPertinence = prox.Info.PertinenceInitial;
var temp = prox;
//graph.RemoveNode(prox);
prox = prox.Parent;
}
#endregion REDEUCE 1
#region GOTO
var operationsGoto = Table[prox.Info][rule.Source];
if (operationsGoto.Count > 0)
{
var state = operationsGoto[0].State;
newPertinence = Norm.Calculate(prox.Info.PertinenceInitial, op.Rule.Pertinence);
var newLeaf = graph.AddNode(idNode++, state, prox, newPertinence);
CustomValueStateNodeLR1 newCustomValueStateNodeLR1 = new CustomValueStateNodeLR1(customValueStateNodeLR1);
newCustomValueStateNodeLR1.IndexInParent = iOp;
newCustomValueStateNodeLR1.Productions.Add(rule);
newLeaf.SetCustomOject("CustomValueStateNodeLR1", newCustomValueStateNodeLR1);
newCustomValueStateNodeLR1.Pertinence = newPertinence;
newLeaf.Info.PertinenceInitial = newPertinence;
newLeafs.Add(newLeaf);
}
#endregion GOTO
}
else if (op.Type == TypeOperation.Acept)
{
#region Acept
Graph <Symbol, double> graphA =
CreateTreeSyntax(customValueStateNodeLR1.Productions,
tokens);
GraphsSyntactic.Add(graphA);
if (sLeaf.Info.PertinenceInitial > maxAcept)
{
Productions = customValueStateNodeLR1.Productions;
maxAcept = sLeaf.Info.PertinenceInitial;
}
#endregion Acept
}
else
{
//TODO: Recuperar de errros
return(0);
}
#endregion FOREACH
}
}
}
leafs = newLeafs;
if (leafs.Count == 0)
{
return(maxAcept);
}
newLeafs = new List <Node <State <Symbol>, double> >();
}
}
catch (Exception ex)
{
}
return(0);
}
