string getnumeroProd(string s, int v, int [] ikeys)
{ //retorna el # de la produccion de la cadena enviada, asumiendo que se envia <id>
try
{
int produccion = v;
foreach (int item in ikeys)
{//numero, no terminal, first, produccion
ElementoProduccion iterator = this.ContenidoProduccion [item];
string keu = iterator.Get_llave().ToLower();
if (keu.CompareTo(s) == 0)
{
return(produccion.ToString());
}
string aux = iterator.EnqNivelLoPosee(s, produccion);
produccion = Convert.ToInt32(aux) - 1;
}
return(produccion.ToString());
}
catch (Exception)
{
return("");
throw;
}
}
int Get_No_SiguienteProduccionRepetida(int intllave, string palabra)
{
int resp = 1;
int [] llaves = this.ContenidoProduccion.Keys.ToArray();
foreach (int i in llaves)
{
ElementoProduccion iterator = this.ContenidoProduccion [i];
if (iterator.Get_llave().ToLower().CompareTo(palabra) == 0 && intllave == i)
{
return(resp);
}
resp = iterator.Calculador_de_nivelesV2(resp);
resp++;
}
return(resp);
}
void ArreglarContenido()
{ //metodo para arreglar el contenido
int [] llaves = this.ContenidoProduccion.Keys.ToArray(); //copia de las llaves
foreach (int i in llaves)
{
ElementoProduccion iterator = this.ContenidoProduccion [i];
string s = iterator.Get_llave();
if (s.CompareTo("<start>") == 0)
{
keystart.Add(i);
}
else
{
keynostart.Add(i);
}
}
Dictionary <int, ElementoProduccion> nuevo = new Dictionary <int, ElementoProduccion>();
List <int> temp1 = new List <int>();
List <int> temp2 = new List <int>();
int llavesStar = 1; //comienza a asignar desde 1 a las producciones que comeincen con start
int llaves_Sin_Star = keystart.Count() + 1; //contador de llaves sin <Start>, inician despues de contar cuantas producciones poseen start
foreach (int i in llaves)
{
if (keystart.Contains(i))
{
nuevo.Add(llavesStar, this.ContenidoProduccion [i]);
temp1.Add(llavesStar);
llavesStar++;
}
else
{
nuevo.Add(llaves_Sin_Star, this.ContenidoProduccion [i]);
temp2.Add(llaves_Sin_Star);
llaves_Sin_Star++;
}
}
this.ContenidoProduccion = nuevo;
this.keystart.Clear();
this.keynostart.Clear();
this.keystart = temp1; //se asignan las nuevas llaves a las listas de control
this.keynostart = temp2; //para las que poseen las llaves de los que tienen start y los que no
}
public Dictionary <string, List <string> > CalcularFirst()
{ //metodo para el inicio del calculo del first
ELEMENTOS_y_Fisrt Lista_Elemtos_y_First = new ELEMENTOS_y_Fisrt(); //calse que maneja llave <[id=(string)],fisrt>, maneja las inserciones repetidas
ELEMENTOS_y_Fisrt Lista_Elemtos_y_First2 = new ELEMENTOS_y_Fisrt(); //calse que maneja llave <[id=(string)],fisrt>, maneja las inserciones repetidas
// y la sobrecarga del first, tanto como el first vacio u otros errores
int [] llaves = this.ContenidoProduccion.Keys.ToArray();
List <int> NoSimples = new List <int>();
foreach (int item in llaves)//se mandan a calcular los que tienen first simple
{
ElementoProduccion iterator = this.ContenidoProduccion [item];
if (iterator.SFrist())// si la produccion posee un first simple, calcular fisrt simples primero
{
List <string> firstSimple = iterator.CalcularFirstSimple().ToList <string>();
iterator.set_My_Fisrt(firstSimple);
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), firstSimple.ToList());
}
else
{
NoSimples.Add(item);//seguardan las llaves de las producciones que no lo contiene de manera simple
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
bool cambio = true;
while (cambio == true)
{
Lista_Elemtos_y_First2 = Lista_Elemtos_y_First.CompiaDeActual();
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //miemros si la lista cambio
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
if (Lista_Elemtos_y_First.EsigualAOtro(Lista_Elemtos_y_First2)) //para ver si dejara de calcularlo
{ //dejara de calcularlo hasta que la Lista_Elemtos_y_First antes de volverlo a calcular sea igual a la restualten despues de calcular
cambio = false;
}
}
List <string> anulables = Lista_Elemtos_y_First.Los_anulables().ToList();// porque ya se tiene el first de todos los complejos sin ver anulables
cambio = true;
while (cambio == true)//calculo hasta que no haya anulables
{
Lista_Elemtos_y_First2 = Lista_Elemtos_y_First.CompiaDeActual();
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //miemros si la lista cambio
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GetpenFirst2(anulables).ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
if (Lista_Elemtos_y_First.EsigualAOtro(Lista_Elemtos_y_First2)) //para ver si dejara de calcularlo
{ //dejara de calcularlo hasta que la Lista_Elemtos_y_First antes de volverlo a calcular sea igual a la restualten despues de calcular
cambio = false;
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
foreach (int item in NoSimples) //calculamos el first por individual de cada complejo
{ //calculo inicial
ElementoProduccion iterator = this.ContenidoProduccion [item];
String [] pendientes = iterator.GpendFirst().ToArray();
foreach (string i in pendientes)
{
if (this.bRango(i))
{
Lista_Elemtos_y_First.set_elementos(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(i));
}
else
{
Lista_Elemtos_y_First.set_elemento(iterator.Get_llave(), i);
}
}
}
Dictionary <string, List <string> > FirstResultantes = new Dictionary <string, List <string> >();
foreach (int item in llaves)//se mandan a calcular los que tienen first simple
{
ElementoProduccion iterator = this.ContenidoProduccion [item];
if (!FirstResultantes.ContainsKey(iterator.Get_llave()))
{
if (iterator.Get_llave().CompareTo("<start>") == 0)
{
string [] elements = Lista_Elemtos_y_First.Get_First_de_un_elemento(iterator.Get_llave()).ToArray();
List <string> sinEpsilon = new List <string>();
string epsilon = Convert.ToString("ԑ");
foreach (string s in elements)
{
/// if (s.CompareTo(epsilon) != 0)
///{
sinEpsilon.Add(s);
///}
}
FirstResultantes.Add(iterator.Get_llave(), sinEpsilon.ToList());
}
else
{
FirstResultantes.Add(iterator.Get_llave(), Lista_Elemtos_y_First.Get_First_de_un_elemento(iterator.Get_llave()).ToList());
}
}
}
return(FirstResultantes);
}
public Dictionary <int, int> CalcularProducciones()
{
int [] llaves = this.ContenidoProduccion.Keys.ToArray(); //contiene todo sobre las llaves, sin importar si es o no repetida
Dictionary <int, string> datos = new Dictionary <int, string>(); //no repetidos
List <int> intsubllaves = new List <int>(); //llaves enteras de los elementos no repetidos
List <int> intLlavesDeLosRepetidos = new List <int>(); //llaves int de los repetidos
List <string> subllaves = new List <string>(); //llaves de los elementos no repetidos
List <string> llavesStrdelosRepetidos = new List <string>(); //llaves de los repetidos
Dictionary <int, int> RESPUESTA = new Dictionary <int, int>();
foreach (int item in llaves)
{ //se leen las producciones y se obtienen por separado las llaves de los no repetidos y de los repetidos, pero loas llaves <id> del diccionario
ElementoProduccion iterator = this.ContenidoProduccion [item];
string s = iterator.Get_llave(); //la llave que devuelve es el <id> en minusculas
if (!datos.ContainsValue(s))
{
datos.Add(item, s);
subllaves.Add(s);//datos incertados si aparecen almenos 1 vez
intsubllaves.Add(item);
}
else
{
llavesStrdelosRepetidos.Add(s);
intLlavesDeLosRepetidos.Add(item);
}
}
int c = 1;//lleva el conteo de la produccion
//se calcula la siguiente produccion
foreach (int item in llaves)
{ //volvemos a leer todas las producciones de la gramatica
ElementoProduccion iterator = this.ContenidoProduccion [item];
string s = iterator.Get_llave(); //la llave que devuelve es el <id> en minusculas
if (llavesStrdelosRepetidos.Contains(s)) //si las tiene se procede a calcular como llave de los repetidos
{
string [] StrsRepetidos = llavesStrdelosRepetidos.ToArray();
int [] llaverepetidas = intLlavesDeLosRepetidos.ToArray();
int j = 0;
bool Inserto = false;
foreach (string strReps in StrsRepetidos)
{
if (strReps.CompareTo(s) == 0 && Inserto == false)
{
int V = this.Get_No_SiguienteProduccionRepetida(llaverepetidas [j], StrsRepetidos [j]);
if (iterator.Get_Cantidad_de_niveles() == 1)
{
RESPUESTA.Add(c, V);
}
else
{ //cuando tiene mas de un nivel
char separador = Convert.ToChar(1333);
string [] r = iterator.Get_SiguieteProduccionPara_repetidos(c, separador, V).Split(separador); //en el arreglo la ultima posicion es la del nivel actual
int newnivel = r.Length - 1; //obtiene la posicion del nivel
int contador = 0;
c = Convert.ToInt32(r [newnivel]);
foreach (string ix in r)
{
if (contador < r.Length && ix != "")
{
string [] s1 = r [contador].Split(' ');//primera pos es el nivel, siguiente es quien le toca
if (s1.Length != 1)
{
RESPUESTA.Add(Convert.ToInt32(s1 [0]), Convert.ToInt32(s1 [1]));
}
}
contador++;
}
}
llavesStrdelosRepetidos.Remove(StrsRepetidos [j]);//PARA QUE QUITE LOS REPETIDOS QUE YA UTILIZO
intLlavesDeLosRepetidos.Remove(llaverepetidas [j]);
Inserto = true;
}
j++;
}
}
else
{
#region se calcula como llave de los no repetidos
if (iterator.Get_Cantidad_de_niveles() == 1)//si es una declarasion sin | y que no este repetida
{
RESPUESTA.Add(c, 0);
}
else
{ //es cuando nopesee almenos otro nivel y no se repite
char separador = Convert.ToChar(1333);
string [] r = iterator.Get_SiguieteProduccionPara_No_repetidos(c, separador).Split(separador); //en el arreglo la ultima posicion es la del nivel actual
int newnivel = r.Length - 1; //obtiene la posicion del nivel
int contador = 0;
c = Convert.ToInt32(r [newnivel]);
foreach (string ix in r)
{
if (contador < r.Length && ix != "")
{
string [] s1 = r [contador].Split(' ');//primera pos es el nivel, siguiente es quien le toca
if (s1.Length != 1)
{
RESPUESTA.Add(Convert.ToInt32(s1 [0]), Convert.ToInt32(s1 [1]));
}
}
contador++;
}
}
#endregion
}
c++;
}
return(RESPUESTA);
}
public List <string> CalcularNT()
{//metodo a corregir metodo a veces funciona a veces no
int [] llaves = this.ContenidoProduccion.Keys.ToArray();
Dictionary <int, string> datos = new Dictionary <int, string>();
List <string> resp = new List <string>();
List <string> pendientes = new List <string>();
List <int> subllaves = new List <int>();
foreach (int item in llaves)
{
ElementoProduccion iterator = this.ContenidoProduccion [item];
string s = iterator.Get_llave();//la llave que devuelve es el <id> en minusculas
if (!datos.ContainsValue(s))
{
datos.Add(item, s);
subllaves.Add(item);
}
}
Dictionary <string, List <string> > LISTAFIRST = this.CalcularFirst();
foreach (int item in subllaves)
{//se asignan a los que ya fueron instanciados en la gramatica en formato numero, no terminal, first, produccion
List <string> first = LISTAFIRST [datos [item].ToString()];
string FIRST = firstDatos(first);
string s = item.ToString() + '‡' + datos [item].ToString() + '‡' + FIRST + '‡' + " ";
resp.Add(s);
}
int [] ar1 = subllaves.ToArray();
int subllaveError = -1;
foreach (int i in ar1)
{
if (i > subllaveError)
{
subllaveError = i;
}
}
if (subllaveError < 0)
{
subllaveError = 0;
}
subllaveError++; //sieguiente llave para los pendientes o los de error, como los quiera ver uno
foreach (string item in resp)
{ //para obtener los <pendientes>, los que no se declararon con ->
String [] r = item.Split('‡');
int i = Convert.ToInt32(r [0]);
ElementoProduccion iterator = this.ContenidoProduccion [i];
List <string> contenido = iterator.listagetcontenido();
foreach (string x in contenido)
{
bool b = (this.bRango(x));
if (b == true && datos.Values.Contains(x) == false && pendientes.Contains(x) == false)
{
pendientes.Add(x);
}
}
}
String [] raux = pendientes.ToArray();
int c = 0;
foreach (string i in raux)
{
raux [c] = subllaveError.ToString() + '‡' + raux [c] + '‡' + " " + '‡' + "ERROR";
subllaveError++;
c++;
}
pendientes.Clear();
pendientes = raux.ToList();
c = 1;
//calular la produccion de los demas
string [] subresp = resp.ToArray();
int icc = 0;
foreach (string st in subresp) //dentro de un foreach para que lo haga con cada elemetno
{
string [] myr = st.Split('‡'); //
myr [3] = getnumeroProd(myr [1], c, llaves);
subresp [icc] = myr [0] + '‡' + myr [1] + '‡' + myr [2] + '‡' + myr [3];
Valores.Add(myr [1], Convert.ToInt32(myr [0]));
icc++;
c++;
}
//luego aca concatenar y retornar
resp.Clear();
resp = subresp.ToList();
resp = this.OrdenarResp(resp);
string [] pendientealfinal = pendientes.ToArray();
foreach (string i in pendientealfinal)
{
string [] myr = i.Split('‡');
Valores.Add(myr [1], Convert.ToInt32(myr [0]));
resp.Add(i);
}
return(resp);
}
