public override Unit VisitArrayInstantiation(ArrayInstatiationAST arrayInstatiation)
{
//tengo que declarar un metodo que sea el que inicialize este array. es decir que le asigne el valor de sizeexp;
TypeInfo tI = arrayInstatiation.CurrentScope.GetTypeInfo(arrayInstatiation.ArrayTypeIdentifier);
Type array = code.DefinedType[tI.CodeName];
ILGenerator il = code.Method.GetILGenerator();
arrayInstatiation.SizeExp.Accept(this);
il.Emit(OpCodes.Newarr, array.GetElementType());
//guardar el array .
LocalBuilder localArray = il.DeclareLocal(array);
il.Emit(OpCodes.Stloc, localArray.LocalIndex);
//inicializar correctamente el array
// for (i =0 to SizeExp ) array[i] = InitializationExp
//TODO: It can be implemented with a generic method that we create (once) in the assembly: Init<T>(T [] elems, T value)
CreateArrayInitializMethod(arrayInstatiation, localArray, array);
il.Emit(OpCodes.Ldloc, localArray.LocalIndex);
if (!code.PushOnStack)
{
il.Emit(OpCodes.Pop);
}
return(Unit.Create());
}
/// <summary>
/// Este metodo es usado para crear un tipo al cual se hace referencia y es posible que no haya sido previamente creado en el codigo IL
/// </summary>
/// <param name="typeDeclaration"></param>
/// <param name="typeId"></param>
/// <returns></returns>
private Type CreateTypeNotFounded(TypeDeclarationAST typeDeclaration, string typeId)
{
TypeInfo type = typeDeclaration.CurrentScope.GetTypeInfo(typeId);
if (code.DefinedType.ContainsKey(type.CodeName))
{
return(code.DefinedType[type.CodeName]);
}
TigerType t = type.Type;
if (t is ArrayType)
{
Type baseType = CreateTypeNotFounded(typeDeclaration, ((ArrayType)t).BaseType.TypeID);
Type arrayType = baseType.MakeArrayType();
code.DefinedType.Add(type.CodeName, arrayType);
return(arrayType);
}
if (t is RecordType)
{
Type temp = code.Module.DefineType(type.CodeName);
code.DefinedType.Add(type.CodeName, temp);
return(temp);
}
throw new NotImplementedException("Los restantes tipos no estan soportados en tiger");
}
public override Unit VisitArrayDeclaration(ArrayDeclarationAST arrayDeclaration)
{
//quedandome con el TypeInfo de tipo base del array.
TypeInfo t = arrayDeclaration.CurrentScope.GetTypeInfo(arrayDeclaration.BaseTypeID);
//en este momento es posible que el tipo del array no halla sido creado en el codigo il.
//este tipo puede ser un array ,un alias o un record ,incluso una clase si se quiere extender esto un poco mas
//creando el tipo del array
Type arrayType = CreateTypeNotFounded(arrayDeclaration, t.TypeId).MakeArrayType();
//annadir el tipo si es necesario.
string arrayCodeName = arrayDeclaration.CurrentScope.GetTypeInfo(arrayDeclaration.TypeId).CodeName;
if (!code.DefinedType.ContainsKey(arrayCodeName))
{
code.DefinedType.Add(arrayCodeName, arrayType);
}
return(Unit.Create());
}
