static bool VerificaPalavra(string palavra, AFN afn)
{
var estadosAux = new List <Estado>();
/* Adicionamos o estado inicial na lista de estados
* auxiliar para começar a verificação */
estadosAux.Add(afn.EstadoInicial);
foreach (char simbolo in palavra)
{
/* Buscamos os estados que possuem transição com o
* simbolo 'simbolo' partindo da lista de estados 'estadosAux' */
estadosAux = Movimento(estadosAux, simbolo);
/* Se a lista de estados for
* vazia a resposta será negativa */
if (!estadosAux.Any())
{
return(false);
}
}
var resultado = false;
var estadosFinais = afn.EstadosFinais;
foreach (var estado in estadosAux)
{
/* Verificamos se o estado está na lista de estados finais
* Caso esteja, resultado = true */
resultado = resultado || estadosFinais.Any(x => x.Nome == estado.Nome);
}
return(resultado);
}
/* Instanciando o autômato na mão */
static void Exemplo1()
{
var no1 = new Estado("1", false);
var no2 = new Estado("2", false);
var no3 = new Estado("3", false);
var no4 = new Estado("4", false);
var no5 = new Estado("5", true);
var listaEstados = new List <Estado> {
no1, no2, no3, no4, no5
};
/* Arestas do No1 */
var aresta1 = new Aresta('a', no2);
no1.Arestas.Add(aresta1);
/* Arestas do No1 */
var aresta2 = new Aresta('b', no1);
var aresta3 = new Aresta('a', no3);
var aresta4 = new Aresta('a', no4);
no2.Arestas.Add(aresta2);
no2.Arestas.Add(aresta3);
no2.Arestas.Add(aresta4);
/* Arestas do No3 */
var aresta5 = new Aresta('b', no4);
no3.Arestas.Add(aresta5);
/* Arestas do No4 */
var aresta6 = new Aresta('a', no5);
no4.Arestas.Add(aresta6);
var simbolosAceitos = new List <char> {
'a', 'b'
};
var afn = new AFN(listaEstados, no1, simbolosAceitos);
/* Função Pe */
var resultado1 = VerificaPalavra("aab", afn);
Console.WriteLine($"Palavra: aab -> {(resultado1 ? "ACEITA" : "NÃO ACEITA")}");
var resultado2 = VerificaPalavra("baaa", afn);
Console.WriteLine($"Palavra: baaa -> {(resultado2 ? "ACEITA" : "NÃO ACEITA")}");
var resultado3 = VerificaPalavra("aaa", afn);
Console.WriteLine($"Palavra: aaa -> {(resultado3 ? "ACEITA" : "NÃO ACEITA")}");
var resultado4 = VerificaPalavra("abababaaa", afn);
Console.WriteLine($"Palavra: abababaaa -> {(resultado4 ? "ACEITA" : "NÃO ACEITA")}");
}
static void Main(string[] args)
{
String afnTeste = "AB*";
AFN afn = new AFN(afnTeste);
Console.WriteLine("AFN Estado gerados algoritmo de Thompson da expressão: " + afnTeste);
Console.WriteLine("Estado inicial: " + afn.getEstadoIni().getNomeEstado());
Console.WriteLine("Estado final: " + afn.getEstadoFim().getNomeEstado() + "\n");
estados = afn.getEstado();
for (int i = 0; i < estados.Count; i++)
{
List <iTransicao> t = estados[i].getTransicoes();
Console.WriteLine(estados[i].getNomeEstado());
for (int x = 0; x < t.Count; x++)
{
Console.WriteLine("Objeto Transito: \n\t\t>>Pai " + t[x].getPai().getNomeEstado());
Console.WriteLine("\t\t>>" + t[x].getNomeTransicao());
Console.WriteLine("\t\t>><Próx>" + t[x].getProxEstado().getNomeEstado());
}
}
Console.ReadKey();
}
public virtual string ReadMsg()
{
string msg = "";
if (RawDataChar == null)
{
return("无数据");
}
if (RawDataChar.Length >= 14)
{
if (RawDataChar[0] == BaseProtocol.BeginChar && RawDataChar[RawDataChar.Length - 1] == BaseProtocol.EndChar)
{
Length = (int)RawDataChar[1];
byte[] Body_b = new byte[Length];
byte bState = RawDataChar[2];
IsPW = bState % 2 > 0;
IsTP = bState % 4 > 2;
Array.Copy(RawDataChar, 3, Body_b, 0, Body_b.Length);
CC = RawDataChar[RawDataChar.Length - 2];
AFN = RawDataChar[14];
byte CCN = FormatHelper.GetXorByte(Body_b, 0, Body_b.Length);
string s = "CCN = " + CCN + " Length = " + Length + " body_b .length is " + Body_b.Length;
//update by kqz 2017-10:40 解决文件下发问题
if ((AFN == (byte)BaseProtocol.AFN.ToDtuSendFile) || (CCN == CC))
{
ControlField = RawDataChar[3];
//if (ControlField == (byte)BaseProtocol.ControlField.FromDtu)
if (Enum.IsDefined(typeof(BaseProtocol.ControlField), (int)ControlField))
{
StationType = RawDataChar[11];
StationCode = Convert.ToInt32(HexStringUtility.ByteArrayToHexString(new byte[] { RawDataChar[12], RawDataChar[13] }), 16);
AFN = RawDataChar[14];
if (Enum.IsDefined(typeof(BaseProtocol.AFN), (int)AFN))
{
byte[] AddressField_b = new byte[7];
Array.Copy(RawDataChar, 4, AddressField_b, 0, 7);
AddressField = HexStringUtility.ByteArrayToHexString(AddressField_b);
//用户数据长度为长度减控制域1字节减地址域7字节减应用层功能码1字节减设备类型1字节减射频地址2字节减密码减时间戳
UserDataBytes = new byte[Length - 1 - 7 - 1 - 1 - 2 - (IsTP ? 2 : 0) - (IsPW ? 5 : 0)];
Array.Copy(RawDataChar, 15, UserDataBytes, 0, UserDataBytes.Length);
UserData = HexStringUtility.ByteArrayToHexString(UserDataBytes);
try
{
if (IsTP)
{
byte[] TPBytes = new byte[5];
Array.Copy(RawDataChar, RawDataChar.Length - 2 - 5, TPBytes, 0, TPBytes.Length);
TP = HexStringUtility.ByteArrayToHexString(TPBytes);
}
if (IsPW)
{
byte[] PWBytes = new byte[2];
Array.Copy(RawDataChar, RawDataChar.Length - 2 - 2 - (IsTP ? 5 : 0), PWBytes, 0, PWBytes.Length);
PW = HexStringUtility.ByteArrayToHexString(PWBytes);
}
}
catch
{
msg = "密码时间戳格式不正确，IsPW：" + (IsPW ? "yes" : "no") + "，IsTP：" + (IsTP ? "yes" : "no");
}
}
else
{
msg = "功能码不对，" + AFN.ToString("X");
}
}
else
{
msg = "控制域不对，" + ControlField.ToString("X");
}
}
else
{
msg = s + " 校验码不对，" + CC;
}
}
else
{
msg = "开始结束字符不对，" + RawDataChar[0].ToString("X") + " " + RawDataChar[RawDataChar.Length - 1].ToString("X");
}
}
else
{
msg = "长度不足14，" + RawDataChar.Length;
}
return(msg);
}
/* Lendo de um arquivo JSON */
static void Exemplo2()
{
/* Realizamos a leitura do JSON e carregamos no objeto afnLeitura utilizando a classe AFNLeitura */
var arquivoText = File.ReadAllText(@"C:/Users/Vinicius/Downloads/Teste.json");
var afnLeitura = JsonConvert.DeserializeObject <AFNLeitura>(arquivoText);
/* Criamos os estados */
var estados = afnLeitura.Estados.Select(x => new Estado(x, false)).ToList();
/* Atualizamos os estados que são estados finais */
foreach (var noFinailAux in afnLeitura.EstadosFinais)
{
var estadoAux = estados.Find(x => x.Nome == noFinailAux);
estadoAux.NoFinal = true;
}
var arestas = new List <Aresta>();
/* Preenchemos a lista de arestas */
foreach (var arestaAux in afnLeitura.FuncaoPrograma)
{
var noOrigem = estados.Find(x => x.Nome == arestaAux.Origem);
var noDestino = estados.Find(x => x.Nome == arestaAux.Destino);
var simbolo = arestaAux.Simbolo;
var arestaInserir = new Aresta(simbolo, noDestino);
noOrigem.Arestas.Add(arestaInserir);
}
/* Buscamos o nó inicial a partir da lista de estados */
var noInicial = estados.Find(x => x.Nome == afnLeitura.EstadoInicial);
/* Instanciamos o AFN */
var afn = new AFN(estados, noInicial, afnLeitura.Simbolos);
var keepRunning = true;
if (afn.IsValid)
{
Console.WriteLine("AFN: " + afnLeitura.ToString());
var input = string.Empty;
while (keepRunning)
{
Console.WriteLine("Digite a palavra que deseja testar (Para sair, digite -1): ");
input = Console.ReadLine();
if (input.Contains("-1"))
{
keepRunning = false;
}
else
{
/* Função Pe */
var resultado = VerificaPalavra(input, afn);
Console.WriteLine($"Palavra: {input} -> {(resultado ? "ACEITA" : "NÃO ACEITA")}");
}
}
Console.WriteLine("Finalizando programa :)");
}
else
{
Console.WriteLine("O AFN inserido não é válido!");
}
}
public void Insert(String name, ArrayList ar, String path)
{
ArrayList vuelta = new ArrayList(); // array que va a almacenar los elementos en orden inverso
for (int i = ar.Count - 1; i >= 0; i--)
{
vuelta.Add(ar[i]);
NodeController.getInstancia().InsertStack(ar[i].ToString());
}
String ast = "";
foreach (var item in vuelta)
{
ast = ast + " " + item;
}
Console.WriteLine(ast);
RegularExpression re = new RegularExpression(name, vuelta);
arrayListER.Add(re);
NodeController.getInstancia().Print(name, path);
//Convierte la expresion regular de prefija a pos
ArrayList regularExpresion = NodeController.getInstancia().ConvertExpression(NodeController.getInstancia().getRoot());
ArrayList regex = new ArrayList();
try
{
regex = RegexController.Instance.infixToPostfix(regularExpresion);
}
catch (Exception a)
{
Console.WriteLine("Expresión mal ingresada");
}
string st = "";
foreach (var item in regularExpresion)
{
st = st + item;
}
Console.WriteLine(name + "->" + st);
//CONSTRUYE EL AUTOMATA ANF
AFN aFN = new AFN();
aFN.construirAutomata(regex);
Automata.Automata afn_result = aFN.Afn;
ThompsonControlador.Instance.generarDOT("AFN", name, afn_result);
InsertAutomataAFNName("AFN " + name);
//CONSTRUYE EL AUTOMATA AFD
AFD AFD = new AFD();
AFD.conversionAFN(afn_result);
Automata.Automata afd_result = AFD.Afd;
//CONSTRUYE EL AUTOMATA SIN ESTADO STRAMPA
Automata.Automata afd_trampa = AFD.RemoveCheatStates(afd_result);
ThompsonControlador.Instance.generarDOT("AFD", name, afd_trampa);
InsertAutomataAFDName("AFD " + name);
//CONSTRUYE LA TABLA
ThompsonControlador.Instance.TableConstructor(name, path, afd_trampa);
InsertTablaName(name + "Table");
//ENVIA EL AUTOMATA A SER GUARDADO PARA POSTERIOR EVALUACION
EvaluatorController.Instance.Insert(name, afd_trampa);
NodeController.getInstancia().clearList();
}
private Transiciones transiciones; //Contendra las transiciones de para el AFD
public Thompson(List <Token> er, string nameEr)
{
this.er = er;
this.nameEr = nameEr;
raiz = create();
}
