public IILLocal DeclareLocal(Type type, string name = null, bool pinned = false)
{
var result = new ILLocal(type, name, pinned, _lastLocalIndex);
_lastLocalIndex++;
_instructions.Add(result);
return result;
}
protected override ILStatement GenerateWriteInternal(ILValue prop, ILValue liaison, ILValue buffer)
{
ILBlock block = new ILBlock();
if (IsPolymorphic())
{
ILLocal type = block.CreateCementedLocal(prop.GetILTypeEX());
block.AddStatement(
new ILIf(
liaison.GetILField(nested_liaison_field).GetILInvoke("ValidateEX", prop).GetILIsFalse(),
GenerateInitialize(liaison, type)
)
);
block.AddStatement(buffer.GetILInvoke("WriteType", type));
}
else
{
block.AddStatement(
new ILIf(
liaison.GetILField(nested_liaison_field).GetILIsNull(),
GenerateInitialize(liaison, GetPropType())
)
);
}
block.AddStatement(liaison.GetILField(nested_liaison_field).GetILInvoke("Write", prop, GetUpdateInterval(), buffer));
return(block);
}
static public IsFingerEquivolentOperation CreateIsFingerEquivolentOperation(this Type item)
{
MethodInfoEX equals_ex_method = typeof(TypeExtensions_Finger_Create).GetStaticMethod <object, object>("EqualsEX");
return(item.CreateDynamicMethodDelegate <IsFingerEquivolentOperation>("IsFingerEquivolent_" + item.Name, delegate(MethodBase method) {
ILBlock body = new ILBlock();
ILLocal obj1 = body.CreateNamedLocal(item, "obj1", method.GetTechnicalILParameter(0));
ILLocal obj2 = body.CreateNamedLocal(item, "obj2", method.GetTechnicalILParameter(1));
body.AddStatement(new ILIf(
obj1.GetILIsNotNull()& obj2.GetILIsNotNull(),
new ILBlock(delegate(ILBlock block) {
foreach (FieldInfo field in item.GetAllInstanceFields())
{
block.AddStatement(new ILIf(
equals_ex_method.GetStaticILMethodInvokation(
obj1.GetILField(field),
obj2.GetILField(field)
).GetILIsFalse(),
new ILReturn(false)
));
}
block.AddStatement(new ILReturn(true));
})
));
body.AddStatement(new ILReturn(false));
return body;
}));
}
/// <summary>
/// Constructs a new mapping handler.
/// </summary>
/// <param name="argumentLocal">The unsafe target argument array.</param>
/// <param name="argumentOffset">The target argument offset.</param>
public MappingHandler(
ILLocal argumentLocal,
int argumentOffset)
{
ArgumentLocal = argumentLocal;
ArgumentOffset = argumentOffset;
}
public IILLocal DeclareLocal(Type type, string name = null, bool pinned = false)
{
var result = new ILLocal(type, name, pinned, _lastLocalIndex);
_lastLocalIndex++;
_instructions.Add(result);
return(result);
}
/// <summary>
/// Constructs a new mapping handler.
/// </summary>
/// <param name="parent">The parent mapper.</param>
/// <param name="kernelLocal">The local variable holding the associated kernel reference.</param>
/// <param name="resultLocal">The local variable holding the result API status.</param>
public MappingHandler(
CLArgumentMapper parent,
ILLocal kernelLocal,
ILLocal resultLocal)
{
Parent = parent;
KernelLocal = kernelLocal;
ResultLocal = resultLocal;
}
public ILValue GenerateRead(ILValue buffer)
{
return(new ILLoadStatement(delegate(ILBlock block) {
ILLocal value = block.CreateCementedLocal(new ILNew(target_type));
block.AddStatement(GenerateReadInto(value, buffer));
return value;
}));
}
/// <summary>
/// Constructs a new mapping handler.
/// </summary>
/// <param name="parent">The parent mapper.</param>
/// <param name="kernelLocal">
/// The local variable holding the associated kernel reference.
/// </param>
/// <param name="resultLocal">
/// The local variable holding the result API status.
/// </param>
/// <param name="startIndex">The start argument index.</param>
public MappingHandler(
CLArgumentMapper parent,
ILLocal kernelLocal,
ILLocal resultLocal,
int startIndex)
{
Parent = parent;
KernelLocal = kernelLocal;
ResultLocal = resultLocal;
StartIndex = startIndex;
}
public ILLocal DefineLocal(TyonObject obj, ILValue value)
{
ILLocal local = block.CreateCementedLocal(value);
object_to_local.Add(obj, local);
if (obj.GetTyonAddress() != null)
{
internal_address_to_local.Add(obj.GetTyonAddress(), local);
}
return(local);
}
public Operation <object, TyonContext> CompileInstanceSystemObject(TyonObject tyon_object)
{
return(this.GetType().CreateDynamicMethodDelegate <Operation <object, TyonContext> >(delegate(ILValue c) {
block = new ILBlock();
context = c;
tyon_object.CompileInitialize(this);
ILLocal local = tyon_object.CompileLocal(this);
block.AddStatement(new ILReturn(local));
return block;
}));
}
public ILLocal CompileLocal(TyonCompiler compiler)
{
ILLocal local = compiler.ResolveObject(this);
if (local == null)
{
local = compiler.DefineLocal(
this,
GetTyonType().CompileInstanceSystemObject(compiler, GetTyonValueList().CompileValues(compiler))
);
}
CompilePushToSystemObject(local, compiler);
return(local);
}
static private ILStatement GenerateInspectedObjectWrite_Polymorphic(ILValue value, ILValue buffer)
{
ILBlock block = new ILBlock();
ILLocal type = block.CreateCementedLocal(value.GetILTypeEX());
block.AddStatement(buffer.GetILInvoke("WriteType", type));
block.AddStatement(
new ILIf(
type.GetILIsNotNull(),
typeof(TypeSerializer).GetILInvoke("WriteObject", value)
)
);
return(block);
}
public void CompileInitialize(TyonCompiler compiler)
{
ILLocal local = compiler.ResolveObject(this);
if (local == null && GetTyonValueList() == null)
{
local = compiler.DefineLocal(
this,
GetTyonType().CompileInstanceSystemObject(compiler)
);
}
GetTyonValueList().IfNotNull(l => l.CompileInitialization(compiler));
GetTyonVariables().Process(v => v.CompileInitialize(compiler));
}
public Process <object, TyonContext> CompilePushToSystemObject(TyonObject tyon_object)
{
Type type = tyon_object.GetTyonType().GetSystemType(this);
return(this.GetType().CreateDynamicMethodDelegate <Process <object, TyonContext> >(delegate(ILValue t, ILValue c) {
block = new ILBlock();
context = c;
ILLocal local = DefineLocal(tyon_object, t.GetILExplicitCast(type));
tyon_object.CompileInitialize(this);
tyon_object.CompilePushToSystemObject(local, this);
return block;
}));
}
public bool WriteWithLiaison(object target, Interval field_update_interval, object liaison, Buffer buffer)
{
if (object_liaison_writer == null)
{
object_liaison_writer = GetTargetType().CreateDynamicMethodDelegateWithForcedParameterTypes <ObjectLiaisonWriter>(delegate(ILValue il_target, ILValue il_field_update_interval, ILValue il_liaison, ILValue il_buffer) {
ILBlock block = new ILBlock();
ILLocal il_to_return = block.CreateNamedLocal(typeof(bool), "to_return");
block.AddStatements(
target_serializer_prop_groups
.Convert(g => g.GenerateWrite(il_target, il_field_update_interval, type_update_interval, il_liaison, il_to_return, il_buffer))
);
block.AddStatement(new ILReturn(il_to_return));
return(block);
}, GetTargetType(), typeof(Interval), GetLiaisonType(), typeof(Buffer));
}
return(object_liaison_writer(target, field_update_interval, liaison, buffer));
}
static public FingerPrintOperation CreateFingerPrintOperation(this Type item)
{
MethodInfoEX get_hash_code_ex_method = typeof(TypeExtensions_Finger_Create).GetStaticMethod <object>("GetHashCodeEX");
return(item.CreateDynamicMethodDelegate <FingerPrintOperation>("FingerPrint_" + item.Name, delegate(MethodBase method){
ILBlock body = new ILBlock();
ILLocal obj = body.CreateNamedLocal(item, "this", method.GetTechnicalILParameter(0));
ILLocal hash = body.CreateNamedLocal(typeof(int), "hash", 17);
foreach (FieldInfo field in item.GetAllInstanceFields())
{
body.AddStatement(
new ILAssign(
hash,
hash * 23 + get_hash_code_ex_method.GetStaticILMethodInvokation(obj.GetILField(field))
)
);
}
body.AddStatement(new ILReturn(hash));
return body;
}));
}
/// <summary>
/// Constructs a new local source.
/// </summary>
/// <param name="local">The current local.</param>
public LocalSource(ILLocal local)
{
Local = local;
}
/// <summary>
/// Constructs a new local target.
/// </summary>
/// <param name="local">The current local.</param>
public LocalTarget(ILLocal local)
{
Local = local;
}
public void CompilePushToSystemObject(ILLocal obj, TyonCompiler compiler)
{
GetTyonVariables().Process(v => v.CompilePushToSystemObject(obj, compiler));
}