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 = .");
}
}
// 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");
}
}
// 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
}