Ejemplo n.º 1
0
        public IType Visit(Class_Def node)
        {
            Context.ActualType = Context.GetType(node.type.s);
            Context.DefineSymbol("self", Context.ActualType);

            foreach (var attr in Context.GetType(node.inherit_type.s).AllAttributes())
            {
                Context.DefineSymbol(attr.Name, attr.Type);
            }

            foreach (var cldr in node.attr.list_Node)
            {
                IType t = this.Visit(cldr);
                Context.DefineSymbol(cldr.name.name, t);
            }
            foreach (var cldr in node.method.list_Node)
            {
                this.Visit(cldr);
            }

            foreach (var cldr in node.attr.list_Node)
            {
                Context.UndefineSymbol();
            }

            Context.UndefineSymbol();
            return(null);
        }
        public bool Visit(Class_Def node)
        {
            bool solve = true;

            Context.ActualType = Context.GetType(node.type.s);
            Context.DefineSymbol("self", Context.ActualType);
            List <string> id_defines = new List <string>();

            // Definiendo atributos del padre
            foreach (var attr in Context.GetType(node.inherit_type.s).AllAttributes())
            {
                Context.DefineSymbol(attr.Name, attr.Type);
            }

            // Definiendo los atributos del hijo
            foreach (var attr in node.attr.list_Node)
            {
                if (id_defines.Contains(attr.name.name) || Context.ActualType.Father.GetAttribute(attr.name.name) != null)
                {
                    solve   = false;
                    Logger += "En la expresion " + node.ToString() + "-> error de identificador ('" + attr.name.name + "' ya esta definido) \n";
                }
                else
                {
                    id_defines.Add(attr.name.name);
                    Context.DefineSymbol(attr.name.name, Context.GetType(attr.type.s));
                }
            }
            foreach (var mtd in node.method.list_Node)
            {
                if (Context.ThereAreMethod(mtd.name.name))
                {
                    solve   = false;
                    Logger += "En la expresion " + node.ToString() + "-> error de identificador (metodo '" + mtd.name.name + "' ya esta definido) \n";
                }
                else
                {
                    Context.DefineMethod(mtd.name.name, Context.GetType(node.type.s));
                }
                Method mtd_father = Context.ActualType.Father.GetMethod(mtd.name.name);
                if (mtd_father != null && !Method.Equal_Def(mtd, mtd_father))
                {
                    solve   = false;
                    Logger += "En la expresion " + node.ToString() + "-> error de identificador (metodo '" + mtd.name.name + "' esta definido con elementos diferentes en un tipo mayor) \n";
                }
            }
            foreach (var cld in node.attr.list_Node)
            {
                if (!this.Visit(cld))
                {
                    solve = false;
                }
            }

            foreach (var cld in node.method.list_Node)
            {
                if (!this.Visit(cld))
                {
                    solve = false;
                }
            }

            Context.UndefineSymbol(id_defines.Count);

            Context.UndefineMethods();

            return(solve);
        }