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;
            }
        }
Example #4
0
 // special constructor for Stack Items
 internal Item(Struct type)
 {
     kind = Kinds.Stack;
     this.type = type;
 }
Example #5
0
 // 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();
 }
Example #6
0
 // special constructor for Const Items
 public Item(int val)
 {
     kind = Kinds.Const; type = Tab.intType; this.val = val;
 }
Example #7
0
        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 = .");
            }
        }
Example #10
0
        //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 = .");
            }
        }
Example #16
0
 // special constructor for Const Items
 public Item(int val)
 {
     kind = Kinds.Const; type = Tab.intType; this.val = val;
 }
        //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");
            }
        }
Example #18
0
 // special constructor for Stack Items
 internal Item(Struct type)
 {
     kind      = Kinds.Stack;
     this.type = type;
 }
        /* 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
        }