public ExpresionRegular(string id)
{
this.id = id;
this.simbolos = new Stack <object[]>();
this.afn = new SubAFN();
afd = new Transicion();
}
public SubAFN crearPositiva(SubAFN basico)
{
SubAFN b1 = new SubAFN();
foreach (Estado e in basico.getEstados())
{
int en = e.getId();
Estado aux = new Estado(en);
foreach (TransicionThompson t in e.getTransiciones())
{
int ti = t.getInicio().getId();
Estado temp = new Estado(ti);
int tf = t.getFinal().getId();
Estado temp1 = new Estado(tf);
string l = t.getLexema();
aux.setTransicion(new TransicionThompson(temp, temp1, l));
}
b1.setEstado(aux);
}
b1.setInicial(b1.getEstado(0));
b1.setFinal(b1.getEstado(b1.getEstados().Count - 1));
SubAFN kleene = this.crearKleene(basico);
return(this.crearConcatenacion(b1, kleene));
}
public SubAFN crearOr(SubAFN basico1, SubAFN basico2)
{
SubAFN b1 = nuevo(basico1);
SubAFN b2 = nuevo(basico2);
SubAFN or = new SubAFN();
Estado inicial = new Estado(0);
inicial.setTransicion(new TransicionThompson(inicial, b1.getInicial(), "ε"));
inicial.setTransicion(new TransicionThompson(inicial, b2.getInicial(), "ε"));
or.setEstado(inicial);
or.setInicial(inicial);
int e = 0;
int basico1tam = b1.getEstados().Count;
int basico2tam = b2.getEstados().Count;
for (e = 0; e < basico1tam; e++)
{
Estado aux = b1.getEstado(e);
aux.setId(e + 1);
foreach (TransicionThompson t in aux.getTransiciones())
{
t.getInicio().setId(e + 1);
t.getFinal().setId(t.getFinal().getId() + 1);
}
or.setEstado(aux);
}
int tf = e + 1;
for (int i = 0; i < basico2tam; i++)
{
Estado aux = b2.getEstado(i);
aux.setId(e + 1);
foreach (TransicionThompson t in aux.getTransiciones())
{
t.getInicio().setId(e + 1);
t.getFinal().setId(t.getFinal().getId() + tf);
}
or.setEstado(aux);
e++;
}
Estado final = new Estado(basico1tam + basico2tam + 1);
or.setFinal(final);
or.setEstado(final);
Estado basico1fin = b1.getFinal();
Estado basico2fin = b2.getFinal();
basico1fin.setTransicion(new TransicionThompson(basico1fin, final, "ε"));
basico2fin.setTransicion(new TransicionThompson(basico2fin, final, "ε"));
return(or);
}
public SubAFN crearBasico(string simbolo)
{
SubAFN basico = new SubAFN();
Estado ini = new Estado(0);
Estado fin = new Estado(1);
TransicionThompson transicion = new TransicionThompson(ini, fin, simbolo);
ini.setTransicion(transicion);
basico.setEstado(ini);
basico.setEstado(fin);
basico.setInicial(ini);
basico.setFinal(fin);
return(basico);
}
public SubAFN crearKleene(SubAFN basico)
{
SubAFN b = nuevo(basico);
int tam = b.getEstados().Count;
SubAFN kleene = new SubAFN();
Estado inicio = new Estado(0);
kleene.setEstado(inicio);
kleene.setInicial(inicio);
for (int i = 0; i < tam; i++)
{
Estado aux = b.getEstado(i);
aux.setId(i + 1);
foreach (TransicionThompson t in b.getEstado(i).getTransiciones())
{
t.getInicio().setId(i + 1);
t.getFinal().setId(t.getFinal().getId() + 1);
}
if (i == 0)
{
b.setInicial(aux);
}
if (i == tam - 1)
{
b.setFinal(aux);
}
kleene.setEstado(aux);
}
Estado fin = new Estado(tam + 1);
kleene.setEstado(fin);
kleene.setFinal(fin);
Estado inibasico = b.getInicial();
Estado finbasico = b.getFinal();
inicio.setTransicion(new TransicionThompson(inicio, inibasico, "ε"));
inicio.setTransicion(new TransicionThompson(inicio, fin, "ε"));
finbasico.setTransicion(new TransicionThompson(finbasico, inibasico, "ε"));
finbasico.setTransicion(new TransicionThompson(finbasico, fin, "ε"));
return(kleene);
}
public SubAFN nuevo(SubAFN b)
{
SubAFN b1 = new SubAFN();
foreach (Estado e in b.getEstados())
{
int en = e.getId();
Estado aux = new Estado(en);
foreach (TransicionThompson t in e.getTransiciones())
{
Estado temp = new Estado(en);
int tf = t.getFinal().getId();
Estado temp1 = new Estado(tf);
string l = t.getLexema();
aux.setTransicion(new TransicionThompson(temp, temp1, l));
}
b1.setEstado(aux);
}
b1.setInicial(b1.getEstado(0));
b1.setFinal(b1.getEstado(b1.getEstados().Count - 1));
return(b1);
}
public SubAFN crearConcatenacion(SubAFN basico1, SubAFN basico2)
{
SubAFN conc2 = nuevo(basico2);
SubAFN concatenacion = new SubAFN();
int e = 0;
for (e = 0; e < basico1.getEstados().Count - 1; e++)
{
Estado aux = basico1.getEstado(e);
aux.setId(e);
if (e == 0)
{
concatenacion.setInicial(aux);
}
concatenacion.setEstado(aux);
}
int tf = e - conc2.getEstado(0).getId();
for (int i = 0; i < conc2.getEstados().Count; i++)
{
Estado aux = conc2.getEstado(i);
aux.setId(e);
foreach (TransicionThompson t in aux.getTransiciones())
{
t.getInicio().setId(e);
t.getFinal().setId(t.getFinal().getId() + tf);
}
if (i == conc2.getEstados().Count - 1)
{
concatenacion.setFinal(aux);
}
concatenacion.setEstado(aux);
e++;
}
return(concatenacion);
}
public void crearTransiciones(SubAFN afn, Stack <object[]> simbolos)
{
EstadoAFD nuevo = new EstadoAFD(0);
nuevo.setCerradura(0);
estados.Add(nuevo);
for (int e = 0; e < estados.Count; e++)
{
for (int i = 0; i < estados[e].getCerraduras().Count; i++)
{
Estado est = afn.getEstado(estados[e].getCerradura(i)); //entra al estado que indica la cerradura
if (estados[e].getCerradura(i) == afn.getFinal().getId())
{
estados[e].setAcepta();
}
foreach (TransicionThompson t in est.getTransiciones())
{
if (t.getLexema().Equals("ε") && !estados[e].encontrarC(t.getFinal().getId()))
{
estados[e].setCerradura(t.getFinal().getId());
if (t.getFinal().getId().Equals(afn.getFinal().getId()))
{
estados[e].setAcepta();
}
}
else if (!t.getLexema().Equals("ε"))
{
int m = encontrarMovimiento(t.getLexema(), estados[e]);
if (m == estados[e].getMovimiento().Count) //si el mover con dicho simbolo no existe
{
Movimiento mov = new Movimiento(t.getLexema(), encontrarSimbolo(simbolos, t.getLexema()));
mov.getMov().setCerradura(t.getFinal().getId());
mov.setMove(t.getFinal().getId());
estados[e].setMovimiento(mov);
}
else // si ya existe, se agrega a que otro estado se puede mover con la misma letra
{
estados[e].getMov(m).getMov().setCerradura(t.getFinal().getId());
estados[e].getMov(m).setMove(t.getFinal().getId());
estados[e].getMov(m).getMov().getCerraduras().Sort();
}
}
}
}
estados[e].getCerraduras().Sort();
int edo = encontrarEstado(estados[e].getCerraduras(), e);
if (edo != e)
{
estados.RemoveAt(e);
e--;
}
else
{
for (int t = 0; t < estados[e].getMovimiento().Count; t++)
{
int m = encontrarMovEstado(estados[e].getMov(t).getMoves(), e);
if (m != -1)
{
estados[e].getMov(t).getMov().setId(m);
}
else
{
EstadoAFD n = estados[e].getMov(t).getMov();
n.setId(estados.Count);
estados.Add(n);
}
}
}
}
}
public void setAFN(SubAFN afn)
{
this.afn = afn;
}
public SubAFN crearUnaoNinguna(SubAFN basico)
{
SubAFN ningun = this.crearBasico("ε");
return(this.crearOr(basico, ningun));
}
