//VarDecl = Type ident { "," ident } ";" .
// First(VarDecl)={ident}; Follow(VarDecl)={"{"}
// too puede ser un field, ademas de una ., o un Global
static void VardDecl(Symbol.Kinds kind, System.Windows.Forms.TreeNode padre)
{
//visto //si es "int[] pos" y viene de "Class Tabla {", kind es "Field"
// si es Tabla val y viene de "class P {", kind es "Global"
Struct type;// = new Struct(Struct.Kinds.None); //int i;
Code.seleccLaProdEnLaGram(6);
if (muestraProducciones) MessageBoxCon3Preg();
Code.cargaProgDeLaGram("VarDecl = Type ident IdentifiersOpc ';'");
/////
//Cambiar desde aca aaaaaaaaaaa
System.Windows.Forms.TreeNode hijo1 = new System.Windows.Forms.TreeNode("VarDecl = Type ident IdentifiersOpc ';'");
padre.Nodes.Add(hijo1);
/////
Type(out type); //En VardDecl
//int[] en el caso del "int[] pos",... int, Table, Persona, int[], etc
//Table en el caso de Table val;
//int en int x;
////
hijo1.Nodes.Add("Type = "+type.kind.ToString());
////
Check(Token.IDENT); // "pos", en int pos, .....int,.... x, i, etc
////
hijo1.Nodes.Add("ident");
////
System.Windows.Forms.TreeNode hijo2 = new System.Windows.Forms.TreeNode("IdentifiersOpc");
hijo1.Nodes.Add(hijo2);
////
// debo insertar el token en la tabla de símbolos
Code.coloreaConRojo("token");
//Code.coloreaConRojo(true); //Ya viene pintado
cantVarLocales++; //provisorio: esto deberia hacerlo solo para el caso de var locales (no para var globales)
Symbol vble = Tab.Insert(kind, token.str, type);
//vble no, poner simbolo (para pos, en int[] pos)
//pues en este caso es campo, y devuelve el Symbol p/pos, type es int[]
//puede ser val, en Tabla val, y type es Table //y devuelve el Symbol p/val
Code.CreateMetadata(vble); //Para el campo pos (en int[] pos)Global, Field o .....
//o Para la vbe Global val
//o para x en int x;
Code.seleccLaProdEnLaGram(7);
//Code.cargaProgDeLaGram("IdentifiersOpc = . | ',' ident IdentifiersOpc.");
while (la == Token.COMMA && la != Token.EOF)
{
Scan(); // Check(Token.COMMA);
Code.coloreaConRojo("token");
//Code.coloreaConRojo(true);
Code.cargaProgDeLaGram("IdentifiersOpc = ',' ident IdentifiersOpc.");//deberia extender el arbol
////
hijo2.Nodes.Add("','");
////
//if (muestraProducciones) MessageBoxCon3Preg();
Check(Token.IDENT); //otro identif
hijo2.Nodes.Add("ident");
Code.coloreaConRojo("token");
//Code.coloreaConRojo(true);
cantVarLocales++; //provisorio: esto deberia hacerlo solo para el caso de var locales (no para var globales)
//if (muestraProducciones) MessageBoxCon3Preg();
vble = Tab.Insert(kind, token.str, type);
Code.CreateMetadata(vble); //Para i, en int x,i
Code.seleccLaProdEnLaGram(7);
//Code.cargaProgDeLaGram("IdentifiersOpc = . | ',' ident IdentifiersOpc.....al semicolon");
}
Check(Token.SEMICOLON);
hijo1.Nodes.Add("';'");
Code.coloreaConRojo("token");
//Code.coloreaConRojo(true);
Code.cargaProgDeLaGram("IdentifiersOpc = .");
}
//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");
}
}
//////////////////////////////////////////////////////////////////////////
/* Starts the analysis.
* Output is written to System.out.
*/
public static void Parse(string prog)
{
// output = new TestTextWriter(); //Console.Out
//entrada del parser salida
Scanner.Init(new StringReader(prog), null); //deja en ch el 1° char de prog
Tab.Init(); //topScope queda apuntando al Scope p/el universe
Errors.Init();
curMethod = null;
token = null;
//Con 1° char de prog en la vble ch, ya puede comenzar el Scanner
laToken = new Token(1, 1); // avoid crash when 1st symbol has scanner error
//porque el Scan comienza con token = laToken
Scan(); // scan first symbol
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
Program(); // start analysis
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//BitArray conjunto = new BitArray(Token.names.Length);
//
//conjunto[Token.EOF] = true;
//Program(conjunto);
Check(Token.EOF);
//Console.WriteLine("========================================");
//Code.il.EmitCall(Code.CALL, Code.readChar, null);
//esto estaba de antes
//Code.il.Emit(OpCodes.Ldc_I4_1);
//Code.il.Emit(OpCodes.Ldc_I4_1);
//int[] ctorParams = { 1, 9 }; //new int[2]
//Type[] ctorParams = new Type[] { typeof(int), typeof(int) };
//Code.il.EmitCall(Code.CALL, Code.writeInt, ctorParams);
//Console.WriteLine("========================================");
//if (ZZ.readKey) Console.ReadKey();
}
internal static void CreateMetadata(Symbol sym)
{
switch (sym.kind)
{
case Symbol.Kinds.Global: //ya visto
if (sym.type != Tab.noType)
sym.fld = program.DefineField(sym.name, sym.type.sysType, GLOBALATTR);
break;
case Symbol.Kinds.Field: //ya visto
if (sym.type != Tab.noType) //Puede se int[]
sym.fld = inner.DefineField(sym.name, sym.type.sysType, FIELDATTR);
break;
case Symbol.Kinds.Local:
LocalBuilder vbleLocalDin = il.DeclareLocal(sym.type.sysType);
if (primeraVez)
{
ultimaVbleLocalDin = vbleLocalDin;
primeraVez = false;
}
break;
case Symbol.Kinds.Type:
inner = module.DefineType(sym.name, INNERATTR);
sym.type.sysType = inner;
// define default contructor (calls base constructor)
sym.ctor = inner.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard, new Type[0]);
il = sym.ctor.GetILGenerator();
il.Emit(LDARG0);
//il.Emit(CALL, objCtor); //este no funca
il.Emit(CALL, typeof(object).GetConstructor(new Type[0]));
il.Emit(RET);
break;
case Symbol.Kinds.Meth:
//sym.name
//MethodBuilder writeStrMthd1 = program.DefineMethod("Main", MethodAttributes.Public, typeof(void), null);
//ok sym.meth = program.DefineMethod("Main", MethodAttributes.Public, typeof(void), null);
sym.meth = program.DefineMethod(sym.name, MethodAttributes.Public, typeof(void), null);
//METHATTR (que es lo que viene originalm) no funca
//sym.meth = program.DefineMethod("Main", METHATTR, sym.type.sysType, null); // args); //Provis
//il = writeStrMthd1.GetILGenerator();
il = sym.meth.GetILGenerator();
if (sym.name == "Main")
{
assembly.SetEntryPoint(sym.meth);
// Console.WriteLine("pasa por assembly.SetEntryPoint(sym.meth)");
}
//il.EmitWriteLine("...dentro del Main..."); funca bien
//il.Emit(OpCodes.Ret);//AQUI NO
break;
case Symbol.Kinds.Prog:
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = sym.name;
//Console.WriteLine(sym.name); if (ZZ.readKey) Console.ReadKey();
assembly =
AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, //originalm:Save
AssemblyBuilderAccess.RunAndSave);
module = assembly.DefineDynamicModule(sym.name + "Module", sym.name + ".exe");//".exe"
program = module.DefineType(sym.name, PROGATTR); //clase din para el program
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
ConstructorBuilder pointCtor =
program.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard, new Type[0]);
ILGenerator ctorIL = pointCtor.GetILGenerator();
// First, you build the constructor.
ctorIL.Emit(OpCodes.Ldarg_0);
//ctorIL.EmitWriteLine("...dentro del constr de class P..."); //funca bien
ctorIL.Emit(OpCodes.Call, objCtor);
ctorIL.Emit(OpCodes.Ret);
inner = null;
// build methods for I/O keywords (read, write)
BuildReadChar();//como lo usa?
BuildReadInt();
BuildWriteChar();
BuildWriteInt();
break;
}
}
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;
}
}
public static void OpenScope(Symbol sym)
{
Scope s = new Scope();
s.nArgs = 0;
s.nLocs = 0;
s.outer=topScope;
topScope=s;
//Codigo Tabla de Simbolos
ultimosNodos.Push(ultimoNodo);
ultimosParametros.Push(new List<TreeNode>());
if (sym != null)
{
profundidad++;
Program1.form1.arbolTS.Nodes.Add("Scope de :Type: " + sym.kind + " | Name: " + sym.name);
}
if (muestraTabSimb) Program1.form1.instContinuar.ShowDialog(); //MessageBox.Show("ContinuarTSimb","T de simbolo");
//Codigo Tabla de Simbolos
}
//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 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();
}
public static Symbol FindSymbol(string name, Symbol puntSymbol)
{
//Fran
for (Symbol sym = puntSymbol; sym != null; sym = sym.next)
if (sym.name == name)
{
if (ZZ.SymTab)
{
Console.WriteLine("Encontró " + name + " con FindSymbol");
};
return sym;
}
Parser.Errors.Error("ERROR: " + name + " no está delcarado");
return noSym;
}
public bool Equals(Symbol sym)
{
if (kind != sym.kind || name != sym.name || !type.Equals(sym.type))
return false;
switch (kind) {
case Kinds.Const: return val == sym.val;
case Kinds.Arg: case Kinds.Local: return adr == sym.adr;
case Kinds.Meth:
return nArgs == sym.nArgs && nLocs == sym.nLocs &&
EqualsCompleteList(locals, sym.locals);
}
return true;
}
/* Compare complete Symbol node lists. */
public static bool EqualsCompleteList(Symbol sym1, Symbol sym2)
{
if (sym1 == sym2) return true; // same object
while (sym1 != null && sym1.Equals(sym2)) {
sym1 = sym1.next; sym2 = sym2.next;
}
if (sym1 != null || sym2 != null) return false;
return true;
}
