public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
{
Type type = Type.EmptyTypes.GetType();
for (int i = 0; i < Compiler.Types.Count; i++)
if (Compiler.Types[i].name == Expr.ReturnType.Name)
type = Compiler.SearchType(Compiler.Types[i].typeArray);
if (assign)
{
assign = false;
LocalBuilder local = cg.DeclareLocal(type);
cg.Emit(OpCodes.Stloc, local);
Expr.GenCode(tb, mb, cg);//pone el array, luego el index y luego el valor para hacer stelem
Index.GenCode(tb, mb, cg);
cg.Emit(OpCodes.Ldloc, local);
cg.Emit(OpCodes.Stelem, type);
}
else
{
Expr.GenCode(tb, mb, cg);
Index.GenCode(tb, mb, cg);
cg.Emit(OpCodes.Ldelem, type);
}
}
protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
{
var genericArgs = source.GetGenericArguments();
if (genericArgs.Length == 0)
{
return new GenericTypeParameterBuilder[0];
}
var names = new string[genericArgs.Length];
for (var i = 0; i < genericArgs.Length; i++)
{
names[i] = genericArgs[i].Name;
}
var genericTypeParameterBuilders = destination.DefineGenericParameters(names);
for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
{
var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();
for (var j = 0; j < genericArgConstraints.Length; j++)
{
genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
}
}
return genericTypeParameterBuilders;
}
private void GenerateFunction(TypeBuilder typeBuilder, out MethodBuilder methodBuilder)
{
methodBuilder = null;
ProgramDeclBlock pdb = this.expr as ProgramDeclBlock;
if (pdb != null)
{
foreach (var function in pdb.Statements)
{
var functionDecl = function as BlockDeclExpr;
if (functionDecl != null)
{
bool isMain = functionDecl.IsMain;
var parameters = functionDecl.Parameters;
Expr mainFunctionParameters = null;
if (isMain)
{
mainFunctionParameters =
GenerateMainMethod(
typeBuilder,
functionDecl,
parameters,
mainFunctionParameters,
out methodBuilder);
}
}
}
}
}
public CodeGenerator(Expression pExpression, String pModuleName, ref LogHandler rLogHandler)
{
_symbolTable = new Dictionary <String, Emit.LocalBuilder>();
_assemblyName = new Reflect.AssemblyName(Path.GetFileNameWithoutExtension(pModuleName));
_statement = pExpression;
//Init Assembly
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, Emit.AssemblyBuilderAccess.Save);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(pModuleName);
_typeBuilder = _moduleBuilder.DefineType("PascalCompilerType");
_methodBuilder = _typeBuilder.DefineMethod
(
"Main",
Reflect.MethodAttributes.Static,
typeof(void),
Type.EmptyTypes
);
_ilGenerator = _methodBuilder.GetILGenerator();
//Actual Work
GenerateStatement(_statement, null);
_ilGenerator.Emit(Emit.OpCodes.Ret);
//Finalizing Work
_typeBuilder.CreateType();
_moduleBuilder.CreateGlobalFunctions();
_assemblyBuilder.SetEntryPoint(_methodBuilder);
_assemblyBuilder.Save(pModuleName);
}
public void IncLevel(int i, string procId)
{
Debug.WriteLine(String.Format("Generator: IncLevel({0},{1})", i, procId));
if(i > 0)
currentMethodBuilder = currentType.DefineMethod(procId, MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
}
public ILDynamicMethodDebugImpl(string name, Type delegateType, Type thisType)
{
_delegateType = delegateType;
_expectedLength = 64;
var mi = delegateType.GetMethod("Invoke");
var uniqueName = ILDynamicTypeDebugImpl.UniqueName(name);
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(uniqueName), AssemblyBuilderAccess.RunAndSave, DynamicILDirectoryPath.DynamicIL);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(uniqueName + ".dll", true);
var sourceCodeFileName = Path.Combine(DynamicILDirectoryPath.DynamicIL, uniqueName + ".il");
_symbolDocumentWriter = _moduleBuilder.DefineDocument(sourceCodeFileName, SymDocumentType.Text, SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
_sourceCodeWriter = new SourceCodeWriter(sourceCodeFileName, _symbolDocumentWriter);
Type[] parameterTypes;
if (thisType != null)
{
parameterTypes = new[] { thisType }.Concat(mi.GetParameters().Select(pi => pi.ParameterType)).ToArray();
}
else
{
parameterTypes = mi.GetParameters().Select(pi => pi.ParameterType).ToArray();
}
_sourceCodeWriter.StartMethod(name, mi.ReturnType, parameterTypes, MethodAttributes.Static);
_typeBuilder = _moduleBuilder.DefineType(name, TypeAttributes.Public, typeof(object), Type.EmptyTypes);
_forbidenInstructions = new ILGenForbidenInstructionsCheating(_typeBuilder);
_dynamicMethod = _typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Static, mi.ReturnType, parameterTypes);
for (int i = 0; i < parameterTypes.Length; i++)
{
_dynamicMethod.DefineParameter(i + 1, ParameterAttributes.In, string.Format("arg{0}", i));
}
}
public CodeGen(Stmt stmt, string moduleName)
{
if (IO.Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
Reflect.AssemblyName name = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(moduleName));
Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
Emit.TypeBuilder typeBuilder = modb.DefineType("Foo");
Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
// CodeGenerator
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
// Go Compile!
this.GenStmt(stmt);
il.Emit(Emit.OpCodes.Ret);
typeBuilder.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(methb);
asmb.Save(moduleName);
this.symbolTable = null;
this.il = null;
}
public InjectableConstructorArg(Type propertyType, string name, MethodBuilder getter, MethodBuilder setter)
{
PropertyType = propertyType;
Name = name;
Getter = getter;
Setter = setter;
}
private static void EmitMethodBody (MethodBuilder methodBuilder, MethodInfo methodInfo, String message)
{
Type returnType = methodInfo.ReturnType;
ILGenerator generator = methodBuilder.GetILGenerator ();
ParameterInfo[] parameterInfos = methodInfo.GetParameters ();
if (returnType == typeof(void)) {
MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_VOID_ARGS;
// Makes the actual call
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldstr, message);
EmitParametersAsArrayOnStack (generator, parameterInfos);
generator.Emit (OpCodes.Call, sendMessageInvoker);
generator.Emit (OpCodes.Ret);
} else {
MethodInfo sendMessageInvoker = EmitInfos.OBJECTIVECRUNTIME_SENDMESSAGE_ARGS_GENERIC.MakeGenericMethod (returnType);
// Makes the actual call
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldstr, message);
EmitParametersAsArrayOnStack (generator, parameterInfos);
generator.Emit (OpCodes.Call, sendMessageInvoker);
generator.Emit (OpCodes.Ret);
}
}
public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
{
List<Type> parametersConstructor = new List<Type>();
List<FieldBuilder> campos = new List<FieldBuilder>();
foreach (var item in Parameters)
{
parametersConstructor.Add(Compiler.SearchType(item.Type));
campos.Add(tb.DefineField(item.Id, Compiler.SearchType(item.Type), FieldAttributes.Public));
}
ConstructorBuilder constructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, parametersConstructor.ToArray());
Compiler.RecordConstructors.Add(new RecordsConstructors(tb.Name, constructor));
ILGenerator ilgen = constructor.GetILGenerator();
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);//creando el contructor vacio para generar el otro
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, objCtor);
int i = 1;
foreach (var item in campos)//poniendole los valores de los campos a lsa propiedades
{
ilgen.Emit(OpCodes.Ldarg_0);//este objeto ilgen=contructor.getIlgenerator()
ilgen.Emit(OpCodes.Ldarg, i);//tiene un field item
ilgen.Emit(OpCodes.Stfld, item);//y en el se pone el valor del argumento i del contructor
i++;
}
ilgen.Emit(OpCodes.Ret);
record = tb.CreateType();
}
internal TypeBuilder(string szName, int genParamPos, MethodBuilder declMeth)
{
this.m_declMeth = declMeth;
this.m_DeclaringType = this.m_declMeth.GetTypeBuilder();
this.m_module = declMeth.GetModuleBuilder();
this.InitAsGenericParam(szName, genParamPos);
}
private void CreateContinueMethod(MethodInfo method, MethodBuilder continueMethod, int position, Type[] parameters, int count)
{
var generator = continueMethod.GetILGenerator();
// Store array in temp0
generator.DeclareLocal(typeof (object[]));
generator.LoadArgument(1);
generator.StashTemporaryVariable(0);
// Push backing object onto the stack
generator.LoadField(backingObject);
// Push each of the arguments passed in onto the stack
for (int i = 0; i < count; i++)
{
generator.LoadTemporaryVariable(0);
generator.LoadInteger(i);
generator.Emit(OpCodes.Ldelem_Ref);
generator.MaybeUnBox(parameters[i]);
}
// Delegate to backing object
generator.Execute(method);
// Convert the returned value to an object
if (method.ReturnType == typeof(void))
generator.LoadNull();
else
generator.MaybeBox(method.ReturnType);
// Return
generator.Emit(OpCodes.Ret);
}
public static IILRewriterContext RewriteInto(this MethodBase src, MethodBuilder dest,
Func<IILOp, IILRewriteControl, IILRewriteControl> logic)
{
var rewriter = new ILRewriter(src, dest, logic);
rewriter.DoRewrite();
return rewriter;
}
private static MethodInfo GetDecompressLZF(ModuleBuilder modBldr, GeneratorOptions config)
{
CreateTb(modBldr, config);
if (decompress_LZF == null)
decompress_LZF = EmitDecompressLZF(mTb);
return decompress_LZF;
}
protected void SetUp () {
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = GetType().FullName;
AssemblyBuilder assembly
= Thread.GetDomain().DefineDynamicAssembly(
assemblyName, AssemblyBuilderAccess.Run);
module = assembly.DefineDynamicModule("module1");
tb = module.DefineType("class1",
TypeAttributes.Public);
eb = tb.DefineEvent ("event1", EventAttributes.None, typeof (AnEvent));
mb =
tb.DefineMethod ("OnAnEvent",
MethodAttributes.Public, typeof (void),
new Type [] { typeof (AnEvent) });
ILGenerator ilgen = mb.GetILGenerator();
ilgen.Emit (OpCodes.Ret);
// These two are required
eb.SetAddOnMethod (mb);
eb.SetRemoveOnMethod (mb);
}
public void Emit(CompilerErrorCollection errors, MethodBuilder m)
{
//Set the parameters
//ParameterBuilder[] parms = new ParameterInfo[args.Length];
for(int i = 0; i < args.Length; i++)
m.DefineParameter(i + 1, ParameterAttributes.None, args[i].Name);
ILGenerator gen = m.GetILGenerator();
//Define the IT variable
LocalRef it = locals["IT"] as LocalRef;
DefineLocal(gen, it);
statements.Process(this, errors, gen);
statements.Emit(this, gen);
//Cast the IT variable to our return type and return it
if (m.ReturnType != typeof(void))
{
gen.Emit(OpCodes.Ldloc, it.Local);
Expression.EmitCast(gen, it.Type, m.ReturnType);
}
gen.Emit(OpCodes.Ret);
}
private Emit.MethodBuilder GenerateMethod(Emit.MethodBuilder methb, MethodDeclaration method)
{
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
this.parameterTable = new System.Collections.Generic.Dictionary <string, Type>();
//foreach (string arg in method.parameters)
//{
// parameterTable[arg] = typeof(string);
//}
foreach (Collections.KeyValuePair <string, Type> para in method.parameters)
{
parameterTable[para.Key] = para.Value;
}
this.GenStmt(method.stmt);
Collections.List <Type> args = new System.Collections.Generic.List <Type>();
foreach (Collections.KeyValuePair <string, Type> para in parameterTable)
{
args.Add(para.Value);
}
//foreach(string arg in method.parameters)
//{
// args.Add(typeof(string));
//}
methb.SetParameters(args.ToArray());
return(methb);
}
private void CompileMainClass(Node ActiveNode)
{
Emit.TypeBuilder _TypeBuilder =
TypeTable[ActiveNode.Nodes[1].Value];
Emit.MethodBuilder MethBuilder = _TypeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
this.AssemblerGenerator = MethBuilder.GetILGenerator();
CurrentType = _TypeBuilder;
OpenBlockVariables();
CreateCode(ActiveNode.Nodes[14]);
CreateCode(ActiveNode.Nodes[15]);
CloseBlockVariables();
// Отладочные команды
AssemblerGenerator.Emit(Emit.OpCodes.Ldstr, "Programm was finished. Press Enter key to quit...");
AssemblerGenerator.Emit(Emit.OpCodes.Call,
typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) }));
AssemblerGenerator.Emit(Emit.OpCodes.Call,
typeof(System.Console).GetMethod("ReadLine", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static, null, new System.Type[] { }, null));
AssemblerGenerator.Emit(Emit.OpCodes.Pop);
AssemblerGenerator.Emit(Emit.OpCodes.Ret);
CreatedTypeTable[ActiveNode.Nodes[1].Value] = _TypeBuilder.CreateType();
ModBuilder.CreateGlobalFunctions();
AsmBuilder.SetEntryPoint(MethBuilder);
}
public static void Generate(
TypeBuilder typeBuilder,
EventMetadata eventMetadata,
MethodBuilder addMethod,
MethodBuilder removeMethod,
MethodBuilder raiseMethod)
{
var @event = typeBuilder.DefineEvent(
eventMetadata.Name,
eventMetadata.EventAttributes,
eventMetadata.EventHandlerType);
if (addMethod != null)
{
@event.SetAddOnMethod(addMethod);
}
if (removeMethod != null)
{
@event.SetRemoveOnMethod(removeMethod);
}
if (raiseMethod != null)
{
@event.SetRaiseMethod(raiseMethod);
}
}
private static void EmitEmptyImplementation( MethodBuilder vM, Type returnType, ParameterInfo[] parameters )
{
ILGenerator gVM = vM.GetILGenerator();
for( int i = 0; i < parameters.Length; ++i )
{
// DefineParameter use 0 for the return parameter.
ParameterInfo param = parameters[i];
vM.DefineParameter( i + 1, param.Attributes, param.Name );
if( param.IsOut )
{
Debug.Assert( param.ParameterType.IsByRef, "'Out' is just an attribute on 'by ref' parameters (unfortunate for covariance support)." );
gVM.StoreDefaultValueForOutParameter( param );
}
}
if( returnType != typeof( void ) )
{
if( returnType.GetTypeInfo().IsValueType )
{
LocalBuilder retValue = gVM.DeclareLocal( returnType );
gVM.Emit( OpCodes.Ldloca_S, retValue.LocalIndex );
gVM.Emit( OpCodes.Initobj, returnType );
gVM.LdLoc( retValue );
}
else
{
gVM.Emit( OpCodes.Ldnull );
}
}
gVM.Emit( OpCodes.Ret );
}
public PropertyEmitter(TypeBuilder owner, string name, Type propertyType, FieldBuilder propertyChangedField) {
this.owner = owner;
this.propertyChangedField = propertyChangedField;
fieldBuilder = owner.DefineField(String.Format("<{0}>", name), propertyType, FieldAttributes.Private);
getterBuilder = owner.DefineMethod(String.Format("get_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, propertyType, Type.EmptyTypes);
ILGenerator getterIl = getterBuilder.GetILGenerator();
getterIl.Emit(OpCodes.Ldarg_0);
getterIl.Emit(OpCodes.Ldfld, fieldBuilder);
getterIl.Emit(OpCodes.Ret);
setterBuilder = owner.DefineMethod(String.Format("set_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, typeof(void), new[] {propertyType});
ILGenerator setterIl = setterBuilder.GetILGenerator();
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Ldarg_1);
setterIl.Emit(OpCodes.Stfld, fieldBuilder);
if (propertyChangedField != null) {
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Dup);
setterIl.Emit(OpCodes.Ldfld, propertyChangedField);
setterIl.Emit(OpCodes.Ldstr, name);
setterIl.Emit(OpCodes.Call, proxyBase_NotifyPropertyChanged);
}
setterIl.Emit(OpCodes.Ret);
propertyBuilder = owner.DefineProperty(name, PropertyAttributes.None, propertyType, null);
propertyBuilder.SetGetMethod(getterBuilder);
propertyBuilder.SetSetMethod(setterBuilder);
}
private void CreateMethodBuilder()
{
methodBuilder = typeBuilder.DefineMethod(
"DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object), typeof(object[]) });
methodBuilder.InitLocals = true;
ilGenerator = methodBuilder.GetILGenerator();
}
public void CreateDynamicMethod()
{
#if SAVE_ASSEMBLY
if (_assemblyBuilder == null)
{
AssemblyName assemblyName = new AssemblyName("ExpressionAssembly");
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, "I:\\Trash");
_moduleBuilder = _assemblyBuilder.DefineDynamicModule("ExpressionModule", "ExpressionModule.module");
}
string typeName = String.Format("Expression{0}", _typeCount);
_typeCount++;
_typeBuilder = _moduleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public);
FieldBuilder filedBuilder = _typeBuilder.DefineField("Source", typeof(string), FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
filedBuilder.SetConstant(_source);
_methodBuilder = _typeBuilder.DefineMethod("Evaluate", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new Type[] { typeof(object[]) });
_ilGenerator = _methodBuilder.GetILGenerator();
#else
_dynamicMethod = new DynamicMethod("Expression", typeof(object), new Type[] { typeof(object[]) }, GetType().Module);
_ilGenerator = _dynamicMethod.GetILGenerator();
#endif
}
private void CreateMethodBuilder(Type returnType, Type[] parameterTypes)
{
methodBuilder = typeBuilder.DefineMethod(
"DynamicMethod", MethodAttributes.Public | MethodAttributes.Static, returnType, parameterTypes);
methodBuilder.InitLocals = true;
emitter = new Emitter(methodBuilder.GetILGenerator(), parameterTypes);
}
private static void EmitBody(MethodBuilder mb, Body body)
{
foreach (var st in body.Statements)
{
EmitStatement(mb, st);
}
}
public override void GenCode(TypeBuilder tb, MethodBuilder mb, ILGenerator cg)
{
LeftOperand.GenCode(tb, mb, cg);
RigthOperand.GenCode(tb, mb, cg);
cg.Emit(OpCodes.And);
}
public void SetupParameters(MethodBuilder methodBuilder)
{
if (methodToOverride.IsGenericMethod)
{
Type[] genericArguments = methodToOverride.GetGenericArguments();
string[] names = genericArguments
.Select(t => t.Name)
.ToArray();
GenericTypeParameterBuilder[] builders = methodBuilder.DefineGenericParameters(names);
for (int i = 0; i < genericArguments.Length; ++i)
{
builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
var constraintTypes = genericArguments[i].GetGenericParameterConstraints();
builders[i].SetInterfaceConstraints(constraintTypes.Where(t => t.IsInterface).ToArray());
foreach (Type type in constraintTypes.Where(t => !t.IsInterface))
{
builders[i].SetBaseTypeConstraint(type);
}
}
for(int i = 0; i < genericArguments.Length; ++i)
{
genericMethodParameters.Add(new KeyValuePair<Type, Type>(genericArguments[i], builders[i].UnderlyingSystemType));
}
}
}
public static GenericTypeParameterBuilder[] CopyGenericArguments(
IMethodInfo methodToCopyGenericsFrom,
MethodBuilder builder,
Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
{
return CopyGenericArguments(methodToCopyGenericsFrom, name2GenericType,
builder.DefineGenericParameters);
}
/// <summary>
/// Calls a method on this variable
/// </summary>
/// <param name="method">Method</param>
/// <param name="parameters">Parameters sent in</param>
/// <returns>Variable returned by the function (if one exists, null otherwise)</returns>
public virtual VariableBase Call(System.Reflection.Emit.MethodBuilder method, object[] parameters = null)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
return(MethodBase.CurrentMethod.Call(this, method, parameters));
}
public CodeGen(Emit.MethodBuilder methb, MethodDeclaration methodDec, Collections.Dictionary <string, Emit.FieldBuilder> typefieldList, string _dllProbeDirectory, MethodGen _parent)
{
this.dllProbeDirectory = _dllProbeDirectory;
this.typefieldList = typefieldList;
this.parent = _parent;
this.methb = methb;
this.methodDec = methodDec;
}
internal void Compile(MethodBuilder m)
{
if (Builder == null)
{
int ofs = (m.IsStatic ? 0 : 1);
Builder = m.DefineParameter(this.Index + ofs, this.Attributes, this.Name);
}
}
internal MethodOnTypeBuilderInst (MethodOnTypeBuilderInst gmd, Type[] typeArguments)
{
this.instantiation = gmd.instantiation;
this.mb = gmd.mb;
this.method_arguments = new Type [typeArguments.Length];
typeArguments.CopyTo (this.method_arguments, 0);
this.generic_method_definition = gmd;
}
private Emit.MethodBuilder GenerateMethod(Emit.TypeBuilder typeBuilder, MethodDeclaration method)
{
Emit.MethodBuilder methb = typeBuilder.DefineMethod(method.MethodName, Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
this.GenStmt(method.stmt);
return(methb);
}
public override void Gen(TypeBuilder program, MethodBuilder method)
{
AstNode left = this.child;
AstNode right = left.sibling;
left.Gen(program, method);
right.Gen(program, method);
method.GetILGenerator().EmitCall(OpCodes.Callvirt, typeof(TypeBase).GetMethod("Equal"), new Type[] { typeof(TypeBase) });
}
// .NET 4.5 and later have the documented SetMethodBody() method.
static Type GetTypeNET45(TypeBuilder tb, MethodBuilder mb, IntPtr address) {
byte[] code = new byte[1] { 0x2A };
int maxStack = 8;
byte[] locals = GetLocalSignature(address);
setMethodBodyMethodInfo.Invoke(mb, new object[5] { code, maxStack, locals, null, null });
var createdMethod = tb.CreateType().GetMethod(METHOD_NAME, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
return createdMethod.GetMethodBody().LocalVariables[0].LocalType;
}
internal void BeginMethod(Type returnType, MethodBuilderInfo methodBuilderInfo, Type[] argTypes, string[] argNames, MethodAttributes methodAttributes)
{
#if DEBUG
methodBuilderInfo.Validate(returnType, argTypes, methodAttributes);
#endif
_methodBuilder = methodBuilderInfo.MethodBuilder;
_ilGen = _methodBuilder.GetILGenerator();
InitILGeneration(argTypes, argNames, (_methodBuilder.Attributes & MethodAttributes.Static) == MethodAttributes.Static);
}
internal void DefineBuilders()
{
declareHelperBuilder = PureAssemblyBuilder.GlobalTypeEmitter.TypeBuilder.DefineMethod(
Name.DeclareHelperName.Value, MethodAttributes.Assembly | MethodAttributes.Static,
Types.Void, new Type[] { typeof(ApplicationContext) });
// sets the type builder to null, which makes functions and global constants defined globally on the module:
this.globalType.TypeDesc.DefineBuilder((TypeBuilder)null);
}
internal EasyMethod(AbstractEasyType maintype, string name, MethodAttributes attrs, ReturnReferenceExpression returnRef, params ArgumentReference[] arguments)
{
this._maintype = maintype;
this._arguments = arguments;
Type returnType = returnRef.Type;
Type[] parameterTypes = ArgumentsUtil.InitializeAndConvert(arguments);
this._builder = maintype.TypeBuilder.DefineMethod(name, attrs, returnType, parameterTypes);
}
public void genMain()
{
//Debemos poner el ret correcto
if (this.il != null)
{
this.il.Emit(Emit.OpCodes.Ret);
}
this.methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void),
System.Type.EmptyTypes);
this.il = methb.GetILGenerator();
}
private Emit.MethodBuilder GetEntryPoint()
{
Emit.MethodBuilder methodB = null;
foreach (TypeGen typeGen in typeList)
{
methodB = typeGen.GetEntryPoint();
if (methodB == null)
{
continue;
}
return(methodB);
}
return(methodB);
}
private static void CopyGenericMethodParameters(MethodInfo targetMethod,
MethodDefinition method,
Dictionary <Type, Type> genArgMapping,
Func <Type, Type> typeReplacer)
{
if (targetMethod.IsGenericMethodDefinition)
{
var targetGenArgs = targetMethod.GetGenericArguments();
var items =
method.DefineGenericParameters(targetGenArgs.Select(x => x.Name).ToArray()).Zip(targetGenArgs,
(paramBuilder,
target) =>
new
{
paramBuilder,
target
})
.ToList();
foreach (var arg in items)
{
arg.paramBuilder.SetGenericParameterAttributes(arg.target.GenericParameterAttributes);
genArgMapping[arg.target] = arg.paramBuilder;
}
foreach (var arg in items)
{
IEnumerable <Type> interfaceConstraints =
arg.target.GetGenericParameterConstraints().Select(typeReplacer).ToList();
if (arg.target.BaseType != null)
{
var baseTypeFixed = typeReplacer(arg.target.BaseType);
if (!baseTypeFixed.IsInterface)
{
arg.paramBuilder.SetBaseTypeConstraint(baseTypeFixed);
}
else
{
//arg.paramBuilder.SetBaseTypeConstraint(typeof(object));
interfaceConstraints = interfaceConstraints.Append(baseTypeFixed);
}
//if (arg.target.BaseType.IsGenericParameter)
//{
// interfaceConstraints = interfaceConstraints.Except(arg.target.BaseType.GetInterfaces());
//}
}
arg.paramBuilder.SetInterfaceConstraints(interfaceConstraints.ToArray());
}
}
}
public void Intercept(DynamicMember parent, System.Reflection.Emit.MethodBuilder builder, System.Reflection.Emit.ILGenerator generator, ref Label returnLabel)
{
var prop = parent as DynamicProperty;
var hasMultipleValuesProperty = prop.DynamicTypeBuilder.DynamicMembers.OfType <DynamicProperty>().FirstOrDefault(p => p.MemberName == $"{prop.MemberName}_HasMultipleValues");
if (hasMultipleValuesProperty == null)
{
return;
}
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Call, hasMultipleValuesProperty.PropertySetMethod);
generator.Emit(OpCodes.Nop);
}
private static void GenerateInvokeMethodIl(MethodDefinition method,
Type[] paramTypes,
ParameterInfo[] parameters,
MethodInfo proxyOnGetMethod)
{
var il = method.GetILGenerator();
var argsLocal = il.DeclareLocal(typeof(object[]));
il.Emit(OpCodes.Ldc_I4, paramTypes.Length);
il.Emit(OpCodes.Newarr, typeof(object));
il.Emit(OpCodes.Stloc, argsLocal);
foreach (var param in parameters)
{
il.Emit(OpCodes.Ldloc, argsLocal);
il.Emit(OpCodes.Ldc_I4, param.Position);
il.Emit(OpCodes.Ldarg, param.Position + 1); // +1 since Ldarg0 means this
if (param.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, param.ParameterType);
}
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetCurrentMethod"));
il.Emit(OpCodes.Castclass, typeof(MethodInfo));
//il.Emit(OpCodes.Ldstr, targetMethod.Name);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Callvirt, proxyOnGetMethod);
if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Pop);
}
else if (method.ReturnType.IsValueType)
{
il.Emit(OpCodes.Unbox_Any, method.ReturnType);
}
else if (method.ReturnType != typeof(object))
{
il.Emit(OpCodes.Castclass, method.ReturnType);
}
il.Emit(OpCodes.Ret);
}
private void inicializar(string nombreCodigoFuente, string nombrePrograma)
{
if (TablaDireccionesSimbolos.Count > 0)
{
throw new System.Exception("ERROR-0002: Tabla de direcciones de variables ha sido inicializada previamente");
}
String rutaEjecutable = IO.Path.GetDirectoryName(nombrePrograma);
//Describo el identificador unico del ensamblado que se esta generando
nombre = new Reflect.AssemblyName(IO.Path.GetFileNameWithoutExtension(nombrePrograma));
//Creo la representacion basica del ensamblado creado de forma dinamica (assembly)
if (rutaEjecutable.Length > 0)
{
asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave, rutaEjecutable);
}
else
{
asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(nombre, Emit.AssemblyBuilderAccess.RunAndSave);
}
Console.WriteLine("Common Runtime usado para generar el ejecutable del programa: " + asmb.ImageRuntimeVersion);
Console.WriteLine("Se esta ejecutando el compilador bajo el CLR version {0}", Environment.Version);
//Defino un nuevo modulo de .net de forma dinamica
modb = asmb.DefineDynamicModule(IO.Path.GetFileName(nombrePrograma), false);
//Creo una nueva clase en el Il Generator stream
typeBuilder = modb.DefineType("pseudoGenerado");
//Debido a que los programas en este tiny solo cuentan con un unico metodo principal (Main) de forma estructurada
//como un truco defino el metodo Main en un objeto por defecto para ejecutar todas las acciones
//expresadas por el lenguaje alli.
//formato: NOMBRE -> Main TIPO-> Static RETORNA-> void PARAMETROS-> vacios
methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.HideBySig | Reflect.MethodAttributes.Static | Reflect.MethodAttributes.Public, typeof(void), System.Type.EmptyTypes);
//Inicializo/Creo el generador/stream de codigo IL con el metodo donde generare el codigo actualmente
this.il = methb.GetILGenerator();
//Para iniciar el programa Emito una primera instruccion vacia (no hace nada)
il.Emit(Emit.OpCodes.Nop);
}
public Emit.MethodBuilder GenerateCode(MethodDeclaration methodDec)
{
MethodAttributes methodAttributes = MethodAttributes.Public;
if (methodDec.IsStatic)
{
methodAttributes = methodAttributes | MethodAttributes.Static;
}
//Type[] types = { typeof(string) };
//Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), types);
Emit.MethodBuilder methb = typeBuilder.DefineMethod(methodDec.MethodName, methodAttributes, typeof(void), System.Type.EmptyTypes);
child = new CodeGen(methb, methodDec, typefieldList, dllProbeDirectory, this);
child.GenerateCode();
return(methb);
}
private static void AdjustParameterTypes(ParameterInfo[] parameters,
Func <Type, Type> typeReplacer,
MethodDefinition method)
{
var fixedParams = new Type[parameters.Length];
foreach (var parameter in parameters)
{
var paramType = typeReplacer(parameter.ParameterType);
fixedParams[parameter.Position] = paramType;
method.DefineParameter(parameter.Position, parameter.Attributes, parameter.Name);
}
// Set fixed parameters having correct generic parameters.
method.SetParameters(fixedParams);
// Set fixed return type with correct generic parameter.
method.SetReturnType(typeReplacer(method.ReturnType));
}
static void Main(string[] args)
{
string name = "hello.exe";
var asm_name = new Refl.AssemblyName(IO.Path.GetFileNameWithoutExtension(name)); //no extension for assembly name
var asml = System.AppDomain.CurrentDomain.DefineDynamicAssembly(asm_name, Emit.AssemblyBuilderAccess.Save);
var modl = asml.DefineDynamicModule(name); //extension is needed for module name
var prog = modl.DefineType("Program");
Emit.MethodBuilder main = prog.DefineMethod("Main", Refl.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
var generator = main.GetILGenerator();
generator.Emit(Emit.OpCodes.Ldstr, "hello~ I'm Yue");
generator.Emit(Emit.OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new System.Type[] { typeof(string) }));//?
generator.Emit(Emit.OpCodes.Ret);
prog.CreateType();
modl.CreateGlobalFunctions();
asml.SetEntryPoint(main);
asml.Save(name);
}
public static Type BuildPropertyObject(System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <string, Type> > obj)
{
string nameOfDLL = "magic.dll";
string nameOfAssembly = "magic_Assembly";
string nameOfModule = "magic_Module";
string nameOfType = "magic_Type";
System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName {
Name = nameOfAssembly
};
System.Reflection.Emit.AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave);
System.Reflection.Emit.ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(nameOfModule, nameOfDLL);
System.Reflection.Emit.TypeBuilder typeBuilder = moduleBuilder.DefineType(nameOfType, System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class);
foreach (var prop in obj)
{
string Name = prop.Key;
Type DataType = prop.Value;
System.Reflection.Emit.FieldBuilder field = typeBuilder.DefineField("_" + Name, DataType, System.Reflection.FieldAttributes.Private);
System.Reflection.Emit.PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(Name, System.Reflection.PropertyAttributes.SpecialName, DataType, null);
System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.SpecialName;
System.Reflection.Emit.MethodBuilder methodBuilderGetter = typeBuilder.DefineMethod("get_" + Name, methodAttributes, DataType, new Type[] { });
System.Reflection.Emit.MethodBuilder methodBuilderSetter = typeBuilder.DefineMethod("set_" + Name, methodAttributes, typeof(void), new Type[] { DataType });
System.Reflection.Emit.ILGenerator ilGeneratorGetter = methodBuilderGetter.GetILGenerator();
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldfld, field);
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ret);
System.Reflection.Emit.ILGenerator ilGeneratorSetter = methodBuilderSetter.GetILGenerator();
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Stfld, field);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ret);
propertyBuilder.SetGetMethod(methodBuilderGetter);
propertyBuilder.SetSetMethod(methodBuilderSetter);
}
// Yes! you must do this, it should not be needed but it is!
Type dynamicType = typeBuilder.CreateType();
// Save to file
assemblyBuilder.Save(nameOfDLL);
return(dynamicType);
}
public CodeGen(stmt stmt, string moduleName, int count)
{
if (IO.Path.GetFileName(moduleName) != moduleName)
{
throw new System.Exception("can only output into current directory!");
}
stmts = stmt;
Reflect.AssemblyName name = new Reflect.AssemblyName("FAJF"); //name of the assembly
Emit.AssemblyBuilder asmb = System.AppDomain.CurrentDomain.DefineDynamicAssembly(name, Emit.AssemblyBuilderAccess.Save);
Emit.ModuleBuilder modb = asmb.DefineDynamicModule(moduleName);
Emit.TypeBuilder typeBuilder = modb.DefineType("resister"); //name of the class
Emit.MethodBuilder methb = typeBuilder.DefineMethod("Main", Reflect.MethodAttributes.Static, typeof(void), System.Type.EmptyTypes);
// CodeGenerator
this.il = methb.GetILGenerator();
this.symbolTable = new Collections.Dictionary <string, Emit.LocalBuilder>();
counting = 0;
counter = count;
counters = 0;
// Go Compile!
this.GenStmt(stmt);
il.Emit(Emit.OpCodes.Ret);
typeBuilder.CreateType();
modb.CreateGlobalFunctions();
asmb.SetEntryPoint(methb);
asmb.Save(moduleName);
// this.il.EmitWriteLine("press any key to continue");
this.symbolTable = null;
this.il = null;
System.Diagnostics.Process.Start(moduleName);
}
public void SetRaiseMethod(MethodBuilder mdBuilder)
{
ArgumentNullException.ThrowIfNull(mdBuilder);
RejectIfCreated();
raise_method = mdBuilder;
}
public void SetSetMethod(MethodBuilder mdBuilder)
{
set_method = mdBuilder;
}
public void SetGetMethod(MethodBuilder mdBuilder)
{
get_method = mdBuilder;
}
public void AddOtherMethod(MethodBuilder mdBuilder)
{
}
public void AddOtherMethod(MethodBuilder mdBuilder)
{
SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Other);
}
public void SetRaiseMethod(MethodBuilder mdBuilder)
{
SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Fire);
}
public void SetRemoveOnMethod(MethodBuilder mdBuilder)
{
SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.RemoveOn);
}
public void SetAddOnMethod(MethodBuilder mdBuilder)
{
ArgumentNullException.ThrowIfNull(mdBuilder);
RejectIfCreated();
add_method = mdBuilder;
}
public void SetAddOnMethod(MethodBuilder mdBuilder)
{
SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.AddOn);
}
public void Intercept(DynamicMember parent, System.Reflection.Emit.MethodBuilder builder, System.Reflection.Emit.ILGenerator generator, ref Label returnLabel)
{
var prop = parent as DynamicProperty;
var originalReturn = returnLabel;
bool valueType = false;
var compareMethod = prop.MemberType.GetMethod("op_Equality", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
if (compareMethod == null)
{
compareMethod = typeof(object).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public);
valueType = true;
}
generator.Emit(OpCodes.Nop);
generator.Emit(OpCodes.Ldarg_1);
if (valueType)
{
generator.Emit(OpCodes.Box, prop.MemberType);
}
if (!prop.IsOverride)
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, prop.BackingField);
}
else
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, prop.PropertyGetMethod);
}
if (valueType)
{
generator.Emit(OpCodes.Box, prop.MemberType);
}
var endlabel = generator.DefineLabel();
generator.Emit(OpCodes.Call, compareMethod);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Ceq);
generator.Emit(OpCodes.Brfalse_S, returnLabel);
generator.Emit(OpCodes.Br_S, endlabel);
returnLabel = generator.DefineLabel();
generator.MarkLabel(returnLabel);
var raiseMethod = prop.DynamicTypeBuilder.DynamicMembers
.OfType <RaisePropertyChangedMethod>()
.Select(p => p.Method)
.OfType <MethodInfo>()
.FirstOrDefault();
if (raiseMethod == null)
{
raiseMethod = prop.DynamicTypeBuilder.BaseType.GetMethod("OnPropertyChanged", BindingFlags.NonPublic | BindingFlags.Instance);
}
if (raiseMethod == null)
{
#if (SILVERLIGHT)
throw new MissingMemberException(string.Format("Missing Member {1} on type {0}", builder.DeclaringType.Name, "PropertyChanged"));
#else
throw new MissingMemberException(builder.DeclaringType.Name, "PropertyChanged");
#endif
}
generator.Emit(OpCodes.Nop);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldstr, prop.MemberName);
generator.Emit(OpCodes.Callvirt, raiseMethod);
generator.Emit(OpCodes.Br_S, originalReturn);
generator.MarkLabel(endlabel);
}
private int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTypes)
{
if (optionalParameterTypes != null && (methodInfo.CallingConvention & CallingConventions.VarArgs) == (CallingConventions)0)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAVarArgCallingConvention"));
}
RuntimeMethodInfo runtimeMethodInfo = methodInfo as RuntimeMethodInfo;
DynamicMethod dynamicMethod = methodInfo as DynamicMethod;
if (runtimeMethodInfo == null && dynamicMethod == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "methodInfo");
}
ParameterInfo[] parametersNoCopy = methodInfo.GetParametersNoCopy();
Type[] array;
if (parametersNoCopy != null && parametersNoCopy.Length != 0)
{
array = new Type[parametersNoCopy.Length];
for (int i = 0; i < parametersNoCopy.Length; i++)
{
array[i] = parametersNoCopy[i].ParameterType;
}
}
else
{
array = null;
}
SignatureHelper memberRefSignature = this.GetMemberRefSignature(methodInfo.CallingConvention, MethodBuilder.GetMethodBaseReturnType(methodInfo), array, optionalParameterTypes);
if (runtimeMethodInfo != null)
{
return(this.GetTokenForVarArgMethod(runtimeMethodInfo, memberRefSignature));
}
return(this.GetTokenForVarArgMethod(dynamicMethod, memberRefSignature));
}
