private void Draw(Automa <char> automa, int indexTable = -1)
        {
            Graph graphAutoma = new Graph("Automa");

            for (int i = 0; i < automa.States.Count; i++)
            {
                State <char> state = automa.States[i];
                Node         no    = graphAutoma.AddNode(state.Name);
                no.Attr.Shape = Shape.Circle;

                if (state.PertinenceFinal > 0)
                {
                    no.Attr.Shape = Shape.DoubleCircle;
                }
                if (indexTable > -1)
                {
                    System.Drawing.Color c = Utils.GetColor(regexFuzzy.TableAutomaProcessing[indexTable][i]);
                    no.Attr.FillColor = new Microsoft.Msagl.Drawing.Color((byte)c.R, (byte)c.G, (byte)c.B);
                }
                else if (state.PertinenceInitial > 0)
                {
                    no.Attr.FillColor = Microsoft.Msagl.Drawing.Color.LightGray;
                }
            }
            foreach (var transition in automa.Transitions)
            {
                Edge arco = graphAutoma.AddEdge(transition.From.Name, transition.To.Name);
                arco.LabelText = transition.ToString();
            }
            GViewer viewer = new GViewer();

            viewer.NavigationVisible = false;
            viewer.OutsideAreaBrush  = Brushes.White;
            viewer.ToolBarIsVisible  = false;
            viewer.Graph             = graphAutoma;
            viewer.Dock = System.Windows.Forms.DockStyle.Fill;
            pnlAutoma.Controls.Clear();
            pnlAutoma.Controls.Add(viewer);
        }
        private void Draw(Automa<char> automa, int indexTable = -1)
        {
            Graph graphAutoma = new Graph("Automa");

            for (int i = 0; i < automa.States.Count; i++)
            {
                State<char> state = automa.States[i];
                Node no = graphAutoma.AddNode(state.Name);
                no.Attr.Shape = Shape.Circle;

                if (state.PertinenceFinal > 0)
                {
                    no.Attr.Shape = Shape.DoubleCircle;
                }
                if (indexTable > -1)
                {
                    System.Drawing.Color c = Utils.GetColor(regexFuzzy.TableAutomaProcessing[indexTable][i]);
                    no.Attr.FillColor = new Microsoft.Msagl.Drawing.Color((byte)c.R, (byte)c.G, (byte)c.B);
                }
                else if (state.PertinenceInitial > 0)
                {
                    no.Attr.FillColor = Microsoft.Msagl.Drawing.Color.LightGray;
                }
            }
            foreach (var transition in automa.Transitions)
            {
                Edge arco = graphAutoma.AddEdge(transition.From.Name, transition.To.Name);
                arco.LabelText = transition.ToString();
            }
            GViewer viewer = new GViewer();
            viewer.NavigationVisible = false;
            viewer.OutsideAreaBrush = Brushes.White;
            viewer.ToolBarIsVisible = false;
            viewer.Graph = graphAutoma;
            viewer.Dock = System.Windows.Forms.DockStyle.Fill;
            pnlAutoma.Controls.Clear();
            pnlAutoma.Controls.Add(viewer);
        }
 public SyntacticAnalysisLR1(GrammarFuzzy.Grammar grammar, NormAbstract norm, ConormAbstract conorm)
     : base(grammar, norm, conorm)
 {
     CacheFirst = new Hashtable();
     Table = new Dictionary<State<Symbol>, Dictionary<Symbol, List<Operation>>>();
     //Rules = new List<RuleProductionState>();
     List<Symbol> alphabet = new List<Symbol>();
     alphabet.AddRange(grammar.Variables);
     alphabet.AddRange(grammar.Terminals);
     this.Grammar = grammar;
     GrammarLine = new GrammarFuzzy.Grammar();
     GrammarLine.Rules.AddRange(grammar.Rules);
     GrammarLine.Terminals.AddRange(grammar.Terminals);
     GrammarLine.Variables.AddRange(grammar.Variables);
     GrammarLine.VariablesEmpty.AddRange(grammar.VariablesEmpty);
     SymbolInitialLine = new Symbol(100, "S'", false);
     GrammarLine.Variables.Add(SymbolInitialLine);
     GrammarLine.AddRule(SymbolInitialLine, grammar.VariableStart);
     GrammarLine.VariableStart = SymbolInitialLine;
     Automa = new Automa<Symbol>(alphabet, Symbol.EmptySymbol);
     SymbolInitial = grammar.VariableStart;
     CreateAutoma();
     CreateTable();
 }
        public SyntacticAnalysisLR1(GrammarFuzzy.Grammar grammar, NormAbstract norm, ConormAbstract conorm) : base(grammar, norm, conorm)
        {
            CacheFirst = new Hashtable();
            Table      = new Dictionary <State <Symbol>, Dictionary <Symbol, List <Operation> > >();
            //Rules = new List<RuleProductionState>();
            List <Symbol> alphabet = new List <Symbol>();

            alphabet.AddRange(grammar.Variables);
            alphabet.AddRange(grammar.Terminals);
            this.Grammar = grammar;
            GrammarLine  = new GrammarFuzzy.Grammar();
            GrammarLine.Rules.AddRange(grammar.Rules);
            GrammarLine.Terminals.AddRange(grammar.Terminals);
            GrammarLine.Variables.AddRange(grammar.Variables);
            GrammarLine.VariablesEmpty.AddRange(grammar.VariablesEmpty);
            SymbolInitialLine = new Symbol(100, "S'", false);
            GrammarLine.Variables.Add(SymbolInitialLine);
            GrammarLine.AddRule(SymbolInitialLine, grammar.VariableStart);
            GrammarLine.VariableStart = SymbolInitialLine;
            Automa        = new Automa <Symbol>(alphabet, Symbol.EmptySymbol);
            SymbolInitial = grammar.VariableStart;
            CreateAutoma();
            CreateTable();
        }
        public virtual Automa<char> RegexToAutoma()
        {
            Automa = new Automa<char>(GetAlphabet().ToList(), SYMBOLEMPTY);
            var stateInitial = Automa.AddState(NextNameState(), 1, 0);

            if (string.IsNullOrEmpty(RegexFuzzy))
                return Automa;

            string temp = string.Empty;
            bool escape = false;

            for (int i = 0; i < RegexFuzzy.Length; i++)
            {

                if (RegexFuzzy[i] == '\\')
                {
                    //NOTHING
                }
                else if (escape)
                {
                    switch (RegexFuzzy[i])
                    {
                        case 't':
                            temp += '\t';
                            break;
                        case 'n':
                            temp += '\n';
                            break;
                        case 'r':
                            temp += '\r';
                            break;
                        default:
                            temp += RegexFuzzy[i];
                            break;
                    }

                }
                else
                {
                    switch (RegexFuzzy[i])
                    {
                        case '?':
                            temp += "{0,1}";
                            break;
                        case '+':
                            temp += "{1,}";
                            break;
                        case '*':
                            temp += "{0,}";
                            break;
                        default:
                            temp += RegexFuzzy[i];
                            break;
                    }
                }

                if (RegexFuzzy[i] == '\\')
                {
                    escape = true;
                }
                else
                {
                    escape = false;
                }
            }

            RegexFuzzy = temp;//;RegexFuzzy.Replace("?", "{0,1}").Replace("+", "{1,}").Replace("*", "{0,}");

            List<State<char>> lastStates = new List<State<char>>();
            lastStates.Add(stateInitial);

            for (int i = 0; i < RegexFuzzy.Length; i++)
            {
                bool final = (i == RegexFuzzy.Length - 1);

                TypeCharEnum typeActual = GetTypeChar(RegexFuzzy[i]);

                TypeCharEnum typeNext = TypeCharEnum.Final;

                if (!final)
                {
                    typeNext = GetTypeChar(RegexFuzzy[i + 1]);
                }
                if (typeActual == TypeCharEnum.Interval || typeActual == TypeCharEnum.Symbol || (typeActual == TypeCharEnum.Loop && typeNext == TypeCharEnum.Final))
                {
                    var nextState = Automa.AddState(NextNameState(), 0, Convert.ToInt16(final));
                    List<char> interval = null;
                    if (ValidateInterval(i))
                    {
                        interval = AddInterval(ref i, nextState, lastStates);

                        typeNext = TypeCharEnum.Final;
                        final = (i == RegexFuzzy.Length - 1);
                        if (!final)
                            typeNext = GetTypeChar(RegexFuzzy[i + 1]);
                    }
                    else //if ()
                    {
                        foreach (var item in lastStates)
                        {
                            AddSimpleNext(item.Name, nextState.Name, RegexFuzzy[i]);
                        }
                    }

                    if (typeNext == TypeCharEnum.Loop)
                    {
                        AddLoop(ref i, lastStates, nextState, final, interval);
                        final = (i == RegexFuzzy.Length - 1);
                    }
                    else
                    {
                        lastStates.Clear();
                        lastStates.Add(nextState);
                    }

                    if (final)
                    {
                        List<char> inclusion = alphabet.ToList();
                        inclusion.Add(SYMBOLEMPTY);
                        AbstractRule<char> roleAlphabet = new SimpleListIncludeRule<char>(ValueDefaultTransitions, inclusion);
                        foreach (var item in lastStates)
                        {
                            item.PertinenceFinal = 1;
                            Automa.FinalStates.Add(item);
                            Automa.AddTransition(item.Name, item.Name, roleAlphabet);
                        }
                    }
                }
            }

            return Automa;
        }