public TypeGen DefineType(string name, Type parent, bool preserveName, bool emitDebugSymbols) { AssemblyGen ag = GetAssembly(emitDebugSymbols); TypeBuilder tb = ag.DefinePublicType(name, parent, preserveName); return(new TypeGen(ag, tb)); }
private TypeGen GenerateModuleGlobalsType(AssemblyGen ag) { TypeGen tg = ag.DefinePublicType(ModuleName == "ironscheme.boot.new" ? "#" : ModuleName, typeof(CustomSymbolDictionary)); tg.AddCodeContextField(); tg.DefaultConstructor = tg.TypeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return(tg); }
public DynamicILGen CreateDynamicMethod(string methodName, Type returnType, Type[] parameterTypes, bool isDebuggable) { ContractUtils.RequiresNotEmpty(methodName, nameof(methodName)); ContractUtils.RequiresNotNull(returnType, nameof(returnType)); ContractUtils.RequiresNotNullItems(parameterTypes, nameof(parameterTypes)); #if FEATURE_REFEMIT if (Snippets.Shared.SaveSnippets) { AssemblyGen assembly = GetAssembly(isDebuggable); TypeBuilder tb = assembly.DefinePublicType(methodName, typeof(object), false); MethodBuilder mb = tb.DefineMethod(methodName, CompilerHelpers.PublicStatic, returnType, parameterTypes); return(new DynamicILGenType(tb, mb, mb.GetILGenerator())); } #endif DynamicMethod dm = ReflectionUtils.RawCreateDynamicMethod(methodName, returnType, parameterTypes); return(new DynamicILGenMethod(dm, dm.GetILGenerator())); }
private TypeGen GenerateModuleGlobalsType(AssemblyGen ag, ScriptCode sc) { var n = sc.CodeBlock.Name; switch (n) { case "visit-code": case "invoke-code": case "guard-code": TypeGen tg = ag.DefinePublicType("syntax-" + sc.CodeBlock.Name, typeof(CustomSymbolDictionary)); tg.AddCodeContextField(); tg.DefaultConstructor = tg.TypeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return(tg); default: return(GenerateModuleGlobalsType(ag)); } }
/// <summary> /// This takes an assembly name including extension and saves the provided ScriptCode objects into the assembly. /// /// The provided script codes can constitute code from multiple languages. The assemblyName can be either a fully qualified /// or a relative path. The DLR will simply save the assembly to the desired location. The assembly is created by the DLR and /// if a file already exists than an exception is raised. /// /// The DLR determines the internal format of the ScriptCode and the DLR can feel free to rev this as appropriate. /// </summary> public static void SaveToAssembly(string assemblyName, params SavableScriptCode[] codes) { ContractUtils.RequiresNotNull(assemblyName, "assemblyName"); ContractUtils.RequiresNotNullItems(codes, "codes"); // break the assemblyName into it's dir/name/extension string dir = Path.GetDirectoryName(assemblyName); if (String.IsNullOrEmpty(dir)) { dir = Environment.CurrentDirectory; } string name = Path.GetFileNameWithoutExtension(assemblyName); string ext = Path.GetExtension(assemblyName); // build the assembly & type gen that all the script codes will live in... AssemblyGen ag = new AssemblyGen(new AssemblyName(name), dir, ext, /*emitSymbols*/false); TypeBuilder tb = ag.DefinePublicType("DLRCachedCode", typeof(object), true); TypeGen tg = new TypeGen(ag, tb); var symbolDict = new Dictionary<SymbolId, FieldBuilder>(); // then compile all of the code Dictionary<Type, List<CodeInfo>> langCtxBuilders = new Dictionary<Type, List<CodeInfo>>(); foreach (SavableScriptCode sc in codes) { List<CodeInfo> builders; if (!langCtxBuilders.TryGetValue(sc.LanguageContext.GetType(), out builders)) { langCtxBuilders[sc.LanguageContext.GetType()] = builders = new List<CodeInfo>(); } KeyValuePair<MethodBuilder, Type> compInfo = sc.CompileForSave(tg, symbolDict); builders.Add(new CodeInfo(compInfo.Key, sc, compInfo.Value)); } MethodBuilder mb = tb.DefineMethod( "GetScriptCodeInfo", MethodAttributes.SpecialName | MethodAttributes.Public | MethodAttributes.Static, typeof(MutableTuple<Type[], Delegate[][], string[][], string[][]>), Type.EmptyTypes); ILGen ilgen = new ILGen(mb.GetILGenerator()); var langsWithBuilders = langCtxBuilders.ToArray(); // lang ctx array ilgen.EmitArray(typeof(Type), langsWithBuilders.Length, (index) => { ilgen.Emit(OpCodes.Ldtoken, langsWithBuilders[index].Key); ilgen.EmitCall(typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) })); }); // builders array of array ilgen.EmitArray(typeof(Delegate[]), langsWithBuilders.Length, (index) => { List<CodeInfo> builders = langsWithBuilders[index].Value; ilgen.EmitArray(typeof(Delegate), builders.Count, (innerIndex) => { ilgen.EmitNull(); ilgen.Emit(OpCodes.Ldftn, builders[innerIndex].Builder); ilgen.EmitNew( builders[innerIndex].DelegateType, new[] { typeof(object), typeof(IntPtr) } ); }); }); // paths array of array ilgen.EmitArray(typeof(string[]), langsWithBuilders.Length, (index) => { List<CodeInfo> builders = langsWithBuilders[index].Value; ilgen.EmitArray(typeof(string), builders.Count, (innerIndex) => { ilgen.EmitString(builders[innerIndex].Code.SourceUnit.Path); }); }); // 4th element in tuple - custom per-language data ilgen.EmitArray(typeof(string[]), langsWithBuilders.Length, (index) => { List<CodeInfo> builders = langsWithBuilders[index].Value; ilgen.EmitArray(typeof(string), builders.Count, (innerIndex) => { ICustomScriptCodeData data = builders[innerIndex].Code as ICustomScriptCodeData; if (data != null) { ilgen.EmitString(data.GetCustomScriptCodeData()); } else { ilgen.Emit(OpCodes.Ldnull); } }); }); ilgen.EmitNew( typeof(MutableTuple<Type[], Delegate[][], string[][], string[][]>), new[] { typeof(Type[]), typeof(Delegate[][]), typeof(string[][]), typeof(string[][]) } ); ilgen.Emit(OpCodes.Ret); mb.SetCustomAttribute(new CustomAttributeBuilder( typeof(DlrCachedCodeAttribute).GetConstructor(Type.EmptyTypes), ArrayUtils.EmptyObjects )); tg.FinishType(); ag.SaveAssembly(); }
private KeyValuePair<Type, Dictionary<string, string[]>> SaveType(AssemblyGen ag, string name) { _tg = ag.DefinePublicType(TypePrefix + name, _baseType, true); Dictionary<string, string[]> specialNames = ImplementType(); Type ret = FinishType(); return new KeyValuePair<Type, Dictionary<string, string[]>>(ret, specialNames); }
public static void SaveNewTypes(string assemblyName, IList<PythonTuple> types) { Assert.NotNull(assemblyName, types); AssemblyGen ag = new AssemblyGen(new AssemblyName(assemblyName), ".", ".dll", false); TypeBuilder tb = ag.DefinePublicType(_constructorTypeName, typeof(object), true); tb.SetCustomAttribute(typeof(PythonCachedTypeInfoAttribute).GetConstructor(Type.EmptyTypes), new byte[0]); MethodBuilder mb = tb.DefineMethod(_constructorMethodName, MethodAttributes.Public | MethodAttributes.Static, typeof(CachedNewTypeInfo[]), Type.EmptyTypes); ILGenerator ilg = mb.GetILGenerator(); // new CachedTypeInfo[types.Count] // we leave this on the stack (duping it) and storing into it. EmitInt(ilg, types.Count); ilg.Emit(OpCodes.Newarr, typeof(CachedNewTypeInfo)); int curType = 0; foreach (var v in types) { NewTypeInfo nti = NewTypeInfo.GetTypeInfo(String.Empty, v); var typeInfos = new NewTypeMaker(nti).SaveType(ag, "Python" + _typeCount++ + "$" + nti.BaseType.Name); // prepare for storing the element into our final array ilg.Emit(OpCodes.Dup); EmitInt(ilg, curType++); // new CachedNewTypeInfo(type, specialNames, interfaceTypes): // load the type ilg.Emit(OpCodes.Ldtoken, typeInfos.Key); ilg.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle")); // create the dictionary<str, str[]> of special names ilg.Emit(OpCodes.Newobj, typeof(Dictionary<string, string[]>).GetConstructor(new Type[0])); foreach (var specialName in typeInfos.Value) { // dup dict ilg.Emit(OpCodes.Dup); // emit key ilg.Emit(OpCodes.Ldstr, specialName.Key); // emit value int iVal = specialName.Value.Length; EmitInt(ilg, iVal); ilg.Emit(OpCodes.Newarr, typeof(string)); for (int i = 0; i < specialName.Value.Length; i++) { ilg.Emit(OpCodes.Dup); EmitInt(ilg, i); ilg.Emit(OpCodes.Ldstr, specialName.Value[0]); ilg.Emit(OpCodes.Stelem_Ref); } // assign to dict ilg.Emit(OpCodes.Call, typeof(Dictionary<string, string[]>).GetMethod("set_Item")); } // emit the interface types (if any) if (nti.InterfaceTypes.Count != 0) { EmitInt(ilg, nti.InterfaceTypes.Count); ilg.Emit(OpCodes.Newarr, typeof(Type)); for (int i = 0; i < nti.InterfaceTypes.Count; i++) { ilg.Emit(OpCodes.Dup); EmitInt(ilg, i); ilg.Emit(OpCodes.Ldtoken, nti.InterfaceTypes[i]); ilg.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle")); ilg.Emit(OpCodes.Stelem_Ref); } } else { ilg.Emit(OpCodes.Ldnull); } // crated the CachedNewTypeInfo and store it in the array ilg.Emit(OpCodes.Newobj, typeof(CachedNewTypeInfo).GetConstructors()[0]); ilg.Emit(OpCodes.Stelem_Ref); } ilg.Emit(OpCodes.Ret); tb.CreateType(); ag.SaveAssembly(); }
private TypeGen GenerateModuleGlobalsType(AssemblyGen ag) { TypeGen tg = ag.DefinePublicType(ModuleName == "ironscheme.boot.new" ? "#" : ModuleName, typeof(CustomSymbolDictionary)); tg.AddCodeContextField(); tg.DefaultConstructor = tg.TypeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return tg; }
private TypeGen GenerateModuleGlobalsType(AssemblyGen ag, ScriptCode sc) { var n = sc.CodeBlock.Name; switch (n) { case "visit-code": case "invoke-code": case "guard-code": TypeGen tg = ag.DefinePublicType("syntax-" + sc.CodeBlock.Name, typeof(CustomSymbolDictionary)); tg.AddCodeContextField(); tg.DefaultConstructor = tg.TypeBuilder.DefineDefaultConstructor(MethodAttributes.Public); return tg; default: return GenerateModuleGlobalsType(ag); } }
public static RecordTypeDescriptor GenerateRecordTypeDescriptor(AssemblyGen ag, object name, object parent, object uid, object issealed, object isopaque, object fields, object fieldtypes) { string n = SymbolTable.IdToString(RequiresNotNull<SymbolId>(name)); string id = uid is SymbolId ? SymbolTable.IdToString(RequiresNotNull<SymbolId>(uid)): uid as string; if (id != null) { RecordTypeDescriptor ngrtd; if (nongenerative.TryGetValue(n + id, out ngrtd)) { return ngrtd; } var type = ClrGenerator.GetTypeFast("record." + id + "." + n.Replace("&", "$")); if (type != null) { return RecordTypeDescriptor.Create(type, n, id, parent as RecordTypeDescriptor); } } bool @sealed = RequiresNotNull<bool>(issealed); bool opaque = RequiresNotNull<bool>(isopaque); RecordTypeDescriptor prtd = parent as RecordTypeDescriptor; // can be #f Type parenttype = typeof(object); if (prtd != null) { parenttype = prtd.type; } else if (n == "&condition") { parenttype = typeof(Condition); } TypeAttributes attrs = TypeAttributes.Public | TypeAttributes.Serializable; var rtd = new RecordTypeDescriptor { Name = n, @sealed = @sealed, opaque = opaque, ag = ag, Parent = prtd, uid = uid, generative = id == null || uid is string, }; if (@sealed) { attrs |= TypeAttributes.Sealed; } object gid = (object)id ?? Guid.NewGuid(); var ns = "record." + gid; var typename = ns + "." + n.Replace("&", "$"); TypeGen tg = ag.DefinePublicType(typename, parenttype, attrs); rtd.tg = tg; rtd.type = tg.TypeBuilder; if (id != null) { nongenerative[n + id] = rtd; } if (parenttype.IsSubclassOf(typeof(Condition))) { SetSymbolValueFast(SymbolTable.StringToObject(n + "-rtd"), rtd); } GeneratePredicate(n, rtd, tg); GenerateFields(fields, n, rtd, tg, fieldtypes); GenerateConstructor(rtd, tg, parenttype); return rtd; }