public bool AssignableTo(Struct dest) { return this.Equals(dest) || this == Tab.nullType && dest.IsRefType() || // for predefined function len(Array of noType) kind == Kinds.Arr && dest.kind == Kinds.Arr && dest.elemType == Tab.noType; }
public Struct(Kinds kind, Struct elemType) { this.kind = kind; // set CLR type of Struct instance switch (kind) { case Struct.Kinds.String: sysType=typeof(string);break; case Struct.Kinds.None: sysType = typeof(void); break; case Struct.Kinds.Int: sysType = typeof(int); break; case Struct.Kinds.Char: sysType = typeof(char); break; case Struct.Kinds.Arr: //int //long (del array) sysType = Array.CreateInstance(elemType.sysType, 0).GetType();//Metadata para int[] this.elemType = elemType; //(struct para int[]).elemType = (struct para el int) break; case Struct.Kinds.Class: // do nothing here, type must first be defined // sysType is set in Code.CreateMetadata before first use break; } this.elemType = elemType; //si int[], hace la asig 2 veces }
/* Factor = Designator [ "(" [ ActPars ] ")" ] * | number * | charConst * | "new" ident [ "[" Expr "]" ] * | "(" Expr ")" . */ // First(Factor)={ident, number, charconst, new, "("} // Follow(Factor)={*, /, %} static void Factor(out Item item, System.Windows.Forms.TreeNode padre) { Struct xType; //luego debe devolver el xType en Factor(...) if (la == Token.IDENT) { ////////// System.Windows.Forms.TreeNode hijodesignator = new System.Windows.Forms.TreeNode("Designator OpcRestOfMethCall"); padre.Nodes.Add(hijodesignator); ///////// Designator(out item,hijodesignator); //en el Factor if (la == Token.LPAR) {//meth(params) Check(Token.LPAR); Code.cargaProgDeLaGram("OpcRestOfMethCall = '(' OpcActPars ')'."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); // el "(" if (muestraProducciones) MessageBoxCon3Preg(); if (la == Token.MINUS || la == Token.IDENT || la == Token.NUMBER || la == Token.CHARCONST || la == Token.NEW || la == Token.LPAR) ActPars(); //Esta parte falta Check(Token.RPAR); } else { Code.cargaProgDeLaGram("OpcRestOfMethCall = ."); Code.coloreaConRojo("latoken"); //Code.coloreaConRojo(false); // el "(" if (muestraProducciones) MessageBoxCon3Preg(); } } else switch (la) { case Token.NUMBER: Check(Token.NUMBER); Code.cargaProgDeLaGram("Factor = number."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); ///// System.Windows.Forms.TreeNode hijonumber = new System.Windows.Forms.TreeNode("Factor = number."); padre.Nodes.Add(hijonumber); ///// if (muestraProducciones) MessageBoxCon3Preg(); item = new Item(token.val);//Nuevo Code.Load(item); break; case Token.CHARCONST: Check(Token.CHARCONST); item = new Item(token.val); item.type = Tab.charType; break; case Token.NEW: Check(Token.NEW); Check(Token.IDENT); //Deberia buscar en la Tab y verificar que sea un Tipo o una clase Symbol sym = Tab.Find(token.str); //ident debe ser int, char, o una clase (Table) if (sym.kind != Symbol.Kinds.Type) Errors.Error("type expected"); Struct type = sym.type; //si es clase, sym.type contiene un puntero a los campos de esa clase if (ZZ.parser) Console.WriteLine("Tab.Find(" + token.str + ") =>" + sym.ToString() + "..."); //if (ZZ.readKey) Console.ReadKey(); if (sym == null) { Errors.Error("--debe venir un tipo");//Fran xType = Tab.noType; } else { xType = sym.type; //Devuelve int como tipo (Struct), no como nodo Symbol if (ZZ.parser) Console.WriteLine("Encontró " + token.str); //if (ZZ.readKey) Console.ReadKey(); }; if (ZZ.parser) Console.WriteLine("Terminó new " + token.str); //if (ZZ.readKey) Console.ReadKey(); if (la == Token.LBRACK) { Check(Token.LBRACK); //Expr(); String finalDeExpr = token.str; Expr(out item); if (item.type != Tab.intType) Errors.Error("array size must be of type int"); Code.Load(item); //genera cod p/cargar el result de la expr // new char [10] Code.il.Emit(Code.NEWARR, type.sysType); //NEWARR de char type = new Struct(Struct.Kinds.Arr, type); //el nuevo type será array de char (pag 33 de T de simb) Check(Token.RBRACK); //if (ZZ.parser) Console.WriteLine("Pasa por [" + finalDeExpr + "]"+ "token.kind= "+Token.names[token.kind]+" token.tr="+token.str); } else { if (sym.ctor == null) { Console.WriteLine("Error sym.ctor == null"); if (ZZ.readKey) Console.ReadKey(); }; if (type.kind == Struct.Kinds.Class) //new Table pag 34 de T. De Simb Code.il.Emit(Code.NEWOBJ, sym.ctor); //emite cod p/new Table qq1 else { Errors.Error("class type expected"); type = Tab.noType; } } item = new Item(type); //item.type = type; lo hace en el constr Item(Struct type) break; case Token.LPAR: Check(Token.LPAR); //Expr(); //////////////////////// padre.Nodes.Add("'('"); ////////////////////// Expr(out item,padre); Check(Token.RPAR); ///////////////// padre.Nodes.Add("')'"); //////////////// break; default: Errors.Error(ErrorStrings.INVALID_FACT); item = new Item(3); //sucio: p/q no de error break; } }
// special constructor for Stack Items internal Item(Struct type) { kind = Kinds.Stack; this.type = type; }
// special constructor for Cond Items public Item(int relop, Struct type) { this.kind = Kinds.Cond; this.type = type; this.relop = relop; tLabel = Code.il.DefineLabel(); fLabel = Code.il.DefineLabel(); }
// special constructor for Const Items public Item(int val) { kind = Kinds.Const; type = Tab.intType; this.val = val; }
public int val; // Const: value #endregion Fields #region Constructors public Item(Symbol sym) { type = sym.type; this.sym = sym; switch (sym.kind) { case Symbol.Kinds.Const: kind = Kinds.Const; val = sym.val; break; case Symbol.Kinds.Arg: kind = Kinds.Arg; adr = sym.adr; break; case Symbol.Kinds.Local: kind = Kinds.Local; adr = sym.adr; break; case Symbol.Kinds.Global: kind = Kinds.Static; break; case Symbol.Kinds.Field: kind = Kinds.Field; break; case Symbol.Kinds.Meth: kind = Kinds.Meth; break; default: Parser.Errors.Error(ErrorStrings.CREATE_ITEM); break; } }
internal MethodBuilder meth; // Method: builder for metadata and CIL #endregion Fields #region Constructors public Symbol(Kinds kind, string name, Struct type) { this.kind = kind; this.name = name; this.type = type; }
//Fran /* Type = ident [ "[" "]" ] */ // First(Type)={ident} // Follow(Type)={ident} //static void Type() { } static void Type(out Struct xType) { //en const int size = 10, ..en int[] Code.seleccLaProdEnLaGram(12); Code.cargaProgDeLaGram("Type = ident LbrackOpc."); if (la != Token.IDENT) //debe venir un tipo (int por ej) { Errors.Error("espera un tipo"); xType = Tab.noType; } else { //laToken=int, en int[] Check(Token.IDENT); //=> token=int y laToken=[, .....token=int y laToken=size, en int size Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //si viene de... yaPintado = true => no pinta nada Symbol sym = Tab.Find(token.str); //busca int y devuelve el Symbol p/int //Busca Table y devuelve el Symbol p/Table if (ZZ.parser) Console.WriteLine("Tab.Find(" + token.str + ") =>" + sym.ToString() + "..."); //if (ZZ.readKey) Console.ReadKey(); if (sym == null) { Errors.Error("debe venir un tipo");//Fran xType = Tab.noType; } else { xType = sym.type; //Devuelve int como tipo (Struct), no como nodo Symbol }; //??Tab.Insert(Symbol.Kinds.Type, token.str, Tab.noType); //o es un tipo array (int[]) o no (int, unaClase) Code.seleccLaProdEnLaGram(13); //Code.cargaProgDeLaGram("LbrackOpc = .| '[' ']'."); Code.coloreaConRojo("latoken"); //Code.coloreaConRojo(false); //un "[" o lo que sigue al type (un ident en int ident1) if (la == Token.LBRACK) // {//int[] Code.cargaProgDeLaGram("LbrackOpc = '[' ']'."); Check(Token.LBRACK); Check(Token.RBRACK); //int tipo del elem del array xType = new Struct(Struct.Kinds.Arr, sym.type); //podria haber sido xType (Struct del int) en vez de sym.type //el nuevo xType que obtiene es un array de int } else Code.cargaProgDeLaGram("LbrackOpc = ."); } }
//void Main() int x,i; {val = new Table;....} /* MethodDecl = ( Type | "void" ) ident "(" [ FormPars ] ")" * { VarDecl } Block . */ // First(MethodDecl)={ident, void}; Follow(MethodDecl)={"}"} static void MethodDecl(System.Windows.Forms.TreeNode padre) { /////// System.Windows.Forms.TreeNode hijo1 = new System.Windows.Forms.TreeNode("TypeOrVoid ident '(' Pars ')' PosDeclars Block"); padre.Nodes.Add(hijo1); ////// Struct type = new Struct(Struct.Kinds.None); //Pone por defecto void if (la == Token.VOID || la == Token.IDENT) { if (la == Token.VOID) { Check(Token.VOID); //token = void laToken = Main Code.coloreaConRojo(true); //if (muestraProducciones) MessageBoxCon3Preg(); Code.cargaProgDeLaGram("MethodDeclsOpc = MethodDecl MethodDeclsOpc."); Code.seleccLaProdEnLaGram(8); //MethodDecl = TypeOrVoid ident "(" PossFormPars ")" Block. //if (muestraProducciones) MessageBoxCon3Preg(); Code.cargaProgDeLaGram("MethodDecl = TypeOrVoid ident '(' Pars ')' PosDeclars Block."); Code.seleccLaProdEnLaGram(9); // 9.TypeOrVoid = Type | "void“. //if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("TypeOrVoid = Type | 'void'."); Code.cargaProgDeLaGram("TypeOrVoid = 'void'."); /////////// System.Windows.Forms.TreeNode hijo2 = new System.Windows.Forms.TreeNode("TypeOrVoid = Type | 'void'"); hijo1.Nodes.Add(hijo2); hijo2.Nodes.Add("'void'"); ////////// type = Tab.noType; // para void } else if (la == Token.IDENT) { Type(out type); // token = UnTipo laToken = Main Code.cargaProgDeLaGram("TypeOrVoid = Type."); Code.coloreaConRojo(true); /////////// System.Windows.Forms.TreeNode hijo2 = new System.Windows.Forms.TreeNode("TypeOrVoid = Type"); hijo1.Nodes.Add(hijo2); hijo2.Nodes.Add("Type= "+type.kind.ToString()); ////////// } Check(Token.IDENT); //Main por ej. //token = Main, laToken = "(" Code.coloreaConRojo(true); /////// hijo1.Nodes.Add("ident"); ////// curMethod = Tab.Insert(Symbol.Kinds.Meth, token.str, type);//inserta void Main // que pasa si hubieran parametros? Tab.OpenScope(curMethod); // tengo que insertar un método en la tabla de símbolo // todos los parámetros son locales //tipoSimbolo = Symbol.Kinds.Local; Check(Token.LPAR); //Si Main() => no tiene FormPars Code.coloreaConRojo(true); //// hijo1.Nodes.Add("'('"); //// Code.seleccLaProdEnLaGram(10); //10.Pars = . | FormPar CommaFormParsOpc. ///////// System.Windows.Forms.TreeNode otrohijo2 = new System.Windows.Forms.TreeNode("Pars = . | FormPar CommaFormParsOpc. "); hijo1.Nodes.Add(otrohijo2); if (la == Token.IDENT) // { FormPars(otrohijo2); //Aqui hay que crear los symbolos para los args } //y colgarlos de curMethod.locals else { Code.coloreaConRojo(false); //pinta el ")" Code.cargaProgDeLaGram("Pars = ."); ///////// otrohijo2.Nodes.Add("Pars = ."); //////// //if (muestraProducciones) MessageBoxCon3Preg(); } Check(Token.RPAR); //// hijo1.Nodes.Add("')'"); //// Code.seleccLaProdEnLaGram(1); //1.Declarations = .| Declaration Declarations. //Code.cargaProgDeLaGram("PosDeclars = .| Declaration PosDeclars."); //////////// System.Windows.Forms.TreeNode hijo22 = new System.Windows.Forms.TreeNode("PosDeclars"); hijo1.Nodes.Add(hijo22); bool banderita=false; /////////// Code.CreateMetadata(curMethod); //genera il //Declaraciones por ahora solo decl de var, luego habria q agregar const y clases while (la != Token.LBRACE && la != Token.EOF) //void Main()==> int x,i; {val = new Table;....} { //Code.cargaProgDeLaGram("Block = '{' StatementsOpc '}'."); if (la == Token.IDENT) { banderita = true; Code.coloreaConRojo(false); //colorea "int" en int i; Code.cargaProgDeLaGram("PosDeclars = Declaration PosDeclars."); Code.seleccLaProdEnLaGram(2); //Code.cargaProgDeLaGram("Declaration = ConstDecl | VarDecl | ClassDecl."); //Code.seleccLaProdEnLaGram(2); Code.cargaProgDeLaGram("Declaration = VarDecl."); //////// System.Windows.Forms.TreeNode hijo3 = new System.Windows.Forms.TreeNode("Declaration = VarDecl "); hijo22.Nodes.Add(hijo3); /////////// VardDecl(Symbol.Kinds.Local,hijo3); // int x,i; en MethodDecl() //cantVarLocales++; /////// } else { token = laToken; Errors.Error("espero una declaracion de variable"); } } Code.seleccLaProdEnLaGram(1); Code.coloreaConRojo(false); //"{" if (banderita == false) { Code.cargaProgDeLaGram("PosDeclars = ."); hijo22.Nodes.Add("PosDeclars = ."); } //if (muestraProducciones) MessageBoxCon3Preg(); if (cantVarLocales > 0) { string instrParaVarsLocs = ".locals init(int32 V_0"; for (int i = 1; i < cantVarLocales; i++) { instrParaVarsLocs = instrParaVarsLocs + "," + "\n int32 V_" + i.ToString(); // +" "; } instrParaVarsLocs = instrParaVarsLocs + ")"; Code.cargaInstr(instrParaVarsLocs); } ////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////// Block(hijo1); //Bloque dentro de MethodDecl() ////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////// curMethod.nArgs = Tab.topScope.nArgs; curMethod.nLocs = Tab.topScope.nLocs; curMethod.locals = Tab.topScope.locals; Tab.CloseScope(); Tab.mostrarTab(); Code.il.Emit(Code.RET); //si lo saco se clava en el InvokeMember Parser.nroDeInstrCorriente++; Parser.cil[Parser.nroDeInstrCorriente].accionInstr = Parser.AccionInstr.ret; Code.cargaInstr("ret"); } }
public bool CompatibleWith(Struct other) { return this.Equals(other) || this == Tab.nullType && other.IsRefType() || other == Tab.nullType && this.IsRefType(); }
public static Symbol Insert(Symbol.Kinds kind, string name, Struct type) { Symbol s; // = null; /// agregado hasta ver qué pasa s = new Symbol(kind, name, type); s.next = null; switch (kind) { //fran case Symbol.Kinds.Arg: s.adr = topScope.nArgs++;break; case Symbol.Kinds.Local:s.adr = topScope.nLocs++;break; }; Symbol actual = topScope.locals, ultimo=null; while (actual != null) //Fran sólo es necesario buscar en el Scope actual { if (actual.name == name) Parser.Errors.Error(name + " está declarado más de una vez "); ultimo = actual; actual = actual.next; } if (ultimo == null) topScope.locals = s; else ultimo.next = s; //Codigo Tabla de Simbolos string str; switch(s.kind) { case Symbol.Kinds.Meth: str = " | Locals:"; break; case Symbol.Kinds.Type: str =(s.name != "int" && s.name != "char")? " | Fields:":""; break; case Symbol.Kinds.Prog: str = " | Fields:"; break; default: str = "";break; } Program1.form1.arbolTS.Nodes[profundidad].Nodes.Add("Type: "+s.kind+ " | Name: " +s.name + str); ultimosParametros.Peek().Add(ultimoNodo = Program1.form1.arbolTS.Nodes[profundidad].Nodes[Program1.form1.arbolTS.Nodes[profundidad].Nodes.Count - 1]); Program1.form1.arbolTS.ExpandAll(); if (muestraTabSimb) Program1.form1.instContinuar.ShowDialog(); //MessageBox.Show("ContinuarTSimb", "T de simbolo"); //Codigo Tabla de Simbolos return s; }
/* Sets up the "universe" (= predefined names). */ public static void Init() { //Codigo Tabla de Simbolos Program1.form1.arbolTS.Nodes.Clear(); profundidad = 0; //Codigo Tabla de Simbolos // tipos estándar: int, char Tab.OpenScope(null); //topScope queda apuntando al Scope p/el universe Program1.form1.arbolTS.Nodes.Add("Scope Universe"); Tab.Insert(Symbol.Kinds.Type, "int", Tab.intType); Tab.Insert(Symbol.Kinds.Type, "char", Tab.charType); Tab.Insert(Symbol.Kinds.Const, "null", Tab.nullType); //Métodos estándares //chr(i) chrSym = Tab.Insert(Symbol.Kinds.Meth, "chr", Tab.charType); Tab.OpenScope(chrSym); Tab.Insert(Symbol.Kinds.Arg, "i", Tab.intType); //el arg q toma es int (Un Symbol char) //Program1.form1.arbolTS.Nodes[0].Nodes[3].Nodes.Add("i | ARG"); chrSym.nArgs = topScope.nArgs; //Fran chrSym.nLocs = topScope.nLocs; //Fran chrSym.locals = Tab.topScope.locals; Tab.CloseScope();//Fran cierra el Scope para el arg "i" Tab.mostrarTab(); // ord(ch) ordSym = Tab.Insert(Symbol.Kinds.Meth, "ord", Tab.intType);//devuelve int //Program1.form1.arbolTS.Nodes[0].Nodes.Add("ord | METH"); //char=tipo q devuelve el met (Struct) Tab.OpenScope(ordSym); Tab.Insert(Symbol.Kinds.Arg, "ch", Tab.charType);//el arg es char //Program1.form1.arbolTS.Nodes[0].Nodes[4].Nodes.Add("ch | ARG"); ordSym.nArgs = topScope.nArgs; //Fran ordSym.nLocs = topScope.nLocs; //Fran ordSym.locals = Tab.topScope.locals; Tab.CloseScope();//Fran cierra el Scope para el arg "ch" Tab.mostrarTab(); //len(arr) lenSym = Tab.Insert(Symbol.Kinds.Meth, "len", Tab.intType);//devuelve int //Program1.form1.arbolTS.Nodes[0].Nodes.Add("ord | METH"); //char=tipo q devuelve el met (Struct) Tab.OpenScope(lenSym); //El arg q toma es un Symbol con tipo Arr, el tipo del Elem del Arr es noType Struct tipoArr = new Struct(Struct.Kinds.Arr, Tab.intType); //debiera funcionar para arreglos de cualquier tipo (no solo de enteros) //segun pag 41 de Tabla de simb.ppt, debiera se Tab.noType (en vez de intType) //pero el Tab.noType da error, Tab.Insert(Symbol.Kinds.Arg, "arr", tipoArr); //Program1.form1.arbolTS.Nodes[0].Nodes[5].Nodes.Add("arr | ARG"); lenSym.nArgs = topScope.nArgs; //Fran lenSym.nLocs = topScope.nLocs; //Fran lenSym.locals = Tab.topScope.locals; Tab.CloseScope();//Fran cierra el Scope para el arg "arr" Tab.mostrarTab(); }
/* Retrieves the field name from the fields of type. */ public static Symbol FindField(string name, Struct type) { /*---------------------------------*/ /*----- insert your code here -----*/ /*---------------------------------*/ Symbol s = null;/// agregado hasta ver qué pasa return s; }
///////////FALTA ARBOL /* FormPars = Type ident { "," ident } . */ // First(FormPars)={ident} ; Follow(FormPar)={")"} static void FormPars(System.Windows.Forms.TreeNode padre) { //seguram hay que insertar el la Tab Struct type = new Struct(Struct.Kinds.None); if (la == Token.IDENT) { Type(out type); // Code.seleccLaProdEnLaGram(5); //if (muestraProducciones) MessageBoxCon3Preg(); Code.cargaProgDeLaGram("PossFormPars = FormPar CommaFormParsOpc."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //if (muestraProducciones) MessageBoxCon3Preg(); Check(Token.IDENT); //x Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); while (la == Token.COMMA && la != Token.EOF) { Check(Token.COMMA); Code.cargaProgDeLaGram("CommaFormParsOpc = ',' FormPar CommaFormParsOpc."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); Type(out type); Check(Token.IDENT); Code.seleccLaProdEnLaGram(6); Code.cargaProgDeLaGram("PossFormPars = FormPar CommaFormParsOpc."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); }//Fin while Code.cargaProgDeLaGram("CommaFormParsOpc = ."); } }
//void Main() int x,i; {val = new Table;....} /* MethodDecl = ( Type | "void" ) ident "(" [ FormPars ] ")" * { VarDecl } Block . */ // First(MethodDecl)={ident, void}; Follow(MethodDecl)={"}"} static void MethodDecl(System.Windows.Forms.TreeNode padre) { /////// padre = "MethodDeclsOpc" System.Windows.Forms.TreeNode hijo1 = new System.Windows.Forms.TreeNode("MethodDecl"); //luego hay que sacarlo y modificar la rama del ident //padre.Nodes.Add(hijo1); //////// //MessageBoxCon3Preg(); System.Windows.Forms.TreeNode methodDecl = new System.Windows.Forms.TreeNode("MethodDecl"); //cuelga ESTE NODO DESPUES DE pintar el void Struct type = new Struct(Struct.Kinds.None); //Pone por defecto void if (la == Token.VOID || la == Token.IDENT) { if (la == Token.VOID) { Check(Token.VOID); //token = void laToken = Main Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //pinta void //incluye if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("MethodDeclsOpc = MethodDecl MethodDeclsOpc."); //Una vez que encuentra "void", infiere que debe usar la opcion: methodDecl.... etc padre.Nodes.Add(methodDecl); padre.Expand(); //////// if (muestraProducciones) MessageBoxCon3Preg(); Code.seleccLaProdEnLaGram(8); //MethodDecl = TypeOrVoid ident "(" PossFormPars ")" Block. if (muestraProducciones) MessageBoxCon3Preg(); System.Windows.Forms.TreeNode typeOrVoid = new System.Windows.Forms.TreeNode("TypeOrVoid"); //ya ha pintado el void methodDecl.Nodes.Add(typeOrVoid); methodDecl.Expand(); if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("MethodDecl = TypeOrVoid ident '(' Pars ')' PosDeclars Block."); Code.seleccLaProdEnLaGram(9); // 9.TypeOrVoid = Type | "void“. if (muestraProducciones) MessageBoxCon3Preg(); //como ya ha verificado "void", typeOrVoid.Nodes.Add("'void'"); typeOrVoid.Expand(); if (muestraProducciones) MessageBoxCon3Preg(); type = Tab.noType; // para void } else if (la == Token.IDENT) { Type(out type); // token = UnTipo laToken = Main Code.cargaProgDeLaGram("TypeOrVoid = Type."); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); /////////// //hay que cambiar hijo1 por methodDecl, e hijo2 por... System.Windows.Forms.TreeNode hijo2 = new System.Windows.Forms.TreeNode("TypeOrVoid = Type"); hijo1.Nodes.Add(hijo2); hijo2.Nodes.Add("Type= "+type.kind.ToString()); ////////// } /////// methodDecl.Nodes.Add("ident"); if (muestraProducciones) MessageBoxCon3Preg(); Check(Token.IDENT); //Main por ej. //token = Main, laToken = "(" Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //hijo1.Nodes.Add("ident"); ////// curMethod = Tab.Insert(Symbol.Kinds.Meth, token.str, type);//inserta void Main // que pasa si hubieran parametros? Tab.OpenScope(curMethod); // tengo que insertar un método en la tabla de símbolo // todos los parámetros son locales //tipoSimbolo = Symbol.Kinds.Local; //// methodDecl.Nodes.Add("'('"); if (muestraProducciones) MessageBoxCon3Preg(); //// Check(Token.LPAR); //Si Main() => no tiene FormPars Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); ///////// System.Windows.Forms.TreeNode pars = new System.Windows.Forms.TreeNode("Pars"); methodDecl.Nodes.Add(pars); if (muestraProducciones) MessageBoxCon3Preg(); Code.seleccLaProdEnLaGram(10); //10.Pars = . | FormPar CommaFormParsOpc. if (muestraProducciones) MessageBoxCon3Preg(); if (la == Token.IDENT) // { FormPars(pars); //Aqui hay que crear los symbolos para los args methodDecl.Nodes.Add("')'"); if (muestraProducciones) MessageBoxCon3Preg(); Check(Token.RPAR); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //pinta el ")" } //y colgarlos de curMethod.locals else { //infiere que no hay params => 1) debe venir un ")". 2) La pocion de la produccion es "." //Code.cargaProgDeLaGram("Pars = ."); Check(Token.RPAR); Code.coloreaConRojo("token"); //Code.coloreaConRojo(true); //pinta el ")" pars.Nodes.Add("."); pars.Expand(); if (muestraProducciones) MessageBoxCon3Preg(); methodDecl.Nodes.Add("')'"); if (muestraProducciones) MessageBoxCon3Preg(); } System.Windows.Forms.TreeNode posDeclars = new System.Windows.Forms.TreeNode("PosDeclars"); methodDecl.Nodes.Add(posDeclars); if (muestraProducciones) MessageBoxCon3Preg(); Code.seleccLaProdEnLaGram(1); //1.Declarations = .| Declaration Declarations. if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("PosDeclars = .| Declaration PosDeclars."); //////////// System.Windows.Forms.TreeNode hijo22 = new System.Windows.Forms.TreeNode("PosDeclars"); hijo1.Nodes.Add(hijo22); bool banderita=false; /////////// Code.CreateMetadata(curMethod); //genera il //Declaraciones por ahora solo decl de var, luego habria q agregar const y clases while (la != Token.LBRACE && la != Token.EOF) //void Main()==> int x,i; {val = new Table;....} { //Code.cargaProgDeLaGram("Block = '{' StatementsOpc '}'."); if (la == Token.IDENT) { banderita = true; Code.coloreaConRojo("latoken"); //Code.coloreaConRojo(false); //colorea "int" en int i; //Infiere la 2° opcion de PosDeclars aaaaaaaa System.Windows.Forms.TreeNode declaration = new System.Windows.Forms.TreeNode("Declaration"); posDeclars.Nodes.Add(declaration); posDeclars.Expand(); if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("PosDeclars = Declaration PosDeclars."); Code.seleccLaProdEnLaGram(2); if (muestraProducciones) MessageBoxCon3Preg(); //Code.cargaProgDeLaGram("Declaration = ConstDecl | VarDecl | ClassDecl."); //Code.seleccLaProdEnLaGram(2); Code.cargaProgDeLaGram("Declaration = VarDecl."); //////// //Puesto q leyò un ident, infiere q la opcion de la produccion es "VarDecl" System.Windows.Forms.TreeNode varDecl = new System.Windows.Forms.TreeNode("VarDecl"); declaration.Nodes.Add(varDecl); declaration.Expand(); if (muestraProducciones) MessageBoxCon3Preg(); /////////// VardDecl(Symbol.Kinds.Local, varDecl); // int x,i; en MethodDecl() con int ya consumido //cantVarLocales++; /////// } else { token = laToken; Errors.Error("espero una declaracion de variable"); } } Code.seleccLaProdEnLaGram(1); Code.coloreaConRojo("latoken"); //Code.coloreaConRojo(false); "{" if (banderita == false) { Code.cargaProgDeLaGram("PosDeclars = ."); hijo22.Nodes.Add("PosDeclars = ."); } //if (muestraProducciones) MessageBoxCon3Preg(); if (cantVarLocales > 0) { string instrParaVarsLocs = ".locals init(int32 V_0"; for (int i = 1; i < cantVarLocales; i++) { instrParaVarsLocs = instrParaVarsLocs + "," + "\n int32 V_" + i.ToString(); // +" "; } instrParaVarsLocs = instrParaVarsLocs + ")"; Code.cargaInstr(instrParaVarsLocs); } ////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////// Block(hijo1); //Bloque dentro de MethodDecl() ////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////// curMethod.nArgs = Tab.topScope.nArgs; curMethod.nLocs = Tab.topScope.nLocs; curMethod.locals = Tab.topScope.locals; Tab.CloseScope(); Tab.mostrarTab(); Code.il.Emit(Code.RET); //si lo saco se clava en el InvokeMember Parser.nroDeInstrCorriente++; Parser.cil[Parser.nroDeInstrCorriente].accionInstr = Parser.AccionInstr.ret; Code.cargaInstr("ret"); } }
/* ClassDecl = "class" ident "{" { VarDecl } "}" . */ // First(ClassDecl)={class}; Follow(ClassDecl)={"{"} static void ClassDecl() { //class Table {int i; int j; metodo1... metodo2...} Check(Token.CLASS); //class Table {int[] pos;int[] pos;},.. class C1 {int i; void P1(){}; char ch; int P2{}; int[] arr; } Check(Token.IDENT); // "Table", laToken queda con "{" String nombreDeLaClase = token.str;//Table Struct StructParaLaClase = new Struct(Struct.Kinds.Class); //crear un Struct para la clase (con kind=Class) Check(Token.LBRACE); //"{"... laToken queda con "Table",...const C1, o Table (en class Table) Symbol nodoClase = Tab.Insert(Symbol.Kinds.Type, nombreDeLaClase, //crea symbol p/la clase Table StructParaLaClase); //Con type=class //nodoClase.type = StructParaLaClase; //no hace falta, ya lo hizo en el insert Code.CreateMetadata(nodoClase);//crea clase Din p/Table (por ej.), //queda apuntada por nodoClase.type.sysType // todas las variables que declaren son tipo FIELD, excepto las clases (anidadas) //class C1 { => int i,j; char ch; Pers p=new Pers(); int P2{}; int[] arr; } //class Table { => int[] pos; int[] neg} //por ahora, no permitimos void P1 {}; Tab.OpenScope(nodoClase); while (la != Token.RBRACE && la != Token.EOF) //itera p/c/campo (pos) { switch (la) { case Token.CONST: ConstDecl(null); //const int size = 10 break; case Token.IDENT: //Type ident.., por ej: int i, int[] pos, etc... //tipoSimbolo = Symbol.Kinds.Field... //deberia ser declaracion de campo (pues cuelga de una clase, no de un metodo) VardDecl(Symbol.Kinds.Field,null); // P/distinguir campos de clases //Lo que va a declarar (pos), va a ser un Symbol con kind "field" //int[] pos; break; case Token.CLASS: //por ahora no debiera permitir clases anidadas ??? ClassDecl(); break; default: Errors.Error("Se esperaba Const, tipo, class"); break; } } //crear un Struct para la clase (con kind=Class) //Struct StructParaLaClase = new Struct(Struct.Kinds.Class); //hacer StructParaLaClase.fields = topScope.locals StructParaLaClase.fields = Tab.topScope.locals; //nodoClase.type = StructParaLaClase; Tab.CloseScope(); //con lo cual recuperamos topSScope Check(Token.RBRACE); //laToken queda con Table (en Table ...) //class C1 { => int i,j; char ch; Pers p=new Pers(); int P2{}; int[] arr; } // int i,j; char ch; Pers p..etc, quedó apuntado por topScope.locals }
public bool Equals(Struct other) { if (kind == Kinds.Arr) return other.kind == Kinds.Arr && elemType.Equals(other.elemType); return this == other; // must be same type node }