Esempio n. 1
0
 public void MontaCombo(Automato at)
 {
     foreach (Estado e in at.Estados.Values)
     {
         cmbEstDest.Items.Add(e);
     }
 }
Esempio n. 2
0
        public static Transicao EditaTransicao(Transicao t, Automato aut)
        {
            AlteraTransicao at = new AlteraTransicao();

            at.MontaCombos(aut);
            if (t != null)
            {
                at.cmbEstOr.SelectedItem = t.EstadoOrigem;
                // at.cmbEstDest.SelectedItem = t.EstadoDestino;
                at.cmbSimbolo.SelectedItem = t.Simbolo;
            }

            at.ShowDialog();
            if (at.Ok)
            {
                if (t == null)
                {
                    t = new Transicao();
                }

                t.EstadoOrigem = (Estado)at.cmbEstOr.SelectedItem;
                // t.EstadoDestino = (Estado)at.cmbEstDest.SelectedItem;
                t.Simbolo = (Simbolo)at.cmbSimbolo.SelectedItem;
                return(t);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 3
0
        /*
         * public static Transicao getNewTransicao(Automato aut)
         * {
         *  AlteraTransicao at = new AlteraTransicao();
         *  at.MontaCombos(aut);
         *  at.ShowDialog();
         *  return at.transicao;
         * }*/

        public void MontaCombos(Automato at)
        {
            foreach (Estado e in at.Estados.Values)
            {
                cmbEstOr.Items.Add(e);
                cmbEstDest.Items.Add(e);
            }
            foreach (Simbolo s in at.Alfabeto.Values)
            {
                cmbSimbolo.Items.Add(s);
            }
        }
Esempio n. 4
0
        private void abrirToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog sfd = new OpenFileDialog();

            sfd.Filter = "XML Files|*.xml";
            sfd.ShowDialog();
            if (sfd.FileName != null && sfd.FileName != "")
            {
                Serializer       s  = new Serializer();
                SaveDataAutomato sd = (SaveDataAutomato)s.Busca(sfd.FileName, typeof(SaveDataAutomato));
                AutomatoInstanciado = sd.ConvertSaveDataAutomato(sd);
                AtualizaAutomato();
            }
        }
Esempio n. 5
0
        public EstadoAgrupado BuscaProxEstados(EstadoAgrupado e, Simbolo s, Automato aut)
        {
            EstadoAgrupado ret = new EstadoAgrupado();

            foreach (Estado est in e.Estados)
            {
                /*
                 * aut.getEstadosDestinos(
                 * if (est.Transicoes.ContainsKey(s.simbolo)) {
                 *  foreach(Es est.Transicoes[s.simbolo].EstadosDestino
                 *  ret.AdicionaSeNovo(
                 * }
                 */
            }
            return(null);
        }
Esempio n. 6
0
        private void btnAFN_ANFDE_Click(object sender, EventArgs e)
        {
            try
            {
                TrasnformaAFND_AFD t = new TrasnformaAFND_AFD();

                t.AutomatoOriginal = AutomatoInstanciado;
                t.Tentativa3();

                AutomatoInstanciado = t.AutomatoNovo;

                AtualizaAutomato();
            }
            catch (Exception err) {
                MessageBox.Show(err.Message);
            }
        }
Esempio n. 7
0
        public Automato Convert(Automato original)
        {
            if (original == null || original.EstadoInicial == null)
            {
                throw new Exception("Estado inicial não definido.");
            }

            AutomatoOriginal = original;

            Estado ini = original.EstadoInicial;

            AutomatoNovo = new Automato();
            //A única coisa que vem do automato anterior é o estado inicial.
            //O resto deve ser criado na medida do necessário


            // ini.EstadosOrigem.Add(ini.Nome);
            return(null);
        }
Esempio n. 8
0
        public Automato ConvertSaveDataAutomato(SaveDataAutomato sa)
        {
            Automato aut = new Automato();

            foreach (string s in sa.Alfabeto)
            {
                Simbolo si = new Simbolo(s);
                aut.Alfabeto.Add(s, si);
            }

            foreach (string estado in sa.Estados)
            {
                Estado e = new Estado(estado);
                e.isFinal   = sa.EstadosFinais.Contains(estado);
                e.isInicial = sa.EstadoInicial == estado;
                aut.Estados.Add(estado, e);
            }

            foreach (Estado e in aut.Estados.Values)
            {
                foreach (SaveDataTransicao t in sa.Transicoes)
                {
                    if (t.EstadoOrigem == e.Nome)
                    {
                        Transicao tr = new Transicao(e);
                        tr.Simbolo = aut.Alfabeto[t.Simbolo];
                        foreach (string d in t.EstadosDestino)
                        {
                            tr.EstadosDestino.Add(aut.Estados[d]);
                        }
                        e.Transicoes.Add(tr.Simbolo.simbolo, tr);
                    }
                }
            }

            if (sa.EstadoInicial != null && sa.EstadoInicial != "")
            {
                aut.EstadoInicial = aut.Estados[sa.EstadoInicial];
            }
            return(aut);
        }
Esempio n. 9
0
        public void Tentativa3()
        {
            AutomatoNovo = new Automato();

            AutomatoNovo.Alfabeto = AutomatoOriginal.Alfabeto;

            if (AutomatoOriginal.EstadoInicial == null)
            {
                throw new Exception("Estado inicial não definido.");
            }

            Estado novoini = new Estado(AutomatoOriginal.EstadoInicial.Nome);

            novoini.isInicial = true;
            novoini.EstadosUnificados.Add(novoini.Nome);
            EstadosNovos.Add(novoini.Nome, novoini);
            AutomatoNovo.EstadoInicial = novoini;
            ProxEst1(novoini);

            AutomatoNovo.Estados = EstadosNovos;
        }
Esempio n. 10
0
        public SaveDataAutomato ConvertAutomato(Automato aut)
        {
            SaveDataAutomato sa = new SaveDataAutomato();

            foreach (Estado e in aut.Estados.Values)
            {
                sa.Estados.Add(e.Nome);
                if (e.isFinal)
                {
                    sa.EstadosFinais.Add(e.Nome);
                }
                foreach (Transicao t in e.Transicoes.Values)
                {
                    SaveDataTransicao st = new SaveDataTransicao();
                    st.EstadoOrigem = e.Nome;
                    foreach (Estado ee in t.EstadosDestino)
                    {
                        st.EstadosDestino.Add(ee.Nome);
                    }
                    st.Simbolo = t.Simbolo.simbolo;
                    sa.Transicoes.Add(st);
                }
            }

            if (aut.EstadoInicial != null)
            {
                sa.EstadoInicial = aut.EstadoInicial.Nome;
            }

            foreach (Simbolo s in aut.Alfabeto.Values)
            {
                sa.Alfabeto.Add(s.simbolo);
            }

            return(sa);
        }
Esempio n. 11
0
        public Estado ProxEst(Estado e, Simbolo s, Automato aut)
        {
            //Procura todos destinos para a consulta atual
            List <Estado> dest = aut.getEstadosDestinos(e.EstadosUnificados, s);


            bool EhFinal = false;

            foreach (Estado eee in dest)
            {
                if (eee.isFinal)
                {
                    EhFinal = true;
                    break;
                }
            }


            if (dest.Count == 0)
            {
                return(null);
            }

            //Gera o nome do novo estado
            string nomestados = getStringEstado(dest);

            Estado estadonovo;

            //Verifica se o novo estado já foi criado

            //Se ainda não foi, o novo estado é criado
            if (EstadosNovos.ContainsKey(nomestados))
            {
                estadonovo = EstadosNovos[nomestados];
            }
            else
            {
                estadonovo = new Estado(nomestados);
            }

            estadonovo.isFinal |= EhFinal;

            //Os estados unificados do pai são guardados no novo estado gerado.
            estadonovo.EstadosGerador_Pais = e.EstadosUnificados;

            //Os estados que foram referenciados para montar este são guardados.
            estadonovo.EstadosUnificados = getEstadosOrigem(dest);

            //As as transições do estado criador são apagadas.
            //    e.Transicoes.Clear();


            //Um única nova transição é criada
            Transicao nova = new Transicao(e);

            nova.EstadosDestino.Add(estadonovo);//O estado novo será destruido mais adiantes, corrigir as referências
            nova.Simbolo = s;

            //A transição é adicionada para o simbolo que está sendo pesquisado.
            e.Transicoes.Add(s.simbolo, nova);

            return(estadonovo);
        }
Esempio n. 12
0
 private void novoToolStripMenuItem_Click(object sender, EventArgs e)
 {
     AutomatoInstanciado = new Automato();
     AtualizaAutomato();
 }