示例#1
0
 public ActionResult DeleteConfirmed(decimal id)
 {
     funcion funcion = db.funcion.Find(id);
     db.funcion.Remove(funcion);
     db.SaveChanges();
     return RedirectToAction("Index");
 }
示例#2
0
        /// <summary>
        /// Crea la nueva función en la base de datos
        /// </summary>
        /// <returns>Retorna True si se creo correctamente</returns>
        public bool NuevaFuncion()
        {
            bool r = false;

            funcion f      = new funcion();
            int     idMenu = 0;

            Int32.TryParse(this._id_menu, out idMenu);
            f.id_menu        = idMenu;
            f.nombre_funcion = this._nombre_funcion;
            f.nombre_menu    = this._nombre_menu;



            try
            {
                ctx.funcions.Add(f);
                ctx.SaveChanges();
                this._id_funcion = f.id_funcion;

                r = true;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message, "Error de datos", MessageBoxButtons.OK, MessageBoxIcon.Error);
                r = false;
            }

            return(r);
        }
示例#3
0
        public void CancelacionBoleto()
        {
            funcion funcion = ViewModel.db.funcion.Find("19/06/2019", "10:00 PM", 1);

            ViewModel.CurrentFuncion = funcion;                                                                         // se genero el diagrama
            ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status = false; // El checkbox es presionado y cambia a false;
            ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status = true;  //El mismo checkbox es seleccionado y su valor vuelve a cambiar. Cambia a true;
            bool result = true;

            Assert.AreEqual(ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status, result);
        }
示例#4
0
 public ActionResult Edit([Bind(Include = "fun_idFuncion,pro_idProyeccion,sal_idSala,fun_horario")] funcion funcion)
 {
     if (ModelState.IsValid)
     {
         db.Entry(funcion).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     ViewBag.pro_idProyeccion = new SelectList(db.proyeccion, "pro_idProyeccion", "pro_horaInicio", funcion.pro_idProyeccion);
     ViewBag.sal_idSala       = new SelectList(db.sala, "sal_idSala", "sal_idSala", funcion.sal_idSala);
     return(View(funcion));
 }
示例#5
0
        public ActionResult Create([Bind(Include = "fun_idFuncion,pro_idProyeccion,sal_idSala,fun_horario")] funcion funcion)
        {
            if (ModelState.IsValid)
            {
                db.funcion.Add(funcion);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            ViewBag.pro_idProyeccion = new SelectList(db.proyeccion, "pro_idProyeccion", "pro_horaInicio", funcion.pro_idProyeccion);
            ViewBag.sal_idSala = new SelectList(db.sala, "sal_idSala", "sal_idSala", funcion.sal_idSala);
            return View(funcion);
        }
示例#6
0
 // GET: funcions/Details/5
 public ActionResult Details(decimal id)
 {
     if (id == null)
     {
         return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
     }
     funcion funcion = db.funcion.Find(id);
     if (funcion == null)
     {
         return HttpNotFound();
     }
     return View(funcion);
 }
示例#7
0
        // GET: funcions/Delete/5
        public ActionResult Delete(decimal id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            funcion funcion = db.funcion.Find(id);

            if (funcion == null)
            {
                return(HttpNotFound());
            }
            return(View(funcion));
        }
示例#8
0
 // GET: funcions/Edit/5
 public ActionResult Edit(decimal id)
 {
     if (id == null)
     {
         return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
     }
     funcion funcion = db.funcion.Find(id);
     if (funcion == null)
     {
         return HttpNotFound();
     }
     ViewBag.pro_idProyeccion = new SelectList(db.proyeccion, "pro_idProyeccion", "pro_horaInicio", funcion.pro_idProyeccion);
     ViewBag.sal_idSala = new SelectList(db.sala, "sal_idSala", "sal_idSala", funcion.sal_idSala);
     return View(funcion);
 }
示例#9
0
        public ActionResult Menu()
        {
            funcion        f            = new funcion();
            funcion        f1           = new funcion();
            List <funcion> lstFunciones = new List <funcion>();

            f.id       = 1;
            f.nombre_c = "Nuevo cliente";
            f.icono_c  = "fa-plus";
            lstFunciones.Add(f);
            f1.id       = 2;
            f1.nombre_c = "Estadisticas";
            f1.icono_c  = "fa-tachometer";
            lstFunciones.Add(f1);

            return(PartialView("Partials/Menu", lstFunciones));
        }
示例#10
0
        private nodo_expresion llamar_funcion(nodo_expresion raiz)
        {
            //encontrar funcion
            //generar el nombre
            String nombre_funcion = raiz.valor;

            foreach (arbol_expresion parametro in raiz.parametros)
            {
                nodo_expresion result = parametro.ejecutar_arbol();
                nombre_funcion += "#" + result.tipo;
            }

            //ejecutarla
            funcion funcion = ejecutar.buscar_funcion(nombre_funcion);

            if (funcion != null)
            {
                nodo_expresion respuesta = ejecutar.ejecutar_flujo(funcion, raiz.parametros);
                respuesta.rol = "terminal";
                //AQUI SE VUELVE A SACAR LA INCERTEZA
                @const.incerteza.Pop();
                //---------------------------------
                return(respuesta);
            }
            else
            {
                String parametros;
                if (nombre_funcion.Split('#').Length > 1)
                {
                    parametros = "con parametros ";
                }
                else
                {
                    parametros = "";
                }
                for (int i = 1; i < nombre_funcion.Split('#').Length; i++)
                {
                    parametros += nombre_funcion.Split('#')[i];
                }
                errores.errores.add_error("Error Semantico", "la funcion " + nombre_funcion.Split('#')[0] + " " + parametros + " no fue declarada", raiz.fila, raiz.columna);
                return(new nodo_expresion("error", "error", "error", raiz.fila, raiz.columna));
            }
        }
示例#11
0
        public void CambioBoleto()
        {
            funcion funcion = ViewModel.db.funcion.Find("19/06/2019", "10:00 PM", 1);

            ViewModel.CurrentFuncion = funcion;                                                                         // se genero el diagrama
            ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status = false; // El checkbox es presionado y cambia a false;
            ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status = true;  //El mismo checkbox es seleccionado y su valor vuelve a cambiar. Cambia a true;
            ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 3).First <Seat>().Status = false; // ahora cambiamos al bueno

            bool realResult = false;

            if (ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 2).First <Seat>().Status == true && ViewModel.SeatsTop.Where(value => value.Row == "N" && value.SeatNumber == 3).First <Seat>().Status == false)
            {
                // si se cumple esta condicion es que el que se selecciono primero se deseleccion y se selecciono el que se queria
                realResult = true;
            }
            bool result = true;

            Assert.AreEqual(realResult, result);
        }
示例#12
0
        static int dibujar_sentencia(sentencia s)
        {
            String tipo         = s.tipo;
            int    no_sentencia = get_cluster();

            if (tipo.Equals("declarar") || tipo.Equals("asignacion"))
            {
                String ids       = "|{";
                String tipo_dato = "";
                if (s.tipo_dato != null)
                {
                    tipo_dato = "\\n" + s.tipo_dato;
                }
                foreach (String id in s.ids)
                {
                    ids += id + "|";
                }
                if (ids.Length > 0)
                {
                    ids = ids.Substring(0, ids.Length - 1) + "}";
                }
                String asigna = "";
                if (s.expresion.raiz != null)
                {
                    asigna = "|expresion";
                }
                String cadena = "node" + no_sentencia + "[label=\"{" + tipo + tipo_dato + ids + asigna + "}\"]\n";
                //sentencias += cadena;
                write(cadena);
            }
            else if (tipo.Equals("retorno"))
            {
                String expresion = "";
                if (s.expresion.raiz != null)
                {
                    expresion = "|expresion";
                }
                String cadena = "node" + no_sentencia + "[label=\"{retorno " + expresion + "}\"];";
                //sentencias += cadena;
                write(cadena);
            }
            else if (tipo.Equals("continuar"))
            {
                String cadena = "node" + no_sentencia + "[label=\"{continuar}\"];";
                //sentencias += cadena;
                write(cadena);
            }
            else if (tipo.Equals("detener"))
            {
                String cadena = "node" + no_sentencia + "[label=\"{detener}\"];";
                //sentencias += cadena;
                write(cadena);
            }
            else if (tipo.Equals("call_funcion"))
            {
                nodo_expresion llamada    = s.expresion.raiz;
                String         parametros = "|{";
                foreach (arbol_expresion parametro in llamada.parametros)
                {
                    parametros += "exp" + "|";
                }
                if (parametros.Length > 0)
                {
                    parametros = parametros.Substring(0, parametros.Length - 1) + "}";
                }
                String nombre = llamada.valor + "( )";
                String cadena = "node" + no_sentencia + "[label=\"{llamar funcion|" + nombre + parametros + "}\"]\n";
                //sentencias += cadena;
                write(cadena);
            }
            else if (tipo.Equals("si"))
            {
                int sentencia_anterior = pila_nodos.Pop();
                int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nrankdir=UD\nstyle=filled\ncolor = " + get_color_grafo() + "\nnode[color = white shape = record]\n");
                write("node" + no_sentencia + "[label=\"si\" color=white shape=diamond];");
                write("node" + punto + "[shape=point];");

                //ci
                pila_nodos.Push(no_sentencia);
                funcion si = s.caminos.ElementAt(0).funcion;
                for (int i = 0; i < si.sentencias.Count; i++)
                {
                    sentencia sent = si.sentencias.ElementAt(i);
                    dibujar_sentencia(sent);
                    if (i == 0)
                    {
                        write("[label=si];");
                    }
                }
                int pre = pila_nodos.Pop();
                write("node" + pre + "->node" + punto + "\n");
                pila_nodos.Push(punto);

                //no
                if (s.caminos.Count > 1)
                {
                    pila_nodos.Push(no_sentencia);
                    funcion no = s.caminos.ElementAt(1).funcion;
                    for (int i = 0; i < no.sentencias.Count; i++)
                    {
                        sentencia sent = no.sentencias.ElementAt(i);
                        dibujar_sentencia(sent);
                        if (i == 0)
                        {
                            write("[label=sino];");
                        }
                    }
                    int presino = pila_nodos.Pop();
                    write("node" + presino + "->node" + punto + "\n");
                }
                else
                {
                    write("node" + no_sentencia + "->node" + punto + "[label=\"sino\"];\n");
                }
                write("\n}");
                return(-1);
            }
            else if (tipo.Equals("selecciona"))
            {
                int sentencia_anterior = pila_nodos.Pop();
                int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nstyle=filled\ncolor = " + get_color_grafo() + "\nnode[color = white shape = record]\n");
                write("node" + no_sentencia + "[label=\"selecciona\" color=white shape=diamond];");
                write("node" + punto + "[shape=point];");

                //insertar caminos
                foreach (camino c in s.caminos)
                {
                    write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nrankdir=UD\nstyle=filled\ncolor = " + get_color_grafo() + "\nnode[color = white shape = record]\n");
                    pila_nodos.Push(no_sentencia);
                    funcion flujo = c.funcion;
                    for (int i = 0; i < flujo.sentencias.Count; i++)
                    {
                        sentencia sent = flujo.sentencias.ElementAt(i);
                        dibujar_sentencia(sent);
                        if (i == 0)
                        {
                            if (c.condicion.raiz != null)
                            {
                                write("[label=\"" + c.condicion.raiz.der.valor + "\"];");
                            }
                            else
                            {
                                write("[label=\"Defecto\"];");
                            }
                        }
                    }
                    int precamino = pila_nodos.Pop();
                    write("node" + precamino + "->node" + punto + "\n");

                    write("\n}\n");
                }
                pila_nodos.Push(punto);
                write("\n}");
                return(-1);
            }
            else if (tipo.Equals("para"))
            {
                int sentencia_anterior = pila_nodos.Pop();
                int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nstyle=filled\ncolor = " + get_color_grafo() + "\nrankdir=UD\n\nnode[color = white shape = record]\n");
                write("node" + no_sentencia + "[label=\"para\" color=white shape=diamond];");
                write("node" + punto + "[shape=point];");

                pila_nodos.Push(no_sentencia);

                dibujar_sentencia(s.inicial);

                no_sentencia = get_cluster();

                sentencia_anterior = pila_nodos.Pop();
                //int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("node" + no_sentencia + "[label=\"cumple\" color=white shape=diamond];");
                //write("node" + punto + "[shape=point];");


                //insertar caminos
                foreach (camino c in s.caminos)
                {
                    pila_nodos.Push(no_sentencia);
                    funcion flujo = c.funcion;
                    for (int i = 0; i < flujo.sentencias.Count; i++)
                    {
                        sentencia sent = flujo.sentencias.ElementAt(i);
                        dibujar_sentencia(sent);
                        if (i == 0)
                        {
                            write("[label=\"Si\"];");
                        }
                    }
                    int precamino = pila_nodos.Pop();
                    write("node" + precamino + "->node" + no_sentencia + "\n");
                }
                pila_nodos.Push(punto);

                write("node" + no_sentencia + "->node" + punto + "[label=\"no\"]\n");

                write("\n}");
                return(-1);
            }
            else if (tipo.Equals("hasta"))
            {
                int sentencia_anterior = pila_nodos.Pop();
                int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nstyle=filled\ncolor = " + get_color_grafo() + "\nnode[color = white shape = record]\n");
                write("node" + no_sentencia + "[label=\"hasta\" color=white shape=diamond];");
                write("node" + punto + "[shape=point];");

                //insertar caminos
                foreach (camino c in s.caminos)
                {
                    pila_nodos.Push(no_sentencia);
                    funcion flujo = c.funcion;
                    for (int i = 0; i < flujo.sentencias.Count; i++)
                    {
                        sentencia sent = flujo.sentencias.ElementAt(i);
                        dibujar_sentencia(sent);
                        if (i == 0)
                        {
                            write("[label=\"No cumple\"];");
                        }
                    }
                    int ultimo = pila_nodos.Pop();
                    write("node" + ultimo + "->node" + no_sentencia + "\n");
                }

                write("node" + no_sentencia + "->node" + punto + "[label=\"cumple\"]\n");

                pila_nodos.Push(punto);
                write("\n}");
                return(-1);
            }
            else if (tipo.Equals("mientras"))
            {
                int sentencia_anterior = pila_nodos.Pop();
                int punto = get_cluster();
                write("node" + sentencia_anterior + "->node" + no_sentencia + "\n");

                write("subgraph cluster_" + get_subgraph() + "{ label = \"\"\nstyle=filled\ncolor = " + get_color_grafo() + "\nnode[color = white shape = record]\n");
                write("node" + no_sentencia + "[label=\"mientras\" color=white shape=diamond];");
                write("node" + punto + "[shape=point];");

                //insertar caminos
                foreach (camino c in s.caminos)
                {
                    pila_nodos.Push(no_sentencia);
                    funcion flujo = c.funcion;
                    for (int i = 0; i < flujo.sentencias.Count; i++)
                    {
                        sentencia sent = flujo.sentencias.ElementAt(i);
                        dibujar_sentencia(sent);
                        if (i == 0)
                        {
                            write("[label=\"cumple\"];");
                        }
                    }
                    int ultimo = pila_nodos.Pop();
                    write("node" + ultimo + "->node" + no_sentencia + "\n");
                }

                write("node" + no_sentencia + "->node" + punto + "[label=\"no cumple\"]\n");

                pila_nodos.Push(punto);
                write("\n}");
                return(-1);
            }
            //ESTO YA NO ES DE LOS IFS
            int ant = pila_nodos.Pop();

            write("node" + ant + "->node" + no_sentencia + "\n");
            pila_nodos.Push(no_sentencia);

            return(no_sentencia);
        }
示例#13
0
        public static void dibujar_funcion(funcion fun)
        {
            //CREAR EL ARCHIVO
            crear_archivo(fun.nombre + ".dot");
            pila_nodos = new Stack <int>();


            int inicio = get_cluster();

            //sentencias = "";
            //String cod = "digraph subgraphs { rankdir = UD label = \"" + fun.nombre + "\"  node[shape = record color = lightgrey]";
            write("digraph subgraphs { rankdir = UD label = \"" + fun.nombre + "\"  node[shape = record color = lightgrey]");
            String parametros = "";

            if (fun.parametros.Count > 0)
            {
                parametros = "|{";
                foreach (String parametro in fun.parametros)
                {
                    parametros += parametro.Replace(',', ' ') + "|";
                }
                parametros = parametros.Substring(0, parametros.Length - 1) + "}";
            }
            //cod += "node"+inicio+"[label=\"{ "+fun.tipo+":"+fun.nombre+parametros+" } \" ]";
            write("node" + inicio + "[label=\"{ " + fun.tipo + ":" + fun.nombre + parametros + " } \" ]");

            //write("node" + inicio + "->node"+(inicio+1)+";");


            pila_nodos.Push(inicio);

            //int actual=-1;
            foreach (sentencia s in fun.sentencias)
            {
                dibujar_sentencia(s);
            }

            int ultima = pila_nodos.Pop();
            int fin    = get_cluster();

            write("node" + fin + "[label=\"{fin} \" ]");
            write("node" + ultima + "->node" + fin);

            //cod += sentencias;

            //cod += "}";
            write("}");

            /*
             * System.IO.StreamWriter file = new System.IO.StreamWriter(fun.nombre + ".dot");
             * file.WriteLine(cod);
             * file.Close();
             */

            String comando = "dot -Tpng " + fun.nombre + ".dot > " + @const.RUTA.Replace("\\", "\\\\") + "\\AST_" + fun.nombre + ".png";

            System.Diagnostics.ProcessStartInfo procStartInfo = new System.Diagnostics.ProcessStartInfo("cmd", "/c " + comando);
            procStartInfo.RedirectStandardOutput = true;
            procStartInfo.UseShellExecute        = false;
            procStartInfo.CreateNoWindow         = false;
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.StartInfo = procStartInfo;
            proc.Start();
            string result = proc.StandardOutput.ReadToEnd();

            Console.WriteLine(result);
        }
示例#14
0
        void recorrer_arbol(ParseTreeNode raiz)
        {
            String termino = "", token = "";

            if (raiz.Term != null)
            {
                termino = raiz.Term.ToString();
            }
            if (raiz.Token != null)
            {
                token = raiz.Token.ToString();
            }
            if (termino.Equals("incerteza"))
            {
                String numero    = raiz.ChildNodes.ElementAt(1).Token.Text;
                Double incerteza = Double.Parse(numero.Replace('.', ','));
                this.interprete.set_incerteza(incerteza);
            }
            else if (termino.Equals("ruta"))
            {
                String ruta = raiz.ChildNodes.ElementAt(1).Token.Text;
                this.interprete.set_ruta(ruta);
            }
            else if (termino.Equals("incluye"))
            {
                String texto   = "";
                String incluye = raiz.ChildNodes.ElementAt(1).Token.Text;
                try
                {
                    String   ruta   = contenedor.SelectedTab.Name;
                    String[] partes = ruta.Split('\\');
                    ruta = "";
                    for (int i = 0; i < partes.Length - 1; i++)
                    {
                        ruta += partes[i] + "\\";
                    }
                    System.IO.StreamReader file = new System.IO.StreamReader(ruta + incluye);
                    texto = file.ReadToEnd();
                    file.Close();

                    analizar(texto);
                }
                catch (Exception e) {
                    errores.errores.add_error("Error Semantico", "Archivo " + incluye + " inaccesible", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                    return;
                }


                /*
                 * String incluye = raiz.ChildNodes.ElementAt(1).Token.Text;
                 * Console.WriteLine("debería de incluir " + incluye);
                 * analizar("Define 666 Define \"nuevo\" Principal () { alo= polisia; }");
                 */
            }
            else if (termino.Equals("declaracion"))
            {
                String        tipo = raiz.ChildNodes.ElementAt(0).Token.Text;
                List <String> ids  = new List <string>();
                for (int i = 0; i < raiz.ChildNodes.ElementAt(1).ChildNodes.Count; i++)
                {
                    ids.Add(raiz.ChildNodes.ElementAt(1).ChildNodes.ElementAt(i).Token.Text);
                }
                arbol_expresion arbol = new arbol_expresion();

                if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0)
                {
                    arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(1));
                    //@const.dibujar_expresion(arbol.raiz, "prueba_expresion");

                    /*nodo_expresion resultado= arbol.ejecutar_arbol();
                     * Console.WriteLine("----------------------");
                     * Console.WriteLine(resultado.valor + " " + resultado.tipo + " " + resultado.rol);
                     * Console.WriteLine("----------------------");
                     */
                }

                interprete.add_sentencia("declarar", ids, arbol, tipo.ToLower(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("declarar_funcion"))
            {
                if (raiz.ChildNodes.ElementAt(0).Token.Text.Equals("Principal"))
                {
                    interprete.funcion_nueva("Principal", interprete.get_funcion(), "void");
                    raiz.ChildNodes.ForEach(recorrer_arbol);
                    interprete.set_principal();
                    return;
                }
                else
                {
                    interprete.funcion_nueva(raiz.ChildNodes.ElementAt(1).Token.Text, interprete.get_funcion(), raiz.ChildNodes.ElementAt(0).Token.Text);
                    raiz.ChildNodes.ForEach(recorrer_arbol);
                    interprete.agregar_nombre(pars);
                    pars = "";
                    interprete.pop_funcion();
                    return;
                }
            }
            else if (termino.Equals("parametro"))
            {
                String tipo   = raiz.ChildNodes.ElementAt(0).Token.Text;
                String nombre = raiz.ChildNodes.ElementAt(1).Token.Text;
                interprete.add_parametro(tipo, nombre);
                pars += "#" + tipo.ToLower();
            }
            else if (termino.Equals("asignacion"))
            {
                String        id    = raiz.ChildNodes.ElementAt(0).Token.Text;
                List <String> lista = new List <string>();
                lista.Add(id);
                nodo_expresion  expresion = extraer_arbol(raiz.ChildNodes.ElementAt(2));
                arbol_expresion arbol     = new arbol_expresion();
                arbol.raiz = expresion;
                interprete.add_sentencia("asignacion", lista, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("retorno_noterminal"))
            {
                arbol_expresion arbol = new arbol_expresion();
                if (raiz.ChildNodes.Count > 1)
                {
                    arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(1));
                }
                interprete.add_sentencia("retorno", null, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("sentencia_continuar"))
            {
                interprete.add_sentencia("continuar", null, new arbol_expresion(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("sentencia_detener"))
            {
                interprete.add_sentencia("detener", null, new arbol_expresion(), raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("call_funcion"))
            {
                arbol_expresion arbol = new arbol_expresion();
                arbol.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(0));
                interprete.add_sentencia("call_funcion", null, arbol, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
            }
            else if (termino.Equals("flujo_si"))
            {
                List <camino> caminos = new List <camino>();
                //extrae la condicion
                nodo_expresion cond = extraer_arbol(raiz.ChildNodes.ElementAt(0));

                //inserta funcion para anidar
                interprete.funcion_nueva("si", interprete.get_funcion(), "void");
                //inserta sentencias
                recorrer_arbol(raiz.ChildNodes.ElementAt(1));
                //obtiene el camino si
                funcion si = interprete.extraer_funcion();
                //agrega primer camino
                caminos.Add(new camino(cond, si));

                //obtener el else
                if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0)
                {
                    //si hay else
                    interprete.funcion_nueva("Sino", interprete.get_funcion(), "void");
                    recorrer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0));
                    funcion sino = interprete.extraer_funcion();
                    caminos.Add(new camino(null, sino));
                }
                interprete.add_sentencia("si", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                return;
            }
            else if (termino.Equals("flujo_selecciona"))
            {
                List <camino> caminos = new List <camino>();
                //extrae la expresion a comparar
                nodo_expresion expresion    = extraer_arbol(raiz.ChildNodes.ElementAt(0));
                ParseTreeNode  pares        = raiz.ChildNodes.ElementAt(1);
                int            caminos_cant = pares.ChildNodes.Count;
                for (int i = 0; i < caminos_cant; i++)
                {
                    ParseTreeNode par = pares.ChildNodes.ElementAt(i);
                    //hacer condicion
                    nodo_expresion condicion = new nodo_expresion("==", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                    condicion.izq = expresion;
                    //extraer valor
                    nodo_expresion valor = extraer_arbol(par.ChildNodes.ElementAt(0));
                    condicion.der = valor;

                    //extraer el camino
                    interprete.funcion_nueva("camino", interprete.get_funcion(), "void");
                    recorrer_arbol(par.ChildNodes.ElementAt(1));
                    funcion flujo = interprete.extraer_funcion();
                    //insertar el camino
                    caminos.Add(new camino(condicion, flujo));
                }
                //obtener el Defecto
                if (raiz.ChildNodes.ElementAt(2).ChildNodes.Count > 0)
                {
                    //si hay defecto
                    interprete.funcion_nueva("defecto", interprete.get_funcion(), "void");
                    recorrer_arbol(raiz.ChildNodes.ElementAt(2).ChildNodes.ElementAt(0));
                    funcion defecto = interprete.extraer_funcion();
                    caminos.Add(new camino(null, defecto));
                }
                interprete.add_sentencia("selecciona", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                return;
            }
            else if (termino.Equals("flujo_para"))
            {
                //crear sentencia de asignacion inicial

                List <String> id = new List <string>();
                id.Add(raiz.ChildNodes.ElementAt(1).Token.Text);
                arbol_expresion expresion = new arbol_expresion();
                expresion.raiz = extraer_arbol(raiz.ChildNodes.ElementAt(3));
                sentencia asignacion_inicial = new sentencia("declarar", id, expresion, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                asignacion_inicial.tipo_dato = "number";
                //extraer condicion
                nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(4));

                //sacar flujo
                List <camino> caminos = new List <camino>();
                //inserta funcion para anidar
                interprete.funcion_nueva("para", interprete.get_funcion(), "void");
                //inserta sentencias
                recorrer_arbol(raiz.ChildNodes.ElementAt(6));
                //obtiene el camino
                funcion para = interprete.extraer_funcion();

                //meter paso al flujo
                nodo_expresion op  = new nodo_expresion("", "", "", -1, -1);
                nodo_expresion var = new nodo_expresion(id.ElementAt(0), "terminal", "id", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                nodo_expresion uno = new nodo_expresion("1", "terminal", "NUMERO", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);

                if (raiz.ChildNodes.ElementAt(5).Token.Text.Equals("++"))
                {
                    op = new nodo_expresion("+", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                }
                else if (raiz.ChildNodes.ElementAt(5).Token.Text.Equals("--"))
                {
                    op = new nodo_expresion("-", "operador", "operador", raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                }

                op.izq = var;
                op.der = uno;

                arbol_expresion asignacion = new arbol_expresion();
                asignacion.raiz = op;
                sentencia paso = new sentencia("asignacion", id, asignacion, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);

                para.add_sentencia(paso);

                //agrega primer camino
                caminos.Add(new camino(condicion, para));



                //meter sentencia
                interprete.add_sentencia("para", asignacion_inicial, caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                return;
            }
            else if (termino.Equals("flujo_hasta"))
            {
                //extraer condicion
                nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(0));
                //sacar flujo
                List <camino> caminos = new List <camino>();
                //inserta funcion para anidar
                interprete.funcion_nueva("hasta", interprete.get_funcion(), "void");
                //inserta sentencias
                recorrer_arbol(raiz.ChildNodes.ElementAt(1));
                //obtiene el camino
                funcion hasta = interprete.extraer_funcion();

                //agrega primer camino
                caminos.Add(new camino(condicion, hasta));
                //meter sentencia
                interprete.add_sentencia("hasta", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                return;
            }
            else if (termino.Equals("flujo_mientras"))
            {
                //extraer condicion
                nodo_expresion condicion = extraer_arbol(raiz.ChildNodes.ElementAt(0));
                //sacar flujo
                List <camino> caminos = new List <camino>();
                //inserta funcion para anidar
                interprete.funcion_nueva("mientras", interprete.get_funcion(), "void");
                //inserta sentencias
                recorrer_arbol(raiz.ChildNodes.ElementAt(1));
                //obtiene el camino
                funcion mientras = interprete.extraer_funcion();

                //agrega primer camino
                caminos.Add(new camino(condicion, mientras));
                //meter sentencia
                interprete.add_sentencia("mientras", new arbol_expresion(), caminos, raiz.FindToken().Location.Line, raiz.FindToken().Location.Column);
                return;
            }
            //Console.WriteLine("-"+termino+"-"+ token+"-");

            raiz.ChildNodes.ForEach(recorrer_arbol);
        }