public NT quitaPrimero()
{
NT tk = ltok[0];
ltok.RemoveAt(0);
return(tk);
}
//Este metodo se encarga de duplicar una produccion.
public Separa coprod()
{
Separa nr = new Separa();
Produccion np;
NT izq = new NT(ladoIzq.nom);
izq.NoTerminal();
izq.primero = ladoIzq.primero;
izq.siguiente = ladoIzq.siguiente;
foreach (Produccion paux in derecha)
{
np = paux.duprod();
nr.derecha.Add(np);
}
izq.listaP = nr.derecha;
nr.ladoIzq = izq;
nr.tksbusqueda = new Produccion();
if (tksbusqueda != null)
{
nr.tksbusqueda.agregafintk(tksbusqueda.ltok);
}
return(nr);
}
List <Separa> Buscasim(List <Separa> list, Separa sepreg)
{
List <Separa> listaux = new List <Separa>();
NT tkaux = sepreg.derecha[0].tksiguiente();
if (tkaux == null)
{
return(null);
}
else
{
for (int x = 0; x < list.Count(); x++)
{
if ((list[x].derecha[0].tksiguiente() != null) && (list[x].derecha[0].tksiguiente().nom == tkaux.nom))
{
listaux.Add(list[x]);
}
}
}
if (listaux.Count == 0)
{
return(null);
}
else
{
return(listaux);
}
}
//Metodo para agregar elementos iniciales.
public void addinic(NT X, List <NT> B, List <NT> buscar)
{
Separa nregla;
Separa aux;
Produccion nproduccion;
for (int x = 0; x < X.listaP.Count(); x++)
{
nregla = new Separa();
nproduccion = X.listaP[x].duprod();
nproduccion.quitatks("ε");
nproduccion.ponerpunto();
nregla.tksbusqueda = new Produccion();
nregla.derecha.Add(nproduccion);
nregla.ladoIzq = X;
Primeragrega(nregla, B, buscar);
aux = buscaregla(nregla, lreg);
if (aux == null)
{
lreg.Add(nregla);
}
else
{
aux.tksbusqueda.agconjunto(nregla.tksbusqueda.ltok);
}
}
}
public void ponerpunto()
{
NT aux = new NT(".");
aux.op(".");
ltok.Insert(0, aux);
}
//Metodo para verificar si un simbolo existe
public bool existes(string cad, CTK centrada)
{
NT n;
NT org = centrada.buscar(cad);
if (org == null)
{
org = centrada.buscar3(cad);
}
if (org == null)
{
org = centrada.buscar4(cad);
}
if (org == null)
{
org = centrada.buscar5(cad);
}
if (org == null)
{
org = centrada.buscar2(cad);
}
if (org != null)
{
n = org.copiar();
ltok.Add(n);
return(true);
}
else
{
return(false);
}
}
public NT removult()
{
int n = ltok.Count - 1;
NT tk = ltok[n];
ltok.RemoveAt(n);
return(tk);
}
public NT copiar()
{
NT copia = new NT(nom);
copia.esTerminal = esTerminal;
copia.oper = oper;
copia.nCol = nCol;
copia.valex = valex;
return(copia);
}
/// Este metodo elimina el primer Token en la lista de la Produccion.
public NT eliminaprim()
{
NT tk = null;
if (ltok.Count > 0)
{
tk = ltok[0];
ltok.RemoveAt(0);
}
return(tk);
}
//Este metodo crea la parte izquierda de la produccion, recibe una cadena de la cual se
//extraeran los tokens y una lista de tokens.
public bool partiz(string texto, CTK listokens)
{
ladoIzq = listokens.buscar(texto);
if (ladoIzq == null)
{
ladoIzq = new NT(texto);
listokens.agregaToken(ladoIzq);
}
ladoIzq.NoTerminal();
return(true);
}
//Este metodo se encarga de agregar tokens a la lista, mientras este no exsita previamente
//recibe como parametro el token a agregar y regresa si pudo agregarlo o no.
public bool agregaToken(NT tkn)
{
for (int x = 0; x < lista.Count; x++)
{
if (lista[x].nom == tkn.nom)
{
return(false);
}
}
lista.Add(tkn);
return(true);
}
//Metodo para crear nuevos tokens.
public void nuevotok(string stcrear, CTK ctks)
{
NT nuevo = ctks.buscar(stcrear);
if (nuevo != null)
{
ltok.Add(nuevo);
}
else
{
nuevo = new NT(stcrear);
ctks.agregaToken(nuevo);
ltok.Add(nuevo);
}
}
/// Este metodo agrega un Token a la produccion de Primero.
public bool agregatkprim(NT tk)
{
bool b = true;
foreach (NT k in ltok)
{
if (tk.nom == k.nom)
{
b = false;
break;
}
}
if (b == true)
{
agregarult(tk);
}
return(b);
}
//Regresa el token que esta depues del punto
public NT tksiguiente()
{
NT sig = null;
int act = 0;
for (int x = 0; x < ltok.Count; x++)
{
if (ltok[x].oper == ".")
{
act = x + 1;
if (act == ltok.Count)
{
return(null);
}
sig = ltok[act];
break;
}
}
return(sig);
}
//Regresa el token que esta antes del punto
public NT tkanterior()
{
NT auxant = null;
int act = 0;
for (int x = 0; x < ltok.Count; x++)
{
if (ltok[x].oper == ".")
{
act = x - 1;
if (act < 0)
{
return(null);
}
auxant = ltok[act];
break;
}
}
return(auxant);
}
public NT moverpunto()
{
NT aux = null;
int act = 0;
for (int x = 0; x < ltok.Count; x++)
{
if (ltok[x].oper == ".")
{
act = x;
aux = ltok[x];
break;
}
}
ltok.RemoveAt(act);
if (act + 1 == (ltok.Count + 1))
{
return(null);
}
ltok.Insert(act + 1, aux);
return(ltok[act]);
}
//Metodo para la regla 2 del AFD.
public void verel2()
{
NT A = null;
List <NT> B = new List <NT>();
bool resp = false;
for (int x = 0; x < lreg.Count; x++)
{
A = null;
B.Clear();
resp = false;
for (int o = 0; o < lreg[x].derecha[0].ltok.Count(); o++)
{
if (A != null)
{
B.Add(lreg[x].derecha[0].ltok[o]);
}
else
{
if (resp == true)
{
A = lreg[x].derecha[0].ltok[o];
}
if (lreg[x].derecha[0].ltok[o].oper == ".")
{
resp = true;
}
}
}
if ((A != null) && (A.esTerminal == false))
{
addinic(A, B, lreg[x].tksbusqueda.ltok);
}
}
}
//Este metodo agrega un Token al inicio de la lista de la Produccion.
public void agregarprim(NT tk)
{
ltok.Insert(0, tk);
}
/// Este metodo elimina un Toquen de la Produccion.
public void removertk(NT tk)
{
ltok.Remove(tk);
}
public Separa()
{
ladoIzq = null;
derecha = new List <Produccion>();
}
public Infoenla(AFD est, NT tk)
{
estAFD = est;
token = tk;
}
public void nuevo(NT tk)
{
ltok.Add(tk);
}
//Este metodo agrega un Token al final de la lista de la Produccion.
public void agregarult(NT tk)
{
ltok.Add(tk);
}
