| public SetCustomAttribute ( System customBuilder ) : void | ||
| customBuilder | System | |
| return | void | |
/**
*
*/
public void EmitDecls()
{
Manager.Solver.Enqueue(() =>
{
compile_all_tyinfos(false);
foreach (var (attr, shouldEmit) in Manager.AttributeCompiler.GetCompiledAssemblyAttributes(
assembly_attributes))
{
if (shouldEmit)
{
_assembly_builder.SetCustomAttribute(attr);
}
}
// emit debug attributes
if (Manager.Options.EmitDebug)
{
var attr = Manager.AttributeCompiler.MakeEmittedAttribute(SystemTypeCache.DebuggableAttribute,
new[] {SystemTypeCache.DebuggableAttribute_DebuggingModes},
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default);
_assembly_builder.SetCustomAttribute(attr);
}
// do not require string literals interning
var attr2 = Manager.AttributeCompiler.MakeEmittedAttribute(
SystemTypeCache.CompilationRelaxationsAttribute, 8);
_assembly_builder.SetCustomAttribute(attr2);
// wrap non exception throws
/* uncomment it after we get dependency upon mono 1.1.10, since mono 1.1.9.x do not support this attribute
*/
});
}
static EmitInterfaceImplementorBase()
{
if (IsDirty && SaveCache)
{
AppDomain.CurrentDomain.ProcessExit += (sender, args) => AssemblyBuilder.Save(AsmFileName);
}
ResolveMethodInfo = null;
foreach (var methodInfo in typeof(AppScope).GetMethods())
{
if (methodInfo.Name == "Resolve" && methodInfo.IsGenericMethod)
{
ResolveMethodInfo = methodInfo;
break;
}
}
var idx = 0;
foreach (var asmFileName in Directory.EnumerateFiles(".", AsmFileName + "*.dll"))
{
idx++;
try
{
var asm1 = Assembly.LoadFrom(asmFileName);
foreach (var type in asm1.GetTypes())
{
var iface = type.GetInterfaces().FirstOrDefault();
if (iface != null) Types[iface] = type;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
AsmFileName = string.Format("{0}.{1}.dll", AsmFileName, idx);
AssemblyBuilder =
AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(AsmFileName)
{
Version = new Version(1, 0, 0, 0),
VersionCompatibility = AssemblyVersionCompatibility.SameMachine,
}, AssemblyBuilderAccess.RunAndSave);
//AssemblyBuilder.
//AssemblyBuilder.DefineVersionInfoResource(AsmFileName, "1.0.0.0", "Zen", "(c) 2013 by FruT", "ZenCore");
var verAttrType = typeof(AssemblyVersionAttribute); //("1.0.0.0")
var verAttrCtor = verAttrType.GetConstructor(new[] { typeof(string) });
var attrBuilder = new CustomAttributeBuilder(verAttrCtor, new object[] { "1.0.0.0" });
AssemblyBuilder.SetCustomAttribute(attrBuilder);
var fverAttrType = typeof(AssemblyVersionAttribute); //("1.0.0.0")
var fverAttrCtor = fverAttrType.GetConstructor(new[] { typeof(string) });
var fattrBuilder = new CustomAttributeBuilder(fverAttrCtor, new object[] { "1.0.0.0" });
AssemblyBuilder.SetCustomAttribute(fattrBuilder);
ModuleBuilder = AssemblyBuilder.DefineDynamicModule("EmitedImplementors", AsmFileName);
}
public AssemblyAlgorithmIdAttributeTest ()
{
//create a dynamic assembly with the required attribute
//and check for the validity
dynAsmName.Name = "TestAssembly";
dynAssembly = Thread.GetDomain ().DefineDynamicAssembly (
dynAsmName,AssemblyBuilderAccess.Run
);
// Set the required Attribute of the assembly.
Type attribute = typeof (AssemblyAlgorithmIdAttribute);
ConstructorInfo ctrInfo = attribute.GetConstructor (
new Type [] { typeof (AssemblyHashAlgorithm) }
);
CustomAttributeBuilder attrBuilder =
new CustomAttributeBuilder (
ctrInfo,
new object [1] { AssemblyHashAlgorithm.MD5 }
);
dynAssembly.SetCustomAttribute (attrBuilder);
object [] attributes = dynAssembly.GetCustomAttributes (true);
attr = attributes [0] as AssemblyAlgorithmIdAttribute;
}
public DynamicAssembly()
{
int assemblyNumber = Interlocked.Increment(ref _assemblyCount);
_assemblyName = new AssemblyName {
Name = String.Format("Quokka.DynamicAssembly.N{0}", assemblyNumber)
};
string moduleName = AssemblyName.Name;
_dynamicClassNamespace = AssemblyName.Name;
if (CreateFiles)
{
_assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(
AssemblyName, AssemblyBuilderAccess.RunAndSave);
// Add a debuggable attribute to the assembly saying to disable optimizations
// See http://blogs.msdn.com/rmbyers/archive/2005/06/26/432922.aspx
Type daType = typeof (DebuggableAttribute);
ConstructorInfo daCtor = daType.GetConstructor(new[] {typeof (bool), typeof (bool)});
var daBuilder = new CustomAttributeBuilder(daCtor, new object[] {true, true});
_assemblyBuilder.SetCustomAttribute(daBuilder);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName);
_canSave = true;
}
else
{
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run);
_moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName);
}
}
public Emitter(EmitterOptions options)
{
_options = options;
_assemblyName = new AssemblyName(_options.AssemblyName);
_assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, AssemblyBuilderAccess.RunAndSave);// TODO: temp for debugging .RunAndCollect);
if (_options.DebugOn)
_assembly.SetCustomAttribute
(
new CustomAttributeBuilder
(
typeof(DebuggableAttribute).GetConstructor
(
new System.Type[] { typeof(DebuggableAttribute.DebuggingModes) }
),
new object[]
{
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default
}
)
);
_module = _assembly.DefineDynamicModule(_assemblyName.Name, _assemblyName.Name + ".dll", _options.DebugOn);
if (_options.DebugOn)
_symbolWriter = _module.DefineDocument(_options.SourceFileName, Guid.Empty, Guid.Empty, Guid.Empty);
_tupleToNative = new Dictionary<Type.TupleType, System.Type>();
}
private static void AddDebuggingAttribute(AssemblyBuilder assembly)
{
var debugAttribute = typeof(DebuggableAttribute);
var debugConstructor = debugAttribute.GetConstructor(
new Type[] { typeof(DebuggableAttribute.DebuggingModes) });
var debugBuilder = new CustomAttributeBuilder(
debugConstructor, new object[] {
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default });
assembly.SetCustomAttribute(debugBuilder);
}
public static void ApplyTo(AssemblyBuilder assemblyBuilder, Dictionary<CacheKey, string> mappings)
{
using (var stream = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(stream, mappings);
var bytes = stream.ToArray();
var attributeBuilder = new CustomAttributeBuilder(constructor, new object[] { bytes });
assemblyBuilder.SetCustomAttribute(attributeBuilder);
}
}
public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, IEnumerable <CustomAttributeBuilder>?assemblyAttributes)
{
AssemblyBuilder ab = DefineDynamicAssembly(name, access);
if (assemblyAttributes != null)
{
foreach (CustomAttributeBuilder attr in assemblyAttributes)
{
ab.SetCustomAttribute(attr);
}
}
return(ab);
}
setDebuggable(System.Reflection.Emit.AssemblyBuilder assemblyBuilder)
{
Type daType = typeof(DebuggableAttribute);
ConstructorInfo daCtor =
daType.GetConstructor(new Type[] {
typeof(DebuggableAttribute.DebuggingModes)
});
CustomAttributeBuilder daBuilder =
new CustomAttributeBuilder(daCtor, new object[] {
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default
});
assemblyBuilder.SetCustomAttribute(daBuilder);
}
private void EmitAttribute(AssemblyBuilder parent, CodeAttributeDeclaration attribute)
{
var type = (Type) attribute.AttributeType.UserData[Parser.RawData];
var vals = new object[attribute.Arguments.Count];
var args = new Type[vals.Length];
for (int i = 0; i < vals.Length; i++)
{
vals[i] = ((CodePrimitiveExpression) attribute.Arguments[i].Value).Value;
args[i] = vals[i].GetType();
}
var ctor = type.GetConstructor(args);
var builder = new CustomAttributeBuilder(ctor, vals);
parent.SetCustomAttribute(builder);
}
public Emitter(EmitterOptions options)
{
_options = options;
//// TODO: setup separate app domain with appropriate cache path, shadow copying etc.
//var domainName = "plan" + DateTime.Now.Ticks.ToString();
//var domain = AppDomain.CreateDomain(domainName);
_assemblyName = new AssemblyName(_options.AssemblyName);
_assembly =
AppDomain.CurrentDomain.DefineDynamicAssembly
(
_assemblyName,
_options.DebugOn ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.RunAndCollect
);
if (_options.DebugOn)
_assembly.SetCustomAttribute
(
new CustomAttributeBuilder
(
typeof(DebuggableAttribute).GetConstructor
(
new System.Type[] { typeof(DebuggableAttribute.DebuggingModes) }
),
new object[]
{
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default
}
)
);
_module = _assembly.DefineDynamicModule(_assemblyName.Name, _assemblyName.Name + ".dll", _options.DebugOn);
if (_options.DebugOn)
_symbolWriter = _module.DefineDocument(_options.SourceFileName, Guid.Empty, Guid.Empty, Guid.Empty);
_tupleToNative = new Dictionary<TupleType, System.Type>();
}
[System.Security.SecurityCritical] // auto-generated
private static void SetTypeLibVersionAttribute(AssemblyBuilder asmBldr, Object typeLib)
{
Type []aConsParams = new Type[2] {typeof(int), typeof(int)};
ConstructorInfo TypeLibVerCons = typeof(TypeLibVersionAttribute).GetConstructor(aConsParams);
// Get the typelib version
int major;
int minor;
Marshal.GetTypeLibVersion((ITypeLib)typeLib, out major, out minor);
// Create an instance of the custom attribute builder.
Object[] aArgs = new Object[2] {major, minor};
CustomAttributeBuilder TypeLibVerBuilder = new CustomAttributeBuilder(TypeLibVerCons, aArgs);
// Set the attribute on the assembly builder.
asmBldr.SetCustomAttribute(TypeLibVerBuilder);
}
[System.Security.SecurityCritical] // auto-generated
private static void SetImportedFromTypeLibAttrOnAssembly(AssemblyBuilder asmBldr, Object typeLib)
{
// Retrieve the ImportedFromTypeLibAttribute constructor.
Type []aConsParams = new Type[1] {typeof(String)};
ConstructorInfo ImpFromComAttrCons = typeof(ImportedFromTypeLibAttribute).GetConstructor(aConsParams);
// Retrieve the name of the typelib.
String strTypeLibName = Marshal.GetTypeLibName((ITypeLib)typeLib);
// Create an instance of the custom attribute builder.
Object[] aArgs = new Object[1] {strTypeLibName};
CustomAttributeBuilder ImpFromComCABuilder = new CustomAttributeBuilder(ImpFromComAttrCons, aArgs);
// Set the ImportedFromTypeLibAttribute on the assembly builder.
asmBldr.SetCustomAttribute(ImpFromComCABuilder);
}
[System.Security.SecurityCritical] // auto-generated
private static void SetGuidAttributeOnAssembly(AssemblyBuilder asmBldr, Object typeLib)
{
// Retrieve the GuidAttribute constructor.
Type []aConsParams = new Type[1] {typeof(String)};
ConstructorInfo GuidAttrCons = typeof(GuidAttribute).GetConstructor(aConsParams);
// Create an instance of the custom attribute builder.
Object[] aArgs = new Object[1] {Marshal.GetTypeLibGuid((ITypeLib)typeLib).ToString()};
CustomAttributeBuilder GuidCABuilder = new CustomAttributeBuilder(GuidAttrCons, aArgs);
// Set the GuidAttribute on the assembly builder.
asmBldr.SetCustomAttribute(GuidCABuilder);
}
/// <summary>
/// Applies custom attributes to generated assembly.
/// </summary>
/// <param name="assembly">Dynamic assembly to apply attributes to.</param>
private void ApplyAssemblyAttributes(AssemblyBuilder assembly)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(ApplicationNameAttribute), applicationName));
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(ApplicationActivationAttribute), activationMode));
if (applicationId != null)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(ApplicationIDAttribute), applicationId));
}
if (description != null)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(DescriptionAttribute), description));
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(AssemblyDescriptionAttribute), description));
}
if (accessControl != null)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(accessControl));
}
if (applicationQueuing != null)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(applicationQueuing));
}
if (roles != null)
{
foreach (SecurityRoleAttribute role in roles)
{
assembly.SetCustomAttribute(ReflectionUtils.CreateCustomAttribute(typeof(SecurityRoleAttribute),
new object[] { role.Role }, role));
}
}
}
[Test] // DefineVersionInfoResource (String, String, String, String, String)
public void TestDefineVersionInfoResource2_Culture_NotSupported ()
{
AssemblyName aname = new AssemblyName ();
aname.CultureInfo = new CultureInfo ("nl-BE");
aname.Name = "lib";
aname.Version = new Version (3, 5, 7);
AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
aname, AssemblyBuilderAccess.RunAndSave,
tempDir);
// AssemblyCulture
Type attrType = typeof (AssemblyCultureAttribute);
ConstructorInfo ci = attrType.GetConstructor (new Type [] { typeof (String) });
CustomAttributeBuilder cab = new CustomAttributeBuilder (
ci, new object [1] { "doesnotexist" });
ab.SetCustomAttribute (cab);
ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
try {
ab.Save ("lib.dll");
Assert.Fail ("#A1");
} catch (ArgumentException ex) {
// Culture name doesnotexist is not supported
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#A5");
Assert.AreEqual ("name", ex.ParamName, "#A6");
}
ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname,
AssemblyBuilderAccess.RunAndSave, tempDir);
// AssemblyCulture
attrType = typeof (AssemblyCultureAttribute);
ci = attrType.GetConstructor (new Type [] { typeof (String) });
cab = new CustomAttributeBuilder (ci, new object [1] { "neutral" });
ab.SetCustomAttribute (cab);
ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
try {
ab.Save ("lib.dll");
Assert.Fail ("#B1");
} catch (ArgumentException ex) {
// Culture name neutral is not supported
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
Assert.IsTrue (ex.Message.IndexOf ("neutral") != -1, "#B5");
Assert.AreEqual ("name", ex.ParamName, "#B6");
}
}
// Make this assembly fully debuggable.
void AddDebuggable(AssemblyBuilder ab)
{
Type type = typeof(DebuggableAttribute);
ConstructorInfo ctor = type.GetConstructor(new [] { typeof(DebuggableAttribute.DebuggingModes) } );
CustomAttributeBuilder caBuilder = new CustomAttributeBuilder(ctor, new object[] {
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default });
ab.SetCustomAttribute(caBuilder);
}
void SetUpAssembly()
{
var outputFile = BuildOutputAssemblyName();
var asmName = CreateAssemblyName(outputFile);
var assemblyBuilderAccess = GetAssemblyBuilderAccess();
var targetDirectory = GetTargetDirectory(outputFile);
_asmBuilder = string.IsNullOrEmpty(targetDirectory)
? AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, assemblyBuilderAccess)
: AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, assemblyBuilderAccess, targetDirectory);
if (Parameters.Debug)
{
// ikvm tip: Set DebuggableAttribute to assembly before
// creating the module, to make sure Visual Studio (Whidbey)
// picks up the attribute when debugging dynamically generated code.
_asmBuilder.SetCustomAttribute(CreateDebuggableAttribute());
}
_asmBuilder.SetCustomAttribute(CreateRuntimeCompatibilityAttribute());
_moduleBuilder = _asmBuilder.DefineDynamicModule(asmName.Name, Path.GetFileName(outputFile), Parameters.Debug);
if (Parameters.Unsafe)
{
_asmBuilder.SetCustomAttribute(CreateSecurityPermissionAttribute("SkipVerification"));
_moduleBuilder.SetCustomAttribute(CreateUnverifiableCodeAttribute());
}
_sreResourceService = new SREResourceService (_asmBuilder, _moduleBuilder);
ContextAnnotations.SetAssemblyBuilder(Context, _asmBuilder);
Context.GeneratedAssemblyFileName = outputFile;
}
internal AssemblyBuilder InternalDefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, System.Security.Policy.Evidence evidence, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions, ref StackCrawlMark stackMark, IEnumerable<CustomAttributeBuilder> unsafeAssemblyAttributes)
{
lock (typeof(AssemblyBuilderLock))
{
AssemblyBuilder builder2;
if (name == null)
{
throw new ArgumentNullException("name");
}
if (((access != AssemblyBuilderAccess.Run) && (access != AssemblyBuilderAccess.Save)) && ((access != AssemblyBuilderAccess.RunAndSave) && (access != AssemblyBuilderAccess.ReflectionOnly)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) access }), "access");
}
if (name.KeyPair != null)
{
name.SetPublicKey(name.KeyPair.PublicKey);
}
if (evidence != null)
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
List<CustomAttributeBuilder> list = null;
DynamicAssemblyFlags none = DynamicAssemblyFlags.None;
if (unsafeAssemblyAttributes != null)
{
list = new List<CustomAttributeBuilder>(unsafeAssemblyAttributes);
foreach (CustomAttributeBuilder builder in list)
{
if (builder.m_con.DeclaringType == typeof(SecurityTransparentAttribute))
{
none |= DynamicAssemblyFlags.Transparent;
}
}
}
builder2 = new AssemblyBuilder((AssemblyBuilder) this.nCreateDynamicAssembly(name, evidence, ref stackMark, requiredPermissions, optionalPermissions, refusedPermissions, access, none)) {
m_assemblyData = new AssemblyBuilderData(builder2, name.Name, access, dir)
};
builder2.m_assemblyData.AddPermissionRequests(requiredPermissions, optionalPermissions, refusedPermissions);
if (list != null)
{
foreach (CustomAttributeBuilder builder3 in list)
{
builder2.SetCustomAttribute(builder3);
}
}
builder2.m_assemblyData.GetInMemoryAssemblyModule();
return builder2;
}
}
private static void SetImportedFromTypeLibAttrOnAssembly(AssemblyBuilder asmBldr, object typeLib)
{
Type[] types = new Type[] { typeof(string) };
ConstructorInfo constructor = typeof(ImportedFromTypeLibAttribute).GetConstructor(types);
string typeLibName = Marshal.GetTypeLibName((ITypeLib) typeLib);
object[] constructorArgs = new object[] { typeLibName };
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
private static void SetGuidAttributeOnAssembly(AssemblyBuilder asmBldr, object typeLib)
{
Type[] types = new Type[] { typeof(string) };
ConstructorInfo constructor = typeof(GuidAttribute).GetConstructor(types);
object[] constructorArgs = new object[] { Marshal.GetTypeLibGuid((ITypeLib) typeLib).ToString() };
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
[Test] // DefineVersionInfoResource (String, String, String, String, String)
public void TestDefineVersionInfoResource2_Culture_NotSupported ()
{
AssemblyName aname = new AssemblyName ();
aname.CultureInfo = new CultureInfo ("nl-BE");
aname.Name = "lib";
aname.Version = new Version (3, 5, 7);
AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
aname, AssemblyBuilderAccess.RunAndSave,
tempDir);
// AssemblyCulture
Type attrType = typeof (AssemblyCultureAttribute);
ConstructorInfo ci = attrType.GetConstructor (new Type [] { typeof (String) });
CustomAttributeBuilder cab = new CustomAttributeBuilder (
ci, new object [1] { "doesnotexist" });
ab.SetCustomAttribute (cab);
ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
try {
ab.Save ("lib.dll");
Assert.Fail ("#A1");
} catch (CultureNotFoundException ex) {
}
ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname,
AssemblyBuilderAccess.RunAndSave, tempDir);
// AssemblyCulture
attrType = typeof (AssemblyCultureAttribute);
ci = attrType.GetConstructor (new Type [] { typeof (String) });
cab = new CustomAttributeBuilder (ci, new object [1] { "neutral" });
ab.SetCustomAttribute (cab);
ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
try {
ab.Save ("lib.dll");
Assert.Fail ("#B1");
} catch (CultureNotFoundException ex) {
}
}
[System.Security.SecurityCritical] // auto-generated
private static void SetPIAAttributeOnAssembly(AssemblyBuilder asmBldr, Object typeLib)
{
IntPtr pAttr = IntPtr.Zero;
_TYPELIBATTR Attr;
ITypeLib pTLB = (ITypeLib)typeLib;
int Major = 0;
int Minor = 0;
// Retrieve the PrimaryInteropAssemblyAttribute constructor.
Type []aConsParams = new Type[2] {typeof(int), typeof(int)};
ConstructorInfo PIAAttrCons = typeof(PrimaryInteropAssemblyAttribute).GetConstructor(aConsParams);
// Retrieve the major and minor version from the typelib.
try
{
pTLB.GetLibAttr(out pAttr);
Attr = (_TYPELIBATTR)Marshal.PtrToStructure(pAttr, typeof(_TYPELIBATTR));
Major = Attr.wMajorVerNum;
Minor = Attr.wMinorVerNum;
}
finally
{
// Release the typelib attributes.
if (pAttr != IntPtr.Zero)
pTLB.ReleaseTLibAttr(pAttr);
}
// Create an instance of the custom attribute builder.
Object[] aArgs = new Object[2] {Major, Minor};
CustomAttributeBuilder PIACABuilder = new CustomAttributeBuilder(PIAAttrCons, aArgs);
// Set the PrimaryInteropAssemblyAttribute on the assembly builder.
asmBldr.SetCustomAttribute(PIACABuilder);
}
public void EmitAttribute (AssemblyBuilder builder)
{
if (ResolveBuilder ())
builder.SetCustomAttribute (cab);
}
private void EmitCustomAttributes(AssemblyBuilder assemblyBuilder, IEnumerable<Cci.ICustomAttribute> attributes)
{
foreach (var attribute in attributes)
{
assemblyBuilder.SetCustomAttribute(CreateCustomAttributeBuilder(attribute));
}
}
internal RegexTypeCompiler(AssemblyName an, CustomAttributeBuilder[] attribs, String resourceFile, Evidence evidence) {
new ReflectionPermission(PermissionState.Unrestricted).Assert();
try {
Debug.Assert(an != null, "AssemblyName should not be null");
_assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave, evidence);
_module = _assembly.DefineDynamicModule(an.Name + ".dll");
if (attribs != null) {
for (int i=0; i<attribs.Length; i++) {
_assembly.SetCustomAttribute(attribs[i]);
}
}
if (resourceFile != null) {
// unmanaged resources are not supported
throw new ArgumentOutOfRangeException("resourceFile");
}
}
finally {
CodeAccessPermission.RevertAssert();
}
}
void SetUpAssembly()
{
string fname = Parameters.OutputAssembly;
if (0 == fname.Length)
{
fname = CompileUnit.Modules[0].Name;
}
string outputFile = BuildOutputAssemblyName(fname);
AssemblyName asmName = CreateAssemblyName(outputFile);
_asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, GetAssemblyBuilderAccess(), GetTargetDirectory(outputFile));
if (Parameters.Debug)
{
// ikvm tip: Set DebuggableAttribute to assembly before
// creating the module, to make sure Visual Studio (Whidbey)
// picks up the attribute when debugging dynamically generated code.
_asmBuilder.SetCustomAttribute(CreateDebuggableAttribute());
}
_asmBuilder.SetCustomAttribute(CreateRuntimeCompatibilityAttribute());
_moduleBuilder = _asmBuilder.DefineDynamicModule(asmName.Name, Path.GetFileName(outputFile), Parameters.Debug);
_sreResourceService = new SREResourceService (_asmBuilder, _moduleBuilder);
ContextAnnotations.SetAssemblyBuilder(Context, _asmBuilder);
Context.GeneratedAssemblyFileName = outputFile;
}
[Test] // SetCustomAttribute (CustomAttributeBuilder)
public void TestSetCustomAttribute1 ()
{
Assembly a;
AssemblyName an;
AssemblyName check;
Attribute attr;
string filename;
an = new AssemblyName ();
an.Name = "TestSetCustomAttributeA";
ab = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Save, tempDir);
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
GetConstructor (new Type [] { typeof (string) }), new object [] { "1.2.3.4"}));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
GetConstructor (new Type [] { typeof (string) }), new object [] { "bar"}));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
new object [] { AssemblyHashAlgorithm.MD5 }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
GetConstructor (new Type [] { typeof (uint) }), new object [] { (uint)0xff }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).
GetConstructor (new Type [] { typeof (bool) }), new object [] { true }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (FooAttribute).
GetConstructor (Type.EmptyTypes), new object [0]));
ab.Save ("TestSetCustomAttributeA.dll");
filename = Path.Combine (tempDir, "TestSetCustomAttributeA.dll");
check = AssemblyName.GetAssemblyName (filename);
Assert.AreEqual (CultureInfo.InvariantCulture, check.CultureInfo, "#A1");
#if NET_2_0
Assert.AreEqual (AssemblyNameFlags.None, check.Flags, "#A2");
#else
Assert.AreEqual (AssemblyNameFlags.PublicKey, check.Flags, "#A2");
#endif
Assert.AreEqual ("TestSetCustomAttributeA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", check.FullName, "#A3");
#if NET_2_0
Assert.IsNull (check.GetPublicKey (), "#A4");
#else
Assert.AreEqual (new byte [0], check.GetPublicKey (), "#A4");
#endif
#if NET_2_0
Assert.AreEqual (new byte [0], check.GetPublicKeyToken (), "#A5");
#else
Assert.IsNull (check.GetPublicKeyToken (), "#A5");
#endif
Assert.AreEqual (AssemblyHashAlgorithm.SHA1, check.HashAlgorithm, "#A6");
Assert.IsNull (check.KeyPair, "#A7");
Assert.AreEqual ("TestSetCustomAttributeA", check.Name, "#A8");
#if NET_2_0
//Assert.AreEqual (ProcessorArchitecture.MSIL, check.ProcessorArchitecture, "#A9");
#endif
Assert.AreEqual (new Version (0, 0, 0, 0), check.Version, "#A10");
Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, check.VersionCompatibility, "#A11");
using (FileStream fs = File.OpenRead (filename)) {
byte [] buffer = new byte [fs.Length];
fs.Read (buffer, 0, buffer.Length);
a = Assembly.Load (buffer);
}
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
Assert.IsNotNull (attr, "#A12a");
Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#A12b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
Assert.IsNotNull (attr, "#A13a");
Assert.AreEqual ("bar", ((AssemblyCultureAttribute) attr).Culture, "#A13b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
Assert.IsNotNull (attr, "#A14a");
Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#A14b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
Assert.IsNotNull (attr, "#A15a");
Assert.AreEqual ((uint) 0xff, ((AssemblyFlagsAttribute) attr).Flags, "#A15b");
attr = Attribute.GetCustomAttribute (a, typeof (FooAttribute));
Assert.IsNotNull (attr, "#A16");
an = new AssemblyName ();
an.CultureInfo = new CultureInfo ("nl-BE");
an.Flags = AssemblyNameFlags.Retargetable;
an.Name = "TestSetCustomAttributeB";
#if NET_2_0
an.ProcessorArchitecture = ProcessorArchitecture.IA64;
#endif
an.Version = new Version (1, 3, 5, 7);
an.VersionCompatibility = AssemblyVersionCompatibility.SameDomain;
ab = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Save, tempDir);
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
GetConstructor (new Type [] { typeof (string) }), new object [] { "1.2.3.4" }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
GetConstructor (new Type [] { typeof (string) }), new object [] { "en-US" }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
new object [] { AssemblyHashAlgorithm.MD5 }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
GetConstructor (new Type [] { typeof (uint) }), new object [] { (uint) 0x0100 }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).
GetConstructor (new Type [] { typeof (bool) }), new object [] { true }));
ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (FooAttribute).
GetConstructor (Type.EmptyTypes), new object [0]));
ab.Save ("TestSetCustomAttributeB.dll");
filename = Path.Combine (tempDir, "TestSetCustomAttributeB.dll");
check = AssemblyName.GetAssemblyName (filename);
Assert.AreEqual ("nl-BE", check.CultureInfo.Name, "#B1");
#if NET_2_0
Assert.AreEqual (AssemblyNameFlags.Retargetable, check.Flags, "#B2");
#else
Assert.AreEqual (AssemblyNameFlags.PublicKey | AssemblyNameFlags.Retargetable, check.Flags, "#B2");
#endif
Assert.AreEqual ("TestSetCustomAttributeB, Version=1.3.5.7, Culture=nl-BE, PublicKeyToken=null, Retargetable=Yes", check.FullName, "#B3");
#if NET_2_0
Assert.IsNull (check.GetPublicKey (), "#B4");
#else
Assert.AreEqual (new byte [0], check.GetPublicKey (), "#B4");
#endif
#if NET_2_0
Assert.AreEqual (new byte [0], check.GetPublicKeyToken (), "#B5");
#else
Assert.IsNull (check.GetPublicKeyToken (), "#B5");
#endif
Assert.AreEqual (AssemblyHashAlgorithm.SHA1, check.HashAlgorithm, "#B6");
Assert.IsNull (check.KeyPair, "#B7");
Assert.AreEqual ("TestSetCustomAttributeB", check.Name, "#B8");
#if NET_2_0
//Assert.AreEqual (ProcessorArchitecture.MSIL, check.ProcessorArchitecture, "#B9");
#endif
Assert.AreEqual (new Version (1, 3, 5, 7), check.Version, "#B10");
Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, check.VersionCompatibility, "#B11");
using (FileStream fs = File.OpenRead (filename)) {
byte [] buffer = new byte [fs.Length];
fs.Read (buffer, 0, buffer.Length);
a = Assembly.Load (buffer);
}
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
Assert.IsNotNull (attr, "#B12a");
Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#B12b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
Assert.IsNotNull (attr, "#B13a");
Assert.AreEqual ("en-US", ((AssemblyCultureAttribute) attr).Culture, "#B13b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
Assert.IsNotNull (attr, "#B14a");
Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#B14b");
attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
Assert.IsNotNull (attr, "#B15a");
Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#B15b");
attr = Attribute.GetCustomAttribute (a, typeof (FooAttribute));
Assert.IsNotNull (attr, "#B16");
}
internal CodegenUnit(AssemblyName asmName)
{
var fileName = asmName.Name + ".dll";
var pdbName = asmName + ".pdb";
// so that we can run multiple tests at once and not lose the info
if (UnitTest.CurrentTest != null)
{
fileName = asmName + ", " + UnitTest.PersistentId + ".dll";
pdbName = asmName + ".pdb";
}
#if TRACE
try
{
_asm = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
_mod = _asm.DefineDynamicModule(fileName, true);
// Mark generated code as debuggable.
// See http://blogs.msdn.com/jmstall/archive/2005/02/03/366429.aspx for explanation.
var daCtor = typeof(DebuggableAttribute).GetConstructor(new []{typeof(DebuggableAttribute.DebuggingModes)});
var daBuilder = new CustomAttributeBuilder(daCtor, new object[] {
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default });
_asm.SetCustomAttribute(daBuilder);
// Mark generated code as non-user code.
// See http://stackoverflow.com/questions/1423733/how-to-tell-if-a-net-assembly-is-dynamic for explanation.
var cgCtor = typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes);
var cgBuilder = new CustomAttributeBuilder(cgCtor, new object []{});
_asm.SetCustomAttribute(cgBuilder);
var hasAlreadyBeenDumped = false;
Action dumpAssembly = () =>
{
if (!hasAlreadyBeenDumped && _asm != null)
{
try
{
// todo. before dumping make sure that all types are completed or else the dump will simply crash
// this is a complex task, but it needs to be resolved for generic case
_asm.Save(fileName);
}
catch (Exception ex)
{
var trace = String.Format("Codegen unit '{0}' has failed to dump the asm:{1}{2}",
asmName.FullName, Environment.NewLine, ex);
Log.WriteLine(trace);
SafetyTools.SafeDo(() =>
{
File.WriteAllText(fileName, trace);
File.Delete(pdbName);
});
}
finally
{
hasAlreadyBeenDumped = true;
}
}
};
_dumpAssembly = dumpAssembly;
// do not use DomainUnload here because it never gets fired for default domain
// however, we need not to neglect because R#'s unit-test runner never exits process
AppDomain.CurrentDomain.DomainUnload += (o, e) => dumpAssembly();
AppDomain.CurrentDomain.ProcessExit += (o, e) => dumpAssembly();
AppDomain.CurrentDomain.UnhandledException += (o, e) => dumpAssembly();
}
catch (Exception ex)
{
var trace = String.Format("Codegen unit '{0}' has failed to initialize:{1}{2}",
asmName.FullName, Environment.NewLine, ex);
Log.WriteLine(trace);
SafetyTools.SafeDo(() =>
{
File.WriteAllText(fileName, trace);
File.Delete(pdbName);
});
throw;
}
#else
_asm = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
_asm.SetCustomAttribute(new CustomAttributeBuilder(typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes), new object[] { }));
_mod = _asm.DefineDynamicModule(fileName, false);
#endif
}
private static void SetPIAAttributeOnAssembly(AssemblyBuilder asmBldr, object typeLib)
{
IntPtr nULL = Win32Native.NULL;
ITypeLib lib = (ITypeLib) typeLib;
int wMajorVerNum = 0;
int wMinorVerNum = 0;
Type[] types = new Type[] { typeof(int), typeof(int) };
ConstructorInfo constructor = typeof(PrimaryInteropAssemblyAttribute).GetConstructor(types);
try
{
lib.GetLibAttr(out nULL);
System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR) Marshal.PtrToStructure(nULL, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR));
wMajorVerNum = typelibattr.wMajorVerNum;
wMinorVerNum = typelibattr.wMinorVerNum;
}
finally
{
if (nULL != Win32Native.NULL)
{
lib.ReleaseTLibAttr(nULL);
}
}
object[] constructorArgs = new object[] { wMajorVerNum, wMinorVerNum };
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
private void InitDebugging()
{
if (!_debugEnabled)
{
return;
}
_debugText = new StringBuilder();
var instanceId = _parseCounter++;
_debugAssemblyName = $"BfAssembly{instanceId}";
_debugAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(_debugAssemblyName), AssemblyBuilderAccess.RunAndSave,
_debugTempPath);
var daType = typeof (DebuggableAttribute);
var daCtor = daType.GetConstructor(new[] {typeof (DebuggableAttribute.DebuggingModes)});
var daBuilder = new CustomAttributeBuilder(daCtor, new object[]
{
DebuggableAttribute.DebuggingModes.DisableOptimizations |
DebuggableAttribute.DebuggingModes.Default
});
_debugAssembly.SetCustomAttribute(daBuilder);
var module = _debugAssembly.DefineDynamicModule(_debugAssemblyName, true);
_debugType = module.DefineType($"BfType{instanceId}", TypeAttributes.Public);
//int[] memory, BfBuffer input, BfBuffer output
_debugMethod = _debugType.DefineMethod("Execute",
MethodAttributes.Public | MethodAttributes.Static,
typeof (void), new[] {typeof (int[]), typeof (BfStream), typeof (BfStream) });
_debugTempPath = Path.Combine(_debugTempPath, $"BfSource{instanceId}X.bf");
_debugSymbols = Expression.SymbolDocument(_debugTempPath);
}
internal static void SetUpAssemblyBuilderAttributes( AssemblyBuilder dedicatedAssemblyBuilder, bool isDebuggable )
{
if ( isDebuggable )
{
dedicatedAssemblyBuilder.SetCustomAttribute( new CustomAttributeBuilder( _debuggableAttributeCtor, _debuggableAttributeCtorArguments ) );
}
else
{
dedicatedAssemblyBuilder.SetCustomAttribute(
new CustomAttributeBuilder(
// ReSharper disable once AssignNullToNotNullAttribute
typeof( DebuggableAttribute ).GetConstructor( new[] { typeof( DebuggableAttribute.DebuggingModes ) } ),
new object[] { DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints }
)
);
}
dedicatedAssemblyBuilder.SetCustomAttribute(
new CustomAttributeBuilder(
// ReSharper disable once AssignNullToNotNullAttribute
typeof( System.Runtime.CompilerServices.CompilationRelaxationsAttribute ).GetConstructor( new[] { typeof( int ) } ),
new object[] { 8 }
)
);
#if !SILVERLIGHT && !NETFX_35
dedicatedAssemblyBuilder.SetCustomAttribute(
new CustomAttributeBuilder(
// ReSharper disable once AssignNullToNotNullAttribute
typeof( SecurityRulesAttribute ).GetConstructor( new[] { typeof( SecurityRuleSet ) } ),
new object[] { SecurityRuleSet.Level2 },
new[] { typeof( SecurityRulesAttribute ).GetProperty( "SkipVerificationInFullTrust" ) },
new object[] { true }
)
);
#endif // !SILVERLIGHT
}
private static void SetTypeLibVersionAttribute(AssemblyBuilder asmBldr, object typeLib)
{
int num;
int num2;
Type[] types = new Type[] { typeof(int), typeof(int) };
ConstructorInfo constructor = typeof(TypeLibVersionAttribute).GetConstructor(types);
Marshal.GetTypeLibVersion((ITypeLib) typeLib, out num, out num2);
object[] constructorArgs = new object[] { num, num2 };
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
