| public static IsStruct ( System.TypeSpec t ) : bool | ||
| t | System.TypeSpec | |
| Résultat | bool | |
//
// The stack contains the pointer and the value of type `type'
//
public void EmitStoreFromPtr(TypeSpec type)
{
if (type.IsEnum)
{
type = EnumSpec.GetUnderlyingType(type);
}
if (type == TypeManager.int32_type || type == TypeManager.uint32_type)
{
ig.Emit(OpCodes.Stind_I4);
}
else if (type == TypeManager.int64_type || type == TypeManager.uint64_type)
{
ig.Emit(OpCodes.Stind_I8);
}
else if (type == TypeManager.char_type || type == TypeManager.short_type ||
type == TypeManager.ushort_type)
{
ig.Emit(OpCodes.Stind_I2);
}
else if (type == TypeManager.float_type)
{
ig.Emit(OpCodes.Stind_R4);
}
else if (type == TypeManager.double_type)
{
ig.Emit(OpCodes.Stind_R8);
}
else if (type == TypeManager.byte_type || type == TypeManager.sbyte_type ||
type == TypeManager.bool_type)
{
ig.Emit(OpCodes.Stind_I1);
}
else if (type == TypeManager.intptr_type)
{
ig.Emit(OpCodes.Stind_I);
}
else if (TypeManager.IsStruct(type) || TypeManager.IsGenericParameter(type))
{
Emit(OpCodes.Stobj, type);
}
else
{
ig.Emit(OpCodes.Stind_Ref);
}
}
static CompiledMethod CompileBlock(Class host, Undo undo, Report Report)
{
RootContext.ResolveTree();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
RootContext.PopulateTypes();
if (Report.Errors != 0)
{
undo.ExecuteUndo();
return(null);
}
TypeBuilder tb = null;
MethodBuilder mb = null;
if (host != null)
{
tb = host.TypeBuilder;
mb = null;
foreach (MemberCore member in host.Methods)
{
if (member.Name != "Host")
{
continue;
}
MethodOrOperator method = (MethodOrOperator)member;
mb = method.MethodBuilder;
break;
}
if (mb == null)
{
throw new Exception("Internal error: did not find the method builder for the generated method");
}
}
RootContext.EmitCode();
if (Report.Errors != 0)
{
return(null);
}
RootContext.CloseTypes();
if (Environment.GetEnvironmentVariable("SAVE") != null)
{
CodeGen.Save(current_debug_name, false, Report);
}
if (host == null)
{
return(null);
}
//
// Unlike Mono, .NET requires that the MethodInfo is fetched, it cant
// work from MethodBuilders. Retarded, I know.
//
Type tt = CodeGen.Assembly.Builder.GetType(tb.Name);
MethodInfo mi = tt.GetMethod(mb.Name);
// Pull the FieldInfos from the type, and keep track of them
foreach (Field field in queued_fields)
{
FieldInfo fi = tt.GetField(field.Name);
FieldInfo old = (FieldInfo)fields [field.Name];
// If a previous value was set, nullify it, so that we do
// not leak memory
if (old != null)
{
if (TypeManager.IsStruct(old.FieldType))
{
//
// TODO: Clear fields for structs
//
}
else
{
try {
old.SetValue(null, null);
} catch {
}
}
}
fields [field.Name] = fi;
}
//types.Add (tb);
queued_fields.Clear();
return((CompiledMethod)System.Delegate.CreateDelegate(typeof(CompiledMethod), mi));
}
//
// Load the object from the pointer.
//
public void EmitLoadFromPtr(TypeSpec t)
{
if (t == TypeManager.int32_type)
{
ig.Emit(OpCodes.Ldind_I4);
}
else if (t == TypeManager.uint32_type)
{
ig.Emit(OpCodes.Ldind_U4);
}
else if (t == TypeManager.short_type)
{
ig.Emit(OpCodes.Ldind_I2);
}
else if (t == TypeManager.ushort_type)
{
ig.Emit(OpCodes.Ldind_U2);
}
else if (t == TypeManager.char_type)
{
ig.Emit(OpCodes.Ldind_U2);
}
else if (t == TypeManager.byte_type)
{
ig.Emit(OpCodes.Ldind_U1);
}
else if (t == TypeManager.sbyte_type)
{
ig.Emit(OpCodes.Ldind_I1);
}
else if (t == TypeManager.uint64_type)
{
ig.Emit(OpCodes.Ldind_I8);
}
else if (t == TypeManager.int64_type)
{
ig.Emit(OpCodes.Ldind_I8);
}
else if (t == TypeManager.float_type)
{
ig.Emit(OpCodes.Ldind_R4);
}
else if (t == TypeManager.double_type)
{
ig.Emit(OpCodes.Ldind_R8);
}
else if (t == TypeManager.bool_type)
{
ig.Emit(OpCodes.Ldind_I1);
}
else if (t == TypeManager.intptr_type)
{
ig.Emit(OpCodes.Ldind_I);
}
else if (t.IsEnum)
{
if (t == TypeManager.enum_type)
{
ig.Emit(OpCodes.Ldind_Ref);
}
else
{
EmitLoadFromPtr(EnumSpec.GetUnderlyingType(t));
}
}
else if (TypeManager.IsStruct(t) || TypeManager.IsGenericParameter(t))
{
Emit(OpCodes.Ldobj, t);
}
else if (t.IsPointer)
{
ig.Emit(OpCodes.Ldind_I);
}
else
{
ig.Emit(OpCodes.Ldind_Ref);
}
}
//
// Emits the right opcode to store to an array
//
public void EmitArrayStore(ArrayContainer ac)
{
if (ac.Rank > 1)
{
if (IsAnonymousStoreyMutateRequired)
{
ac = (ArrayContainer)ac.Mutate(CurrentAnonymousMethod.Storey.Mutator);
}
ig.Emit(OpCodes.Call, ac.GetSetMethod());
return;
}
var type = ac.Element;
if (type.IsEnum)
{
type = EnumSpec.GetUnderlyingType(type);
}
if (type == TypeManager.byte_type || type == TypeManager.sbyte_type || type == TypeManager.bool_type)
{
Emit(OpCodes.Stelem_I1);
}
else if (type == TypeManager.short_type || type == TypeManager.ushort_type || type == TypeManager.char_type)
{
Emit(OpCodes.Stelem_I2);
}
else if (type == TypeManager.int32_type || type == TypeManager.uint32_type)
{
Emit(OpCodes.Stelem_I4);
}
else if (type == TypeManager.int64_type || type == TypeManager.uint64_type)
{
Emit(OpCodes.Stelem_I8);
}
else if (type == TypeManager.float_type)
{
Emit(OpCodes.Stelem_R4);
}
else if (type == TypeManager.double_type)
{
Emit(OpCodes.Stelem_R8);
}
else if (type == TypeManager.intptr_type)
{
Emit(OpCodes.Stobj, type);
}
else if (TypeManager.IsStruct(type))
{
Emit(OpCodes.Stobj, type);
}
else if (type.IsGenericParameter)
{
Emit(OpCodes.Stelem, type);
}
else if (type.IsPointer)
{
Emit(OpCodes.Stelem_I);
}
else
{
Emit(OpCodes.Stelem_Ref);
}
}
