private void EmitPrivateFieldAssignment(LocalBuilder localbuilder) {
var fieldInfo = Member as FieldInfo;
var methodAttributes = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
var methodBuilder = DynamicTypeBuilder.Current.DefineMethod("EmitPrivateFieldAssignment", methodAttributes);
var methodBuilderILGenerator = methodBuilder.GetILGenerator();
Type = fieldInfo.FieldType;
methodBuilder.SetReturnType(Type);
_assignorExpression.AcceptVisitor(Visitor, methodBuilderILGenerator);
methodBuilderILGenerator.DeclareLocal(Type);
methodBuilderILGenerator.Emit(OpCodes.Stloc_1);
methodBuilderILGenerator.Emit(OpCodes.Ldtoken, Target);
methodBuilderILGenerator.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
methodBuilderILGenerator.Emit(OpCodes.Ldstr, Member.Name);
methodBuilderILGenerator.EmitPushInteger(Convert.ToInt32(BindingFlags.NonPublic | BindingFlags.Static));
methodBuilderILGenerator.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("GetField", new Type[] { TypeSystem.String, typeof(BindingFlags) }));
methodBuilderILGenerator.Emit(OpCodes.Ldnull);
methodBuilderILGenerator.Emit(OpCodes.Ldloc_1);
methodBuilderILGenerator.Emit(OpCodes.Callvirt, typeof(FieldInfo).GetMethod("SetValue", new Type[] { TypeSystem.Object, TypeSystem.Object }));
methodBuilderILGenerator.Emit(OpCodes.Ldloc_1);
methodBuilderILGenerator.Emit(OpCodes.Ret);
ILGenerator.Emit(OpCodes.Call, methodBuilder);
}
public LocalVariableCollection(ILGenerator il, bool decode)
{
this.il = il;
variables = new Dictionary<string, LocalBuilder>();
dataPointer = il.DeclareLocal(typeof(byte*));
remainingBytes = decode ? il.DeclareLocal(typeof(int)) : null;
}
protected override void EmitDecodeAndStore(IEmittingContext context, LocalBuilder collectionVar, Action emitLoadIndex, bool doNotCheckBounds)
{
var il = context.IL;
il.Ldloc(collectionVar);
ElementCodec.EmitDecode(context, doNotCheckBounds);
il.Callvirt(addMethod);
}
private void DeclareParameterLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals)
{
for (int i = 0; i < parameterLocals.Length; i++)
{
parameterLocals[i] = this.ilg.DeclareLocal(TypeLoader.GetParameterType(parameters[i]), "param" + i.ToString(CultureInfo.InvariantCulture));
}
}
private void Store(string name, System.Type type)
{
if (this.symbolTable.ContainsKey(name))
{
Emit.LocalBuilder locb = this.symbolTable[name];
if (locb.LocalType == type)
{
this.il.Emit(Emit.OpCodes.Stloc, this.symbolTable[name]);
}
else
{
throw new System.Exception("'" + name + "' is of type " + locb.LocalType.Name + " but attempted to store value of type " + type.Name);
}
}
else if (this.typefieldList.ContainsKey(name))
{
if (this.typefieldList[name].IsStatic)
{
this.il.Emit(Emit.OpCodes.Stsfld, this.typefieldList[name]);
}
else
{
this.il.Emit(Emit.OpCodes.Stfld, this.typefieldList[name]);
}
}
else
{
throw new System.Exception("undeclared variable '" + name + "'");
}
}
public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Ldloc(memberValue);
// Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
//���ֵΪ�գ����ܵ���ToString
generator.Load(null);
generator.If(Cmp.NotEqualTo);
generator.Ldloc(memberValue);
// Type originalType = memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType;
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.Call(typeof(object).GetMethod("ToString", Type.EmptyTypes));
generator.Else();
generator.LoadDefaultValue(memberValue.LocalType);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.EndIf();
generator.Call(typeof(NameValueCollection).GetMethod("Add", new Type[] { typeof(string), typeof(string) }));
}
private static void EmitStoreLocalShortTerm(this ILGenerator ILGenerator, LocalBuilder localBuilder) {
switch (localBuilder.LocalIndex) {
case 0:
ILGenerator.Emit(OpCodes.Stloc_0);
break;
case 1:
ILGenerator.Emit(OpCodes.Stloc_1);
break;
case 2:
ILGenerator.Emit(OpCodes.Stloc_2);
break;
case 3:
ILGenerator.Emit(OpCodes.Stloc_3);
break;
default:
ILGenerator.Emit(OpCodes.Stloc_S, localBuilder);
break;
}
}
internal ForState(LocalBuilder indexVar, Label beginLabel, Label testLabel, object end)
{
this.indexVar = indexVar;
this.beginLabel = beginLabel;
this.testLabel = testLabel;
this.end = end;
}
private void WriteToMemoryCell(LocalBuilder variable)
{
codeGenerator.Emit(OpCodes.Ldloc, Memory);
codeGenerator.Emit(OpCodes.Ldloc, MemoryPointer);
codeGenerator.Emit(OpCodes.Ldloc, variable);
codeGenerator.Emit(OpCodes.Stelem_I1);
}
private System.Type TypeOfExpr(Expr expr)
{
if (expr is StringLiteral)
{
return(typeof(string));
}
else if (expr is IntLiteral)
{
return(typeof(int));
}
else if (expr is Variable)
{
Variable var = (Variable)expr;
if (this.symbolTable.ContainsKey(var.Ident))
{
Emit.LocalBuilder locb = this.symbolTable[var.Ident];
return(locb.LocalType);
}
else
{
throw new System.Exception("undeclared variable '" + var.Ident + "'");
}
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.GetType().Name);
}
}
protected override LocalBuilder CallMockedMethod(LocalBuilder generics, LocalBuilder args, LocalBuilder methodOut)
{
var ifResult = Body.DeclareLocal(typeof(bool));
var indexParams = Body.DeclareLocal(typeof(IEnumerable<MethodArg>));
var last = Body.DeclareLocal(typeof(int));
//last = args.Length - 1;
Body.Emit(OpCodes.Ldloc, args);
Body.Emit(OpCodes.Call, MethodArg_Length);
Body.Emit(OpCodes.Ldc_I4_1);
Body.Emit(OpCodes.Sub);
Body.Emit(OpCodes.Stloc, last);
//indexParams = Enumerable.Take(args, last);
Body.Emit(OpCodes.Ldloc, args);
Body.Emit(OpCodes.Ldloc, last);
Body.Emit(OpCodes.Call, Take);
Body.Emit(OpCodes.Stloc, indexParams);
// this.ObjectBase.SetIndex(indexParams, args[last].Arg);
Body.Emit(OpCodes.Ldarg_0);
Body.Emit(OpCodes.Ldfld, ObjBase);
Body.Emit(OpCodes.Ldloc, indexParams);
Body.Emit(OpCodes.Ldloc, args);
Body.Emit(OpCodes.Ldloc, last);
Body.Emit(OpCodes.Ldelem_Ref);
Body.Emit(OpCodes.Ldfld, MethodArg_Arg);
Body.Emit(OpCodes.Call, ObjectBase.Reflection.SetIndex);
// ifResult = true
Body.Emit(OpCodes.Ldc_I4_1);
Body.Emit(OpCodes.Stloc, ifResult);
return ifResult;
}
internal AspectArgsMethodWeaver(MethodInfo method, LocalBuilder methodLocalBuilder, Type[] parameters, IAspectWeavingSettings aspectWeavingSettings)
{
this.method = method;
this.parameters = parameters;
this.methodLocalBuilder = methodLocalBuilder;
this.aspectWeavingSettings = aspectWeavingSettings;
}
public static void Emit_DecreaseInteger(this ILGenerator il, LocalBuilder remainingBytesVal, LocalBuilder distanceVar)
{
il.Emit(OpCodes.Ldloc, remainingBytesVal);
il.Emit(OpCodes.Ldloc, distanceVar);
il.Emit(OpCodes.Sub);
il.Emit(OpCodes.Stloc, remainingBytesVal);
}
public static LocalBuilder GetPropertyValue(this ILGenerator il, PropertyInfo property, LocalBuilder target)
{
var x = il.DeclareLocal(property.PropertyType);
il.LoadPropertyValue(property, target);
il.SetLocal(x);
return x;
}
protected void UnlockRegister(LocalBuilder reg)
{
if (registers.ContainsKey (reg.LocalType))
return;
registers.Add (reg.LocalType, reg);
}
private void CreateObject(ClassDataContract classContract)
{
Type typeOfValueType = this.objectType = classContract.UnderlyingType;
if (typeOfValueType.IsValueType && !classContract.IsNonAttributedType)
{
typeOfValueType = Globals.TypeOfValueType;
}
this.objectLocal = this.ilg.DeclareLocal(typeOfValueType, "objectDeserialized");
if (classContract.UnderlyingType == Globals.TypeOfDBNull)
{
this.ilg.LoadMember(Globals.TypeOfDBNull.GetField("Value"));
this.ilg.Stloc(this.objectLocal);
}
else if (classContract.IsNonAttributedType)
{
if (typeOfValueType.IsValueType)
{
this.ilg.Ldloca(this.objectLocal);
this.ilg.InitObj(typeOfValueType);
}
else
{
this.ilg.New(classContract.GetNonAttributedTypeConstructor());
this.ilg.Stloc(this.objectLocal);
}
}
else
{
this.ilg.Call(null, XmlFormatGeneratorStatics.GetUninitializedObjectMethod, DataContract.GetIdForInitialization(classContract));
this.ilg.ConvertValue(Globals.TypeOfObject, typeOfValueType);
this.ilg.Stloc(this.objectLocal);
}
}
public override void OutputSet(NitroIL into,Type setting){
if(VariableType==null){
VariableType=setting;
}else if(setting!=VariableType){
// Overwriting the variable with something of a different type. Create a new one.
VariableType=setting;
Builder=null;
}
if(VariableType==null){
VariableType=typeof(object);
}
if(Builder==null){
Builder=into.DeclareLocal(VariableType);
}
into.Emit(OpCodes.Stloc,Builder);
}
private System.Type TypeOfExpr(Expr expr)
{
if (expr is StringLiteral)
{
return(typeof(string));
}
else if (expr is IntLiteral)
{
return(typeof(int));
}
else if (expr is Variable)
{
Variable var = (Variable)expr;
if (this.symbolTable.ContainsKey(var.Ident))
{
Emit.LocalBuilder locb = this.symbolTable[var.Ident];
return(locb.LocalType);
}
else
{
throw new System.Exception("variable no declarada '" + var.Ident + "'");
}
}
//*********************
else if (expr is BinExpr)
{
return(typeof(int));
}
//*********************
else
{
throw new System.Exception("no se puede calcular el tipo: " + expr.GetType().Name);
}
}
public static void DefineLocalVariable (string name, LocalBuilder builder)
{
if (symwriter != null) {
int index = MonoDebuggerSupport.GetLocalIndex (builder);
symwriter.DefineLocalVariable (index, name);
}
}
/// <summary>
/// Emits 'for' statement on current IL stream.
/// </summary>
/// <param name="il">IL generator to be emitted to.</param>
/// <param name="count">'count' local variable which is <see cref="Int32"/> type and holds maximum loop count.</param>
/// <param name="bodyEmitter">Delegate to emit for statement body.</param>
public static void EmitFor( TracingILGenerator il, LocalBuilder count, Action<TracingILGenerator, LocalBuilder> bodyEmitter )
{
Contract.Requires( il != null );
Contract.Requires( count != null );
Contract.Requires( bodyEmitter != null );
var i = il.DeclareLocal( typeof( int ), "i" );
il.EmitLdc_I4_0();
il.EmitAnyStloc( i );
var forCond = il.DefineLabel( "FOR_COND" );
il.EmitBr( forCond );
var body = il.DefineLabel( "BODY" );
il.MarkLabel( body );
bodyEmitter( il, i );
// increment
il.EmitAnyLdloc( i );
il.EmitLdc_I4_1();
il.EmitAdd();
il.EmitAnyStloc( i );
// cond
il.MarkLabel( forCond );
il.EmitAnyLdloc( i );
il.EmitAnyLdloc( count );
il.EmitBlt( body );
}
void ICanModifyContext.EmitDecls(EmitContext ec)
{
object var;
if ((var = CodeGenerator.variable_defined_in_current_scope (id)) != null) {
Type t = var.GetType ();
if (t == typeof (FieldBuilder))
field_info = (FieldBuilder) var;
else if (t == typeof (LocalBuilder))
local_builder = (LocalBuilder) var;
return;
}
ILGenerator ig = ec.ig;
if (parent == null || (parent.GetType () != typeof (FunctionDeclaration)
&& parent.GetType () != typeof (FunctionExpression))) {
FieldBuilder field_builder;
TypeBuilder type_builder = ec.type_builder;
field_builder = type_builder.DefineField (id, this.type, FieldAttributes.Public | FieldAttributes.Static);
TypeManager.Add (id, field_builder);
field_info = field_builder;
} else {
local_builder = ig.DeclareLocal (type);
TypeManager.Add (id, local_builder);
}
}
/// Generates the code that adds an object from a local variable to a dictionary also stored in a local
/// <param name="ilGenerator"></param>
/// <param name="dictionary"></param>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public static void AddLocalToLocalDictionary(this ILGenerator ilGenerator, LocalBuilder dictionary, object key, LocalBuilder value)
{
ilGenerator.Emit(OpCodes.Ldloc, dictionary);
ilGenerator.LoadValue(key);
ilGenerator.Emit(OpCodes.Ldloc, value);
ilGenerator.Emit(OpCodes.Callvirt, DictionaryAdd);
}
public static void FillEntity(ILGenerator generator, Type entityType, LocalBuilder entity)
{
//Dictionary<string, int> fields = DataPortal.FindFields(data);
LocalBuilder fields = generator.DeclareLocal(typeof(Dictionary<string, int>));
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, typeof(DataPortal).GetMethod("FindFields", new Type[]{typeof(IDataRecord)}));
generator.Emit(OpCodes.Stloc, fields);
foreach(PropertyInfo property in entityType.GetProperties())
{
DbFieldAttribute fieldInfo = ReflectionHelper.GetAttribute<DbFieldAttribute>(property);
if(fieldInfo == null)
{
continue;
}
//int fieldIndex = DataPortal.FindField(fields, propInfo.Name);
LocalBuilder fieldIndex = generator.DeclareLocal(typeof(Int32));
generator.Emit(OpCodes.Ldloc, fields);
generator.Emit(OpCodes.Ldstr, fieldInfo.FieldName);
generator.Emit(OpCodes.Call, typeof(DataPortal).GetMethod("FindField", new Type[] { typeof(Dictionary<string, int>), typeof(string) }));
generator.Emit(OpCodes.Stloc, fieldIndex);
//if(fieldIndex >= 0)
Label notFieldExists = generator.DefineLabel();
generator.Emit(OpCodes.Ldloc, fieldIndex);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Clt);
generator.Emit(OpCodes.Brtrue_S, notFieldExists);
{
FillProperty(generator, entityType, entity, property, fieldIndex);
generator.Emit(OpCodes.Nop);
}
generator.MarkLabel(notFieldExists);
}
}
private System.Type TypeOfExpr(expr expr)
{
if (expr is StringLiteral)
{
return(typeof(string)); //setting the type of expr to type string
}
else if (expr is IntLiteral)
{
return(typeof(int)); //type to int
}
else if (expr is Variable)
{
Variable var = (Variable)expr;
if (this.symbolTable.ContainsKey(var.Ident))
{
Emit.LocalBuilder locb = symbolTable[var.Ident]; //loacal variable assigned the value of symbol table at key var.Ident
return(locb.LocalType);
}
else
{
throw new System.Exception("undeclared variable '" + var.Ident + "'");
}
}
else if (expr is BinExpr)
{
BinExpr var = (BinExpr)expr;
return(typeof(int));
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.GetType().Name);
}
}
public ILForLoop(Label conditionLabel, Label startLoopLogicLabel, LocalBuilder counter, LocalBuilder max)
{
ConditionLabel = conditionLabel;
Counter = counter;
Max = max;
StartLoopLogicLabel = startLoopLogicLabel;
}
public MethodCallExpression(LocalBuilder instance, string methodName, params object[] args)
: base(args)
{
_instance = new Variable(instance);
_methodName = methodName;
LookupMethod(instance.LocalType, methodName);
}
internal override void Emit (EmitContext ec, LocalBuilder local)
{
var member = EmitLoadMember (ec, local);
foreach (var initializer in initializers)
initializer.Emit (ec, member);
}
/// <summary>
/// Initializes the CodeGenerator infrastructure, binds the ILGenerator,
/// creates temporaries; resets evaluation condition caches.
/// Ready to compile a new SDF.
/// </summary>
/// <param name="ilg">The ILGenerator used by all compile methods</param>
public static void Initialize(ILGenerator ilg) {
CodeGenerate.ilg = ilg;
numberVariables = new Dictionary<FullCellAddr, Variable>();
testDouble = ilg.DeclareLocal(typeof (double));
testValue = ilg.DeclareLocal(Value.type);
tmpFullCellAddr = ilg.DeclareLocal(FullCellAddr.type);
}
public static void Emit_IncreasePointer(this ILGenerator il, LocalBuilder dataPointerVar, LocalBuilder distanceVar)
{
il.Emit(OpCodes.Ldloc, dataPointerVar);
il.Emit(OpCodes.Ldloc, distanceVar);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc, dataPointerVar);
}
public InitializeInvokerArgumentArrayStatement(
LocalBuilder argumentArrayLocal,
ParameterInfo[] parameters)
{
_argumentArrayLocal = argumentArrayLocal;
_parameters = parameters;
}
private ReturnFixer(LocalBuilder refSlot, int argIndex, Type argType)
{
Debug.Assert(refSlot.LocalType.IsGenericType() && refSlot.LocalType.GetGenericTypeDefinition() == typeof(StrongBox<>));
_refSlot = refSlot;
_argIndex = argIndex;
_argType = argType;
}
private void CodeCall(FuncCallExpression call, List<LocalVariable> locals, List<GlobalVariable> globals, FuncParam[] parameters, ILGenerator il, List<Function> allFuncs, LocalBuilder tmpVar)
{
var func = FindFunc(call, allFuncs);
foreach (var expression in call.Params)
CodeExpression(expression, locals, globals, parameters, il, allFuncs, tmpVar);
il.Emit(OpCodes.Call, func.Info);
}
internal override void Emit (EmitContext ec, LocalBuilder local)
{
var member = EmitLoadMember (ec, local);
foreach (var binding in bindings)
binding.Emit (ec, member);
}
public StoreOutArgumentsStatement(
LocalBuilder argumentArrayLocal,
ParameterInfo[] parameters)
{
_argumentArrayLocal = argumentArrayLocal;
_parameters = parameters;
}
public void storeVariable(Symbol s, bool isref, uint scope, string proc_actual)
{
Symbol aux;
int tipo = 0;
if (scope == 0)
{
aux = symtab.getSymbol(s.Name);
}
else
{
aux = symtab.getSymbol(proc_actual, s.Name, ref tipo);
}
if (aux != null)
{
/*
* Porque puede ser que estemos usando
* una variable global dentro de un metodo
* hay que comprobar tb el tipo
*/
if (scope == 0 || tipo == 0)
{
this.il.Emit(Emit.OpCodes.Stsfld, (Emit.FieldBuilder)fbuilderTable[aux.Name]);
}
//tipo = 1 parametro
else if (tipo == 1)
{
Param f = (Param)aux;
if (f.Reference)
{
this.genStInd(f);
}
else
{
this.il.Emit(Emit.OpCodes.Starg_S, (short)f.Offset);
}
}
else
{
Hashtable h = (Hashtable)lbuilderTable[proc_actual];
Emit.LocalBuilder l = (Emit.LocalBuilder)h[s.Name];
if (l == null)
{
return;
}
if (isref)
{
this.genStInd(s);
}
else
{
this.il.Emit(Emit.OpCodes.Stloc, l);
}
}
}
}
private void ValidateSymbolType(String pName, Type pExpectedType)
{
Emit.LocalBuilder localBuilder = GetValueFromSymbolTable(pName, -1);
if (localBuilder.LocalType != pExpectedType)
{
String ErrMSg = "Variable {0} is of type {1}, but type {2} cannot be stored in it";
throw new Exception(String.Format(ErrMSg, pName, localBuilder.LocalType.Name, pExpectedType.Name));
}
}
private void ADD_EMIT()
{
//this.il.Emit(Emit.OpCodes.Ldc_I4, ((IntLiteral)whole[0]).Value);
//this.il.Emit(Emit.OpCodes.Ldc_I4, ((IntLiteral)whole[2]).Value);
//this.il.Emit(Emit.OpCodes.Add);
if (whole[0] is IntLiteral)
{
this.il.Emit(Emit.OpCodes.Ldc_I4, ((IntLiteral)whole[0]).Value);//pushes the value of passed expression on integer type stack
}
else
{
string ident = ((Variable)whole[0]).Ident;
Emit.LocalBuilder locb = this.symbolTable[ident];
this.il.Emit(Emit.OpCodes.Ldloc, locb);
}
for (int len = 2; len < whole.Count; len = len + 2)
{
if (whole[len] is IntLiteral)
{
this.il.Emit(Emit.OpCodes.Ldc_I4, ((IntLiteral)whole[len]).Value); //pushes the value of passed expression on integer type stack
}
else
{
string ident = ((Variable)whole[len]).Ident;
Emit.LocalBuilder locb = this.symbolTable[ident];
this.il.Emit(Emit.OpCodes.Ldloc, locb);
}
if ((whole[len - 1]).Equals(BinOp.add))
{
this.il.Emit(Emit.OpCodes.Add);
}
else if ((whole[len - 1]).Equals(BinOp.minus))
{
this.il.Emit(Emit.OpCodes.Sub);
}
else if ((whole[len - 1]).Equals(BinOp.multiply))
{
this.il.Emit(Emit.OpCodes.Mul);
}
else if ((whole[len - 1]).Equals(BinOp.divide))
{
this.il.Emit(Emit.OpCodes.Div);
}
}
}
//Almacena el valor del tope de la pila en el nombre de variable proporcionado (no maneja ambito)
public static void Almacenar(string nombre, Emit.ILGenerator _il)
{
if (!TablaDireccionesSimbolos.ContainsKey(nombre))
{
TablaDireccionesSimbolos[nombre] = _il.DeclareLocal(typeof(System.Int32)); //Solo variables enteras
}
Emit.LocalBuilder variableLocal = TablaDireccionesSimbolos[nombre];
if (!variableLocal.LocalType.HasElementType) //(es una variable simple) verdadero solo en caso de vectores o matrices
{
_il.Emit(Emit.OpCodes.Stloc, TablaDireccionesSimbolos[nombre]);
}
else //es una matriz o vector y actuo acorde
{
throw new System.Exception("No se soportan arrays o matrices en las asignaciones");
}
}
public Emit.LocalBuilder GetValueFromSymbolTable(String pIdentifier, Int32 pIndex)
{
if (!_symbolTable.ContainsKey(pIdentifier))
{
throw new Exception("Undeclared variable '" + pIdentifier + "'");
}
if (pIndex != -1)
{
//Array with Index pIndex
Emit.LocalBuilder local = _symbolTable[pIdentifier];
return(_symbolTable[pIdentifier]);
}
else
{
return(_symbolTable[pIdentifier]);
}
}
private System.Type TypeOfExpr(Expr expr)
{
if (expr is StringLiteral)
{
return(typeof(string));
}
else if (expr is IntLiteral)
{
return(typeof(int));
}
else if (expr is BinExpr)
{
return(TypeOfExpr(((BinExpr)expr).Right));
}
else if (expr is Variable)
{
Variable var = (Variable)expr;
if (this.symbolTable.ContainsKey(var.Ident))
{
Emit.LocalBuilder locb = this.symbolTable[var.Ident];
return(locb.LocalType);
}
else
{
throw new System.Exception("undeclared variable '" + var.Ident + "'");
}
}
else if (expr is MethodCall)
{
MethodCall callMethod = (MethodCall)expr;
if (callMethod.returnType == null && !callMethod.IsConstrutor)
{
callMethod.returnType = GetMethodInfo(callMethod).ReturnParameter.ParameterType;
}
return(callMethod.returnType);
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.GetType().Name);
}
}
private void Store(string name, System.Type type)
{
if (this.symbolTable.ContainsKey(name))
{
Emit.LocalBuilder locb = this.symbolTable[name];
if (locb.LocalType == type)
{
this.il.Emit(Emit.OpCodes.Stloc, this.symbolTable[name]);
}
else
{
throw new System.Exception("'" + name + "' es del tipo " + locb.LocalType.Name + " pero se intenta almacenar el tipo " + type.Name);
}
}
else
{
throw new System.Exception("variable no declarada '" + name + "'");
}
}
private void Store(string Id)
{
int Position;
if ((Position = checkStackParams(Id)) >= 0)
{
AssemblerGenerator.Emit(Emit.OpCodes.Starg, Position + 1);
}
else
{
Emit.LocalBuilder LocVar = VariableBuilder(Id);
if (LocVar == null)
{
throw new System.Exception("Использование необъявленной переменной.");
}
else
{
AssemblerGenerator.Emit(Emit.OpCodes.Stloc, LocVar);
}
}
}
private void Load(string Id)
{
int Position = checkStackParams(Id);
if (Position >= 0)
{
AssemblerGenerator.Emit(Emit.OpCodes.Ldarg, Position + 1);
}
else
{
Emit.LocalBuilder LocVar = VariableBuilder(Id);
if (LocVar == null)
{
throw new System.Exception("Использование необъявленной переменной.");
}
else
{
CurrentTopStackType = LocVar.LocalType;
AssemblerGenerator.Emit(Emit.OpCodes.Ldloc, LocVar);
}
}
}
public static int GetLocalIndex(SRE.LocalBuilder local)
{
return(get_local_index(local));
}
public void genMethod(Symbol s)
{
System.Type[] parameters;
System.Type returnType = null;
Procedure p = null;
//Debemos poner el ret correcto
if (this.il != null)
{
this.il.Emit(Emit.OpCodes.Ret);
}
if (s is Procedure)
{
p = (Procedure)s;
}
if (s is Function)
{
Function f = (Function)s;
returnType = getSystemTypeFormat(f.TypeReturn);
p = (Procedure)f;
}
parameters = new System.Type[p.Parameters.Count];
int i = 0;
int cont = p.Parameters.Count;
object[] keys = new object[cont];
p.Parameters.Keys.CopyTo(keys, 0);
Array.Reverse(keys);
for (i = 0; i < cont; i++)
{
Param param = (Param)p.Parameters[keys[i]];
parameters[i] = getSystemTypeFormat(param.Type);
if (param.Reference)
{
parameters[i] = parameters[i].MakeByRefType();
}
}
this.methb = typeBuilder.DefineMethod(s.Name,
Reflect.MethodAttributes.Public | Reflect.MethodAttributes.Static,
returnType,
parameters);
mbuilderTable.Add(s.Name, methb);
this.il = methb.GetILGenerator();
//Local variables
if (p.Locales.Count > 0)
{
Hashtable h = new Hashtable();
foreach (Symbol local in p.Locales.Values)
{
Emit.LocalBuilder lbuilder = this.il.DeclareLocal(getSystemTypeFormat(local.Type));
h.Add(local.Name, lbuilder);
}
lbuilderTable.Add(s.Name, h);
}
}
public void loadVariable(Symbol s, bool isref, uint scope, string proc_actual)
{
Symbol aux;
int tipo = 0;
if (scope == 0)
{
aux = symtab.getSymbol(s.Name);
}
else
{
aux = symtab.getSymbol(proc_actual, s.Name, ref tipo);
}
/*
* Si la cadena coincide con el nombre del procedimiento
* o de otra variable, debemos tratarlo como un literal
*
* Las constantes las tratamos como literales, ya que en mono
* no esta implementado el metodo getRawConstantValue para obtener
* el valor. Dado que en compilacion no dejamos asignar valores,
* no se notara a no ser que se mire el codigo generado.
*/
if (aux != null && !s.Literal && !(aux is Constant))
{
if (scope == 0)
{
if (isref)
{
this.il.Emit(Emit.OpCodes.Ldsflda, (Emit.FieldBuilder)fbuilderTable[aux.Name]);
}
else
{
this.il.Emit(Emit.OpCodes.Ldsfld, (Emit.FieldBuilder)fbuilderTable[aux.Name]);
}
}
//tipo = 1 parametro
else if (tipo == 1)
{
Param f = (Param)aux;
this.genLdArg(f.Offset);
if (isref)
{
this.genLdInd(f);
}
}
else
{
Hashtable h = (Hashtable)lbuilderTable[proc_actual];
if (h == null)
{
return;
}
Emit.LocalBuilder l = (Emit.LocalBuilder)h[s.Name];
if (l == null)
{
return;
}
if (isref)
{
this.il.Emit(Emit.OpCodes.Ldloca, l);
}
else
{
this.il.Emit(Emit.OpCodes.Ldloc, l);
}
}
}
else
{
switch (s.Type.toString())
{
case "INT":
if (aux != null && aux is Constant)
{
Constant cnt = (Constant)aux;
this.il.Emit(Emit.OpCodes.Ldc_I4, Int32.Parse(cnt.Value));
}
else
{
this.il.Emit(Emit.OpCodes.Ldc_I4, Int32.Parse(s.Name));
}
break;
case "CHAR":
if (aux != null && aux is Constant)
{
Constant cnt = (Constant)aux;
this.il.Emit(Emit.OpCodes.Ldc_I4, Char.Parse(cnt.Value));
}
else
{
this.il.Emit(Emit.OpCodes.Ldc_I4, Char.Parse(s.Name));
}
break;
case "STRING":
if (aux != null && aux is Constant)
{
Constant cnt = (Constant)aux;
this.il.Emit(Emit.OpCodes.Ldstr, cnt.Value);
}
else
{
this.il.Emit(Emit.OpCodes.Ldstr, s.Name);
}
break;
case "REAL":
if (aux != null && aux is Constant)
{
Constant cnt = (Constant)aux;
string str = cnt.Value.Replace('.', ',');
this.il.Emit(Emit.OpCodes.Ldc_R8, Double.Parse(str));
}
else
{
string str = s.Name.Replace('.', ',');
this.il.Emit(Emit.OpCodes.Ldc_R8, Double.Parse(str));
}
break;
case "BOOLEAN":
if (aux != null && aux is Constant)
{
Constant cnt = (Constant)aux;
if (cnt.Value == "true")
{
this.il.Emit(Emit.OpCodes.Ldc_I4, 1);
}
else
{
this.il.Emit(Emit.OpCodes.Ldc_I4, 0);
}
}
else
{
if (s.Name == "true")
{
this.il.Emit(Emit.OpCodes.Ldc_I4, 1);
}
else
{
this.il.Emit(Emit.OpCodes.Ldc_I4, 0);
}
}
break;
}
}
}
public virtual void Emit(OpCode opcode, LocalBuilder local)
{
if (local == null)
{
throw new ArgumentNullException(nameof(local));
}
if (local.ilgen != this)
{
throw new ArgumentException(SR.Argument_UnmatchedMethodForLocal, nameof(local));
}
uint pos = local.position;
if ((opcode == OpCodes.Ldloca_S || opcode == OpCodes.Ldloc_S || opcode == OpCodes.Stloc_S) && pos > 255)
{
throw new InvalidOperationException(SR.InvalidOperation_BadInstructionOrIndexOutOfBound);
}
bool load_addr = false;
bool is_store = false;
bool is_load = false;
make_room(6);
/* inline the code from ll_emit () to optimize il code size */
if (opcode.StackBehaviourPop == StackBehaviour.Pop1)
{
cur_stack--;
is_store = true;
}
else if (opcode.StackBehaviourPush == StackBehaviour.Push1 || opcode.StackBehaviourPush == StackBehaviour.Pushi)
{
cur_stack++;
is_load = true;
if (cur_stack > max_stack)
{
max_stack = cur_stack;
}
load_addr = opcode.StackBehaviourPush == StackBehaviour.Pushi;
}
if (load_addr)
{
if (pos < 256)
{
code[code_len++] = (byte)0x12;
code[code_len++] = (byte)pos;
}
else
{
code[code_len++] = (byte)0xfe;
code[code_len++] = (byte)0x0d;
code[code_len++] = (byte)(pos & 0xff);
code[code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else
{
if (is_store)
{
if (pos < 4)
{
code[code_len++] = (byte)(0x0a + pos);
}
else if (pos < 256)
{
code[code_len++] = (byte)0x13;
code[code_len++] = (byte)pos;
}
else
{
code[code_len++] = (byte)0xfe;
code[code_len++] = (byte)0x0e;
code[code_len++] = (byte)(pos & 0xff);
code[code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else if (is_load)
{
if (pos < 4)
{
code[code_len++] = (byte)(0x06 + pos);
}
else if (pos < 256)
{
code[code_len++] = (byte)0x11;
code[code_len++] = (byte)pos;
}
else
{
code[code_len++] = (byte)0xfe;
code[code_len++] = (byte)0x0c;
code[code_len++] = (byte)(pos & 0xff);
code[code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else
{
ll_emit(opcode);
}
}
}
public virtual void Emit(OpCode opcode, LocalBuilder local)
{
if (local == null)
{
throw new ArgumentNullException("local");
}
if (local.ilgen != this)
{
throw new ArgumentException("Trying to emit a local from a different ILGenerator.");
}
uint pos = local.position;
bool load_addr = false;
bool is_store = false;
bool is_load = false;
make_room(6);
/* inline the code from ll_emit () to optimize il code size */
if (opcode.StackBehaviourPop == StackBehaviour.Pop1)
{
cur_stack--;
is_store = true;
}
else if (opcode.StackBehaviourPush == StackBehaviour.Push1 || opcode.StackBehaviourPush == StackBehaviour.Pushi)
{
cur_stack++;
is_load = true;
if (cur_stack > max_stack)
{
max_stack = cur_stack;
}
load_addr = opcode.StackBehaviourPush == StackBehaviour.Pushi;
}
if (load_addr)
{
if (pos < 256)
{
code [code_len++] = (byte)0x12;
code [code_len++] = (byte)pos;
}
else
{
code [code_len++] = (byte)0xfe;
code [code_len++] = (byte)0x0d;
code [code_len++] = (byte)(pos & 0xff);
code [code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else
{
if (is_store)
{
if (pos < 4)
{
code [code_len++] = (byte)(0x0a + pos);
}
else if (pos < 256)
{
code [code_len++] = (byte)0x13;
code [code_len++] = (byte)pos;
}
else
{
code [code_len++] = (byte)0xfe;
code [code_len++] = (byte)0x0e;
code [code_len++] = (byte)(pos & 0xff);
code [code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else if (is_load)
{
if (pos < 4)
{
code [code_len++] = (byte)(0x06 + pos);
}
else if (pos < 256)
{
code [code_len++] = (byte)0x11;
code [code_len++] = (byte)pos;
}
else
{
code [code_len++] = (byte)0xfe;
code [code_len++] = (byte)0x0c;
code [code_len++] = (byte)(pos & 0xff);
code [code_len++] = (byte)((pos >> 8) & 0xff);
}
}
else
{
ll_emit(opcode);
}
}
}
/// <summary>
/// Pops the current value from the top of the evaluation stack and stores it
/// in a the local variable list at a specified index.
/// </summary>
/// <param name="il">The instance of <see cref="ILGenerator"/>.</param>
/// <param name="localBuilder">The instance of <see cref="LocalBuilder"/>.</param>
/// <returns>The instance of <see cref="ILGenerator"/>.</returns>
public static System.Reflection.Emit.ILGenerator Stloc(this System.Reflection.Emit.ILGenerator il, System.Reflection.Emit.LocalBuilder localBuilder)
{
il.Emit(System.Reflection.Emit.OpCodes.Stloc, localBuilder);
return(il);
}
public virtual void Emit(OpCode opcode, LocalBuilder local)
{
}
//public static readonly System.Reflection.MethodInfo NameValueCollectionOpImplicitMethodInfo = typeof(NameValueCollection).GetMethod("op_Implicit",new Type[] { typeof(StringContainer)});
/// <summary>
/// 把parameters中的值转换为Model属性中相应类型的值
/// </summary>
/// <param name="methodIL"></param>
/// <param name="model"></param>
/// <param name="propertyInfo"></param>
/// <param name="parametersGetItem"></param>
public static void ConvertPropertyString(ILGenerator methodIL, System.Reflection.Emit.LocalBuilder model,
System.Reflection.PropertyInfo propertyInfo, System.Reflection.MethodInfo parametersGetItem)
{
Type propertyType = propertyInfo.PropertyType;
bool isNullable = false;
if (propertyInfo.PropertyType
#if (NET40 || NET451 || NET461)
.IsGenericType
#endif
#if NETCORE
.GetTypeInfo().IsGenericType
#endif
&& propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
isNullable = true;
propertyType = propertyInfo.PropertyType.GetGenericArguments()[0];
}
if (propertyType == typeof(System.String))
{
if (!propertyInfo.GetSetMethod().IsStatic)
{
methodIL.Emit(OpCodes.Ldloc, model); //model
methodIL.Emit(OpCodes.Ldarg_0); //model,nvc
methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name); //model,nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[typeof(String).TypeHandle]);
methodIL.Emit(OpCodes.Call, propertyInfo.GetSetMethod());
}
else
{
methodIL.Emit(OpCodes.Ldarg_0); //nvc
methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name); //nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[typeof(String).TypeHandle]);
methodIL.Emit(OpCodes.Call, propertyInfo.GetSetMethod());
}
}
else if (propertyType == typeof(System.Int32) ||
propertyType == typeof(System.Int16) ||
propertyType == typeof(System.Int64) ||
propertyType == typeof(System.UInt32) ||
propertyType == typeof(System.UInt16) ||
propertyType == typeof(System.UInt64) ||
propertyType == typeof(System.Byte) ||
propertyType == typeof(System.SByte) ||
propertyType == typeof(System.Single) ||
propertyType == typeof(System.Double) ||
propertyType == typeof(System.Decimal) ||
propertyType == typeof(System.DateTime) ||
propertyType == typeof(System.DateTimeOffset) ||
propertyType == typeof(System.Char) ||
propertyType == typeof(System.Boolean) ||
propertyType == typeof(System.Guid)
)
{
if (!propertyInfo.GetSetMethod().IsStatic)
{
methodIL.Emit(OpCodes.Ldloc, model);
methodIL.Emit(OpCodes.Ldarg_0); //nvc
methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name); //nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[propertyInfo.PropertyType.TypeHandle]);
methodIL.Emit(OpCodes.Callvirt, propertyInfo.GetSetMethod());
}
else
{
methodIL.Emit(OpCodes.Ldarg_0); //nvc
methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name); //nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[propertyInfo.PropertyType.TypeHandle]);
methodIL.Emit(OpCodes.Call, propertyInfo.GetSetMethod());
}
if (isNullable)
{
//var temp = methodIL.DeclareLocal(propertyType);
//var temp1 = methodIL.DeclareLocal(propertyInfo.PropertyType);
//var success = methodIL.DeclareLocal(typeof(Boolean));
//var elseCase = methodIL.DefineLabel();
//var endCase = methodIL.DefineLabel();
//methodIL.Emit(OpCodes.Ldarg_1);//nvc
//methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name);//nvc,key
//methodIL.Emit(OpCodes.Callvirt, parametersGetItem);//string
////string,temp
//methodIL.Emit(OpCodes.Ldloca_S,temp);
////bool
//methodIL.Emit(OpCodes.Call, propertyType.GetMethod("TryParse", new Type[] { typeof(string), propertyType.MakeByRefType() }));
//methodIL.Emit(OpCodes.Stloc_S,success);
//methodIL.Emit(OpCodes.Ldloc_S,success);
////
//methodIL.Emit(OpCodes.Brfalse_S,elseCase);
////model
//methodIL.Emit(OpCodes.Ldarg_0);
////model,temp
//methodIL.Emit(OpCodes.Ldloc,temp);
////model.property=new Type();
//methodIL.Emit(OpCodes.Newobj,propertyInfo.PropertyType.GetConstructor(new Type[] { propertyType}));
////model.property.setMethod(temp);
//methodIL.Emit(OpCodes.Callvirt,propertyInfo.GetSetMethod());
//methodIL.Emit(OpCodes.Br_S,endCase);
//methodIL.MarkLabel(elseCase);
//methodIL.Emit(OpCodes.Ldarg_0);
//methodIL.Emit(OpCodes.Ldloca_S,temp1);
//methodIL.Emit(OpCodes.Initobj,propertyInfo.PropertyType);
//methodIL.Emit(OpCodes.Ldloc_S,temp1);
//methodIL.Emit(OpCodes.Callvirt,propertyInfo.GetSetMethod());
//methodIL.MarkLabel(endCase);
}
else
{
//methodIL.Emit(OpCodes.Ldarg_1);//nvc
//methodIL.Emit(OpCodes.Ldstr, propertyInfo.Name);//nvc,key
//methodIL.Emit(OpCodes.Callvirt, parametersGetItem);//string
//var temp = methodIL.DeclareLocal(propertyInfo.PropertyType);
////methodIL.Emit(OpCodes.Ldc_I4_0);
////methodIL.Emit(OpCodes.Stloc,temp);
////string,&temp
//methodIL.Emit(OpCodes.Ldloca_S, temp);
////bool
//methodIL.Emit(OpCodes.Call, propertyInfo.PropertyType.GetMethod("TryParse", new Type[] { typeof(string), propertyInfo.PropertyType.MakeByRefType() }));
////
//methodIL.Emit(OpCodes.Pop);
//if (!propertyInfo.GetSetMethod().IsStatic)
//{
// //model
// methodIL.Emit(OpCodes.Ldarg_0);
//}
////model,temp
//methodIL.Emit(OpCodes.Ldloc, temp);
////model.property=temp
//methodIL.Emit(OpCodes.Call, propertyInfo.GetSetMethod());
}
}
}
/// <summary>
/// 把parameters中的值转换为Model字段中相应类型的值
/// </summary>
/// <param name="methodIL"></param>
/// <param name="model"></param>
/// <param name="fieldInfo"></param>
/// <param name="parametersGetItem"></param>
public static void ConvertFieldString(ILGenerator methodIL, System.Reflection.Emit.LocalBuilder model,
System.Reflection.FieldInfo fieldInfo, System.Reflection.MethodInfo parametersGetItem)
{
Type fieldType = fieldInfo.FieldType;
bool isNullable = false;
if (fieldInfo.FieldType
#if (NET40 || NET451 || NET461)
.IsGenericType
#endif
#if NETCORE
.GetTypeInfo().IsGenericType
#endif
&& fieldInfo.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
isNullable = true;
fieldType = fieldInfo.FieldType.GetGenericArguments()[0];
}
if (fieldType == typeof(System.String))
{
//model
methodIL.Emit(OpCodes.Ldloc, model);
methodIL.Emit(OpCodes.Ldarg_0); //model,nvc
methodIL.Emit(OpCodes.Ldstr, fieldInfo.Name); //model,nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[typeof(String).TypeHandle]);
//model.field=string
methodIL.Emit(OpCodes.Stfld, fieldInfo);
}
else if (fieldType == typeof(System.Int32) ||
fieldType == typeof(System.Int16) ||
fieldType == typeof(System.Int64) ||
fieldType == typeof(System.UInt32) ||
fieldType == typeof(System.UInt16) ||
fieldType == typeof(System.UInt64) ||
fieldType == typeof(System.Byte) ||
fieldType == typeof(System.SByte) ||
fieldType == typeof(System.Single) ||
fieldType == typeof(System.Double) ||
fieldType == typeof(System.Decimal) ||
fieldType == typeof(System.DateTime) ||
fieldType == typeof(System.DateTimeOffset) ||
fieldType == typeof(System.Char) ||
fieldType == typeof(System.Boolean) ||
fieldType == typeof(System.Guid)
)
{
//model
methodIL.Emit(OpCodes.Ldloc, model);
methodIL.Emit(OpCodes.Ldarg_0); //model,nvc
methodIL.Emit(OpCodes.Ldstr, fieldInfo.Name); //model,nvc,key
methodIL.Emit(OpCodes.Callvirt, NameValueCollectionGetMethodInfo); //model,string
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[fieldInfo.FieldType.TypeHandle]);
//model.field=string
methodIL.Emit(OpCodes.Stfld, fieldInfo);
//如果是泛型
if (isNullable)
{
//var temp = methodIL.DeclareLocal(fieldType);
//var success = methodIL.DeclareLocal(typeof(Boolean));
//var elseCase = methodIL.DefineLabel();
//var endCase = methodIL.DefineLabel();
//methodIL.Emit(OpCodes.Ldarg_1);//nvc
//methodIL.Emit(OpCodes.Ldstr, fieldInfo.Name);//nvc,key
//methodIL.Emit(OpCodes.Callvirt, parametersGetItem);//call ,string
////string,&temp
//methodIL.Emit(OpCodes.Ldloca_S,temp);
////bool
//methodIL.Emit(OpCodes.Call, fieldType.GetMethod("TryParse", new Type[] { typeof(string), fieldType.MakeByRefType() }));
//methodIL.Emit(OpCodes.Stloc_S, success);
//methodIL.Emit(OpCodes.Ldloc_S,success);
////
//methodIL.Emit(OpCodes.Brfalse_S, elseCase);
// //model
// methodIL.Emit(OpCodes.Ldarg_0);
// //model,temp
// methodIL.Emit(OpCodes.Ldloc,temp);
// //model.filed=new Type();
// methodIL.Emit(OpCodes.Newobj,fieldInfo.FieldType.GetConstructor(new Type[]{ fieldType}));
// //model.field=temp;
// methodIL.Emit(OpCodes.Stfld,fieldInfo);
//methodIL.Emit(OpCodes.Br_S,endCase);
//methodIL.MarkLabel(elseCase);
// methodIL.Emit(OpCodes.Ldarg_0);
// methodIL.Emit(OpCodes.Ldflda,fieldInfo);
// methodIL.Emit(OpCodes.Initobj, fieldInfo.FieldType);
//methodIL.MarkLabel(endCase);
}
else
{
//methodIL.Emit(OpCodes.Ldarg_1);//nvc
//methodIL.Emit(OpCodes.Ldstr, fieldInfo.Name);//key
//methodIL.Emit(OpCodes.Callvirt, parametersGetItem);//call ,string
// //get:string,model
//methodIL.Emit(OpCodes.Ldarg_0);
////get:string,&model.field
//methodIL.Emit(OpCodes.Ldflda, fieldInfo);
////bool
//methodIL.Emit(OpCodes.Call, fieldType.GetMethod("TryParse", new Type[] { typeof(string), fieldType.MakeByRefType() }));
////
//methodIL.Emit(OpCodes.Pop);
}
}
else if (fieldType == typeof(NFinal.Http.HttpMultipart.HttpFile))
{
}
else if (fieldType == typeof(System.IO.Stream))
{
}
}
internal void Emit(OpCode opCode, LocalBuilder builder)
{
var real = Mscorlib.GetType("System.Reflection.Emit.LocalBuilder");
this.Invoke("Emit", new Type[] { typeof(OpCode), real }, opCode, builder.Inner);
}
static IEnumerable <CodeInstruction> XPiler(IEnumerable <CodeInstruction> instructions, SRE.ILGenerator generator)
{
var codes = instructions.ToList();
//var gen = generator.GetCecilGen();
SRE.LocalBuilder localAtmo = null;
var atmoGetItem = AccessTools.PropertyGetter(typeof(List <Atmosphere>), "Item");
if (Patch.Debug)
{
Log($"List<Atmosphere>[] getter:{atmoGetItem.FullDescription()}");
}
//Find local atmosphere LocalBuilder
for (int index = 160; index < codes.Count; index++)
{
if (codes[index].opcode == SRE.OpCodes.Callvirt &&
atmoGetItem.Equals(codes[index].operand))
{
localAtmo = codes[++index].operand as SRE.LocalBuilder;
break;
}
}
var fieldPlayerEnteredTiles = AccessTools.Field(typeof(Assets.Scripts.TileSystem), nameof(Assets.Scripts.TileSystem.PlayerEnteredTiles));
//Insert extra check in the if statement
for (int index = 165; index < codes.Count; index++)
{
// /------- Add This -------\
//if(!TileSystem.PlayerEnteredTiles.Contains(Vector2Int) && !atmosphere.IsValidThing())
//find LoadField TileSystem.PlayerEnteredTiles
if (codes[index].opcode == SRE.OpCodes.Ldsfld &&
fieldPlayerEnteredTiles.Equals(codes[index].operand))
{
//Sanity Check
//check if callvirt List<vector2Int>.Contains()
if (codes[index + 2].opcode == SRE.OpCodes.Callvirt &&
typeof(List <UnityEngine.Vector2Int>).GetMethod("Contains").Equals(codes[index + 2].operand))
{
//we start 3 codes later
index += 3;
var truLabel = generator.DefineLabel();
var jmpLabel = generator.DefineLabel();
// jmp to jmpLabel if true
codes.Insert(index++, new CodeInstruction(SRE.OpCodes.Brtrue_S, truLabel));
// load atmosphere local
codes.Insert(index++, new CodeInstruction(SRE.OpCodes.Ldloc_S, localAtmo));
// callvirt bool Atmosphere.IsValidThing()
codes.Insert(index++, new CodeInstruction(SRE.OpCodes.Callvirt,
AccessTools.Method(
typeof(Atmosphere),
nameof(Atmosphere.IsValidThing))));
index += 2;
// add our label to point to this instruction
codes.Insert(index++, new CodeInstruction(SRE.OpCodes.Br_S, jmpLabel));
codes.Insert(index, new CodeInstruction(SRE.OpCodes.Ldc_I4_0));
codes[index++].labels.Add(truLabel);
codes[index].labels.Add(jmpLabel);
break;
}
}
}
return(codes);
}
/// <summary>Puts the specified instruction onto the Microsoft intermediate language (MSIL) stream followed by the index of the given local variable.</summary>
/// <param name="opcode">The MSIL instruction to be emitted onto the stream. </param>
/// <param name="local">A local variable. </param>
/// <exception cref="T:System.ArgumentException">The parent method of the <paramref name="local" /> parameter does not match the method associated with this <see cref="T:System.Reflection.Emit.ILGenerator" />. </exception>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="local" /> is null. </exception>
/// <exception cref="T:System.InvalidOperationException">
/// <paramref name="opcode" /> is a single-byte instruction, and <paramref name="local" /> represents a local variable with an index greater than Byte.MaxValue. </exception>
/// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
public static ILGenerator FluentEmit(this ILGenerator generator, System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.LocalBuilder local)
{
generator.Emit(opcode, local);
return(generator);
}
