public String generarCodigoProcedimientos(Clase clase) { String cadena = ""; foreach (Procedimiento a in clase.procedimientos) { if (tipoArchivo.SelectedIndex == 0) { // OLC++ cadena += "\t" + getVisibilidad(a.visibilidad) + " " + Simbolo.getValor(a.tipo) + " " + a.nombre + "(){\n\n\t}\n\n"; } else if (tipoArchivo.SelectedIndex == 1) { // Tree if (a.tipo == (int)Simbolo.Tipo.VACIO) { cadena += "\t" + getVisibilidad(a.visibilidad) + " metodo " + a.nombre + "():\n\n"; } else { cadena += "\t" + getVisibilidad(a.visibilidad) + " funcion " + Simbolo.getValor(a.tipo) + " " + a.nombre + "():\n\n"; } } } return(cadena); }
public List <C3D> compilar(String texto, RichTextBox consola, int lenguaje, String clase) { // *************** FASE 1 Analisis Lexico y Sintactico **************// if (lenguaje == (int)Pagina.Lenguaje.OLC) { // OLC++ InterpreteOLC interprete = new InterpreteOLC(); clases = interprete.analizarOLC(texto); clase = clase.Replace(".olc", ""); } else { // Tree InterpreteTree interprete = new InterpreteTree(); clases = interprete.analizarTree(texto); clase = clase.Replace(".tree", ""); } // **************** FASE 2 Llenar Tabla de Simbolos *****************// llenarTablaSimbolos(); // **************** FASE 3 Analisis Semantico y Codigo Intermedio ***// if (clases.Count > 0) { Clase main = buscarMain(clases[0]); if (main == null) { // Error! No hay procedimiento main en la clase de inicio! return(null); } GeneradorC3D.clases = clases; return(GeneradorC3D.generarC3D(main)); } return(null); }
public void agregarClase() { Clase nueva = new Clase("Clase_" + (clases.Count + 1), 0, 0); this.clases.Add(nueva); EditorClase editor = new EditorClase(); editor.setClase(ref nueva); editor.Show(); }
public void guardarClases(ParseTreeNode nodo) { // CLASES -> Lista de CLASE foreach (ParseTreeNode clase in nodo.ChildNodes) { Clase nueva = guardarClase(clase); if (!existeClase(nueva)) { clases.Add(nueva); } } }
public List <Atributo> getAtributoClase(Clase clase) { List <Atributo> atributos = new List <Atributo>(); foreach (Atributo a in clase.atributos) { if (a.tipo == (int)Simbolo.Tipo.CLASE) { atributos.Add(a); } } return(atributos); }
public static List <C3D> generarC3D(Clase main_clase) { instrucciones = new List <C3D>(); display = new Display(); //this.ambitos = new DisplayAmbitos(); temporales = 1; etiquetas = 1; // Generar codigo 3D del metodo principal generarC3DMain(main_clase); // Generar codigo 3D de los demas metodos generarC3DClases(); return(instrucciones); }
public bool getConstructorClase(Clase clase, String nclase) { foreach (Procedimiento c in clase.constructores) { foreach (Atributo parametro in c.parametros) { if (parametro.clase == nclase) { return(true); } } } return(false); }
public bool existeClase(Clase nueva) { foreach (Clase c in clases) { if (c.nombre.Equals(nueva.nombre)) { Errores.getInstance.agregar(new Error((int)Error.tipoError.SEMANTICO, "La clase " + nueva.nombre + " ya existe", nueva.linea, nueva.columna)); return(true); } } return(false); }
public Simbolo guardarSimboloClase(Clase clase) { Simbolo sclase = new Simbolo(); sclase.nombre = clase.nombre; sclase.padre = clase.padre; sclase.ambito = -1; sclase.dimensiones = null; sclase.pos = -1; sclase.rol = (int)Simbolo.Tipo.CLASE; sclase.tipo = -1; sclase.tam = tamanio; return(sclase); }
private Clase buscarMain(Clase clase) { foreach (Simbolo simbolo in tablaSimbolos) { if (simbolo.padre != null) { if (simbolo.rol == (int)Simbolo.Tipo.METODO && simbolo.nombre.Equals("main")) { return(clase); } } } return(null); }
public List <String> getClaseProcedimiento(Clase clase) { List <String> clases = new List <String>(); foreach (Procedimiento p in clase.procedimientos) { foreach (Atributo a in p.parametros) { if (a.tipo == (int)Simbolo.Tipo.CLASE && a.clase != clase.nombre) { clases.Add(a.clase); } } } return(clases); }
private static void generarC3DThis(Clase clase, String puntero, String estructura) { Simbolo sclase = TablaSimbolos.getInstance.getClase(clase.nombre); if (sclase != null) { String t1 = getTemporal(); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar apuntador del this")); instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, t1, puntero, "+", "0")); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar apuntador donde incia el this")); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, estructura, t1, "H")); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Reservar espacio para globales de " + clase.nombre)); aumentarHeap(Convert.ToString(sclase.tam)); // Recorrer las variables globales y asignarles foreach (Atributo atr in clase.atributos) { if (atr.esArreglo) { Arreglo.guardarC3D(atr.nombre, atr.valor, Acceso.Tipo.ESTE); } else { if (atr.valor != null) { instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener valor del atributo " + atr.nombre)); Nodo exp = Expresion.expresionC3D(atr.valor); Acceso.actual = null; instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener posicion del atributo " + atr.nombre)); Nodo nodo = Acceso.generarC3DID(atr.nombre, Acceso.Tipo.ESTE, "P", "Stack"); if (nodo != null) { // Asignar la expresion instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Asignar expresion al atributo " + atr.nombre)); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, nodo.estructura, nodo.referencia, exp.cadena)); } } } } } }
public String generarCodigoAtributos(Clase clase) { String cadena = ""; foreach (Atributo a in clase.atributos) { if (tipoArchivo.SelectedIndex == 0) { // OLC++ cadena += "\t" + getVisibilidad(a.visibilidad) + " " + Simbolo.getValor(a.tipo) + " " + a.nombre + ";\n"; } else if (tipoArchivo.SelectedIndex == 1) { // Tree cadena += "\t" + getVisibilidad(a.visibilidad) + " " + Simbolo.getValor(a.tipo) + " " + a.nombre + "\n"; } } return(cadena); }
private static void generarC3DMain(Clase clase) { C3DSentencias.claseActual = clase; Simbolo smain = TablaSimbolos.getInstance.getProcedimiento(clase.nombre, "main"); // Guardar this de la clase main instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Reservar espacio para this y super de " + clase.nombre)); String t1 = getTemporal(); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar inicio -> pos 0")); instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, t1, "H", "+", "0")); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, "Stack", "0", "0")); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, "Stack", "1", "1")); GeneradorC3D.aumentarHeap("2"); // Generar this y super generarC3DThis(clase, t1, "Heap"); // Guardar super de la clase main generarC3DSuper(clase, t1, "Heap"); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Llamada al main")); instrucciones.Add(new C3D((int)C3D.TipoC3D.LLAMADA, clase.nombre + "_main")); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Terminar la ejecucion")); instrucciones.Add(new C3D((int)C3D.TipoC3D.EXIT, "")); }
public static Nodo instanciaC3D(ParseTreeNode nuevo, Acceso.Tipo tipo) { // NUEVO -> new id EXPS // SUPER -> super [ EXPS ] Nodo nodo = new Nodo(); // NUEVO String idC = nuevo.ChildNodes[1].Token.Text; // Buscar que la clase exista Clase instancia = GeneradorC3D.getClasePadre(idC); if (instancia != null) { List <Nodo> expresiones = new List <Nodo>(); String llave = getExpresiones(nuevo.ChildNodes[2], ref expresiones); if (llave != null) { llave = "constructor" + llave; Simbolo procedimiento = TablaSimbolos.getInstance.getProcedimiento( instancia.nombre, llave); if (procedimiento == null || procedimiento.visibilidad == (int)Simbolo.Visibilidad.PRIVADO) { // Error Semantico! No se puede hacer instancia por ser privado return(null); } // Get parametros List <Simbolo> sparametros = TablaSimbolos.getInstance.getParametros( instancia.nombre, procedimiento); if (expresiones.Count == sparametros.Count) { int tam = GeneradorC3D.tamMain; if (C3DSentencias.procedimientoActual != null) { // Esta en el main! tam = C3DSentencias.procedimientoActual.tam; } GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Pasar los parametros")); String taux = GeneradorC3D.getTemporal(); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Crear un temporal auxiliar para el incremento del ambito")); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, taux, "P", "+", Convert.ToString(tam))); parametrosC3D(taux, sparametros, expresiones); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Incrementar el ambito")); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, "P", "P", "+", Convert.ToString(tam))); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Llamar al procedimiento " + llave)); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.LLAMADA, instancia.nombre + "_" + llave)); // Ver si hay retorno Y guardarlo String temp = GeneradorC3D.getTemporal(); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener posicion del retorno en el ambito actual ")); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, temp, "P", "+", "2")); nodo.cadena = GeneradorC3D.getTemporal(); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener valor del retorno de la funcion " + llave)); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.ACCESO, "Stack", nodo.cadena, temp)); nodo.tipo = (int)Simbolo.Tipo.CLASE; GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Disminuir el ambito ")); GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, "P", "P", "-", Convert.ToString(tam))); } } } return(nodo); }
public Clase guardarClase(ParseTreeNode clase) { // CLASE -> id BCUERPO | id id BCUERPO Clase nueva; String nombre_clase = clase.ChildNodes.ElementAt(0).Token.Value.ToString(); int pos = 1; if (clase.ChildNodes.Count == 2) { nueva = new Clase(nombre_clase, clase.ChildNodes[0].Token.Location.Line, clase.ChildNodes[0].Token.Location.Line); } else { // Tiene padre String padre = clase.ChildNodes.ElementAt(1).Token.Value.ToString(); nueva = new Clase(nombre_clase, padre, clase.ChildNodes[0].Token.Location.Line, clase.ChildNodes[0].Token.Location.Line); pos++; } // Recorrer atributos, constructores y procedimientos ParseTreeNode cuerpos = clase.ChildNodes.ElementAt(pos).ChildNodes.ElementAt(0); foreach (ParseTreeNode cuerpo in cuerpos.ChildNodes) { if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("METODO")) { Procedimiento proc = guardarProcedimiento(cuerpo.ChildNodes[0]); proc.llenarDeclaraciones(proc.sentencias, nueva.atributos); nueva.agregarProcedimiento(proc); } else if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("__constructor")) { Procedimiento cons = guardarConstructor(cuerpo); cons.llenarDeclaraciones(cons.sentencias, nueva.atributos); nueva.agregarConstructor(cons); } else if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("DECLARACION")) { ParseTreeNode declara = cuerpo.ChildNodes[0]; /* DECLARACION -> TIPO + LISTA_IDS + asignarR | TIPO + LISTA_IDS | TIPO + NARREGLO -> id + INDICES */ int tipo = Simbolo.getTipo(declara.ChildNodes[0].Token.Text); ParseTreeNode ids = declara.ChildNodes[1]; if (ids.Term.Name.Equals("NARREGLO")) { Atributo variable = new Atributo(ids.ChildNodes[0].Token.Text, tipo, ids.ChildNodes[0].Token.Location.Line, ids.ChildNodes[0].Token.Location.Column); variable.asignarArreglo(ids.ChildNodes[1]); if (tipo == (int)Simbolo.Tipo.CLASE) { variable.asignarClase(declara.ChildNodes[0].ChildNodes[0].Token.Text); } nueva.agregarAtributo(variable); } else { foreach (ParseTreeNode var in ids.ChildNodes) { Atributo a = new Atributo(var.Token.Text, tipo, var.Token.Location.Line, var.Token.Location.Column); if (declara.ChildNodes.Count == 3) { a.asignarValor(declara.ChildNodes[2]); } nueva.agregarAtributo(a); } } } else if (cuerpo.ChildNodes[0].Term.Name.Equals("VISIBILIDAD")) { int vis = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text); ParseTreeNode declara = cuerpo.ChildNodes[1]; int tipo = Simbolo.getTipo(declara.ChildNodes[0].Token.Text); ParseTreeNode ids = declara.ChildNodes[1]; if (ids.Term.Name.Equals("NARREGLO")) { Atributo variable = new Atributo(ids.ChildNodes[0].Token.Text, tipo, ids.ChildNodes[0].Token.Location.Line, ids.ChildNodes[0].Token.Location.Column); variable.asignarArreglo(ids.ChildNodes[1]); if (tipo == (int)Simbolo.Tipo.CLASE) { variable.asignarClase(declara.ChildNodes[0].ChildNodes[0].Token.Text); } nueva.agregarAtributo(variable); } else { foreach (ParseTreeNode var in ids.ChildNodes) { Atributo a = new Atributo(var.Token.Text, tipo, var.Token.Location.Line, var.Token.Location.Column); if (declara.ChildNodes.Count == 3) { a.asignarValor(declara.ChildNodes[2]); } nueva.agregarAtributo(a); } } } } return(nueva); }
public Clase guardarClase(ParseTreeNode nodo) { // CLASE -> id id CUERPOS //| id CUERPOS Clase nueva; int idCuerpos = 1; if (nodo.ChildNodes.Count == 3) { // Tiene padre nueva = new Clase(nodo.ChildNodes[0].Token.Text, nodo.ChildNodes[1].Token.Text, nodo.ChildNodes[0].Token.Location.Line, nodo.ChildNodes[0].Token.Location.Column); idCuerpos = 2; } else { // No tiene padre nueva = new Clase(nodo.ChildNodes[0].Token.Text, nodo.ChildNodes[0].Token.Location.Line, nodo.ChildNodes[0].Token.Location.Column); } // Recorrer cuerpos foreach (ParseTreeNode cuerpo in nodo.ChildNodes[idCuerpos].ChildNodes) { // Recorrer cada uno de los cuerpos en busca de Declaraciones, Metodos, Funciones o Constructores /* * CUERPO.Rule = VISIBILIDAD + TPROC + id + TCUERPO? -> 4 , 3 | TPROC + id + TCUERPO? -> 3 , 2 | sobreescribir + METODO -> 2 | PRINCIPAL -> 1 | VISIBILIDAD + CONSTRUCTOR -> 2 | CONSTRUCTOR -> 1 | ASIGNACION + fin; -> 1 */ switch (cuerpo.ChildNodes.Count) { case 1: // CONSTRUCTOR o PRINCIPAL if (cuerpo.ChildNodes[0].Term.Name.Equals("CONSTRUCTOR")) { Procedimiento cons = guardarConstructor(cuerpo.ChildNodes[0], (int)Simbolo.Visibilidad.PUBLICO); cons.llenarDeclaraciones(cons.sentencias, nueva.atributos); nueva.agregarConstructor(cons); } else if (cuerpo.ChildNodes[0].Term.Name.Equals("PRINCIPAL")) { Procedimiento proc = new Procedimiento("main", (int)Simbolo.Tipo.VACIO, new List <Atributo>(), cuerpo.ChildNodes[0].ChildNodes[0], cuerpo.Span.Location.Line, cuerpo.Span.Location.Column); proc.llenarDeclaraciones(proc.sentencias, nueva.atributos); nueva.agregarProcedimiento(proc); } break; case 2: // sobreescribir METODO // VISIBILIDAD CONSTRUCTOR // TPROC id if (cuerpo.ChildNodes[1].Term.Name.Equals("CONSTRUCTOR")) { int vis = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text); Procedimiento cons = guardarConstructor(cuerpo.ChildNodes[1], vis); cons.llenarDeclaraciones(cons.sentencias, nueva.atributos); nueva.agregarConstructor(cons); } else if (cuerpo.ChildNodes[1].Term.Name.Equals("METODO")) { Procedimiento proc = guardarProcedimiento (cuerpo.ChildNodes[1], true); proc.llenarDeclaraciones(proc.sentencias, nueva.atributos); nueva.agregarProcedimiento(proc); } else { // TPROC id ParseTreeNode tproc = cuerpo.ChildNodes[0]; int tipo = Simbolo.getTipo(tproc.ChildNodes[0].Token.Text); Atributo a = new Atributo(cuerpo.ChildNodes[1].Token.Text, tipo, cuerpo.ChildNodes[1].Token.Location.Line, cuerpo.ChildNodes[1].Token.Location.Column); if (tipo == (int)Simbolo.Tipo.CLASE) { a.asignarClase(tproc.ChildNodes[0].Token.Text); } nueva.agregarAtributo(a); } break; case 3: // TPROC id CMETODO // TPROC id DARREGLO // TPROC id EXP // VISIBILIDAD TPROC id if (cuerpo.ChildNodes[0].Term.Name.Equals("TPROC")) { if (cuerpo.ChildNodes[2].Term.Name.Equals("CMETODO")) { // Es procedimiento Procedimiento proc = guardarProcedimiento (cuerpo, true); proc.llenarDeclaraciones(proc.sentencias, nueva.atributos); nueva.agregarProcedimiento(proc); } else { // Es atributo ParseTreeNode tproc = cuerpo.ChildNodes[0]; String ctipo = tproc.ChildNodes[0].Token.Text; int tipo = Simbolo.getTipo(ctipo); Atributo a = new Atributo(cuerpo.ChildNodes[1].Token.Text, tipo, cuerpo.ChildNodes[1].Token.Location.Line, cuerpo.ChildNodes[1].Token.Location.Column); // Ver si el tipo de la variable es una clase if (tipo == (int)Simbolo.Tipo.CLASE) { a.asignarClase(ctipo); } // Verificar si es un arreglo o tiene valor if (cuerpo.ChildNodes[2].Term.Name.Equals("EXP")) { // Tiene valor a.asignarValor(cuerpo.ChildNodes[2]); } else { // Es arreglo ParseTreeNode darr = cuerpo.ChildNodes[2]; a.asignarArreglo(darr.ChildNodes[0]); if (darr.ChildNodes.Count == 2) { a.asignarValor(darr.ChildNodes[1]); } } nueva.agregarAtributo(a); } } else if (cuerpo.ChildNodes[0].Term.Name.Equals("VISIBILIDAD")) { // Es atributo int vis = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text); ParseTreeNode tproc = cuerpo.ChildNodes[1]; String ctipo = tproc.ChildNodes[0].Token.Text; int tipo = Simbolo.getTipo(ctipo); Atributo a = new Atributo(cuerpo.ChildNodes[2].Token.Text, tipo, vis, cuerpo.ChildNodes[2].Token.Location.Line, cuerpo.ChildNodes[2].Token.Location.Column); if (tipo == (int)Simbolo.Tipo.CLASE) { a.asignarClase(ctipo); } nueva.agregarAtributo(a); } break; case 4: // VISIBILIDAD TPROC id CMETODO // VISIBILIDAD TPROC id DARREGLO // VISIBILIDAD TPROC id EXP int vis2 = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text); if (cuerpo.ChildNodes[3].Term.Name.Equals("CMETODO")) { // Es procedimiento Procedimiento proc = guardarProcedimiento(cuerpo, false); proc.llenarDeclaraciones(proc.sentencias, nueva.atributos); nueva.agregarProcedimiento(proc); } else { // Es atributo --> DARREGLO o EXP // Es atributo ParseTreeNode tproc = cuerpo.ChildNodes[1]; String ctipo = tproc.ChildNodes[0].Token.Text; int tipo = Simbolo.getTipo(ctipo); Atributo a = new Atributo(cuerpo.ChildNodes[2].Token.Text, tipo, vis2, cuerpo.ChildNodes[2].Token.Location.Line, cuerpo.ChildNodes[2].Token.Location.Column); // Ver si el tipo de la variable es una clase if (tipo == (int)Simbolo.Tipo.CLASE) { a.asignarClase(ctipo); } // Verificar si es un arreglo o tiene valor if (cuerpo.ChildNodes[3].Term.Name.Equals("EXP")) { // Tiene valor a.asignarValor(cuerpo.ChildNodes[3]); } else { // Es arreglo ParseTreeNode darr = cuerpo.ChildNodes[3]; a.asignarArreglo(darr.ChildNodes[0]); if (darr.ChildNodes.Count == 2) { a.asignarValor(darr.ChildNodes[1]); } } nueva.agregarAtributo(a); } break; } } return(nueva); }
private static void generarC3DSuper(Clase clase, String puntero, String estructura) { Simbolo sclase = TablaSimbolos.getInstance.getClase(clase.nombre); if (sclase != null) { String t1 = getTemporal(); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar apuntador del super")); instrucciones.Add(new C3D((int)C3D.TipoC3D.ASIGNACION, t1, puntero, "+", "1")); instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar posicion donde empieza super")); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, estructura, t1, "H")); // Buscar clase padre Clase padre; if (clase.padre != null) { padre = getClasePadre(clase.padre); if (padre == null) { return; } } else { return; } sclase = TablaSimbolos.getInstance.getClase(clase.padre); if (sclase == null) { return; } instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Reservar espacio para la clase padre" + sclase.nombre)); aumentarHeap(Convert.ToString(sclase.tam)); // Recorrer las variables globales y asignarles foreach (Atributo atr in padre.atributos) { if (atr.visibilidad == (int)Simbolo.Visibilidad.PUBLICO || atr.visibilidad == (int)Simbolo.Visibilidad.PROTEGIDO) { if (atr.esArreglo) { Arreglo.guardarC3D(atr.nombre, atr.valor, Acceso.Tipo.SUPER); } else { if (atr.valor != null) { instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener valor del atributo " + atr.nombre)); Nodo exp = Expresion.expresionC3D(atr.valor); Acceso.actual = null; instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Obtener posicion del atributo " + atr.nombre)); Nodo nodo = Acceso.generarC3DID(atr.nombre, Acceso.Tipo.SUPER, "P", "Stack"); if (nodo != null) { // Asignar la expresion instrucciones.Add(new C3D((int)C3D.TipoC3D.COMENTARIO, "// Guardar valor del atributo " + atr.nombre)); instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR, nodo.estructura, nodo.referencia, exp.cadena)); } } } } } } }
public void setClase(ref Clase nueva) { this.clase = nueva; txtClase.Text = nueva.nombre; }