internal CustomAttributeData(ConstructorInfo constructor, object[] args, List<CustomAttributeNamedArgument> namedArguments)
{
this.lazyConstructor = constructor;
MethodSignature sig = constructor.MethodSignature;
List<CustomAttributeTypedArgument> list = new List<CustomAttributeTypedArgument>();
for (int i = 0; i < args.Length; i++)
{
list.Add(new CustomAttributeTypedArgument(sig.GetParameterType(i), args[i]));
}
lazyConstructorArguments = list.AsReadOnly();
if (namedArguments == null)
{
this.lazyNamedArguments = Empty<CustomAttributeNamedArgument>.Array;
}
else
{
this.lazyNamedArguments = namedArguments.AsReadOnly();
}
}
internal CustomAttributeData(Assembly asm, ConstructorInfo constructor, ByteReader br)
{
this.lazyConstructor = constructor;
if (br.Length == 0)
{
// it's legal to have an empty blob
lazyConstructorArguments = Empty<CustomAttributeTypedArgument>.Array;
lazyNamedArguments = Empty<CustomAttributeNamedArgument>.Array;
}
else
{
if (br.ReadUInt16() != 1)
{
throw new BadImageFormatException();
}
lazyConstructorArguments = ReadConstructorArguments(asm, br, constructor);
lazyNamedArguments = ReadNamedArguments(asm, br, br.ReadUInt16(), constructor.DeclaringType);
}
}
internal static void ReadDeclarativeSecurity(Module module, int index, List <CustomAttributeData> list)
{
Universe u = module.universe;
Assembly asm = module.Assembly;
int action = module.DeclSecurity.records[index].Action;
ByteReader br = module.GetBlob(module.DeclSecurity.records[index].PermissionSet);
if (br.PeekByte() == '.')
{
br.ReadByte();
int count = br.ReadCompressedUInt();
for (int j = 0; j < count; j++)
{
Type type = ReadType(module, br);
ConstructorInfo constructor = type.GetPseudoCustomAttributeConstructor(u.System_Security_Permissions_SecurityAction);
// LAMESPEC there is an additional length here (probably of the named argument list)
byte[] blob = br.ReadBytes(br.ReadCompressedUInt());
list.Add(new CustomAttributeData(asm, constructor, action, blob, index));
}
}
else
{
// .NET 1.x format (xml)
char[] buf = new char[br.Length / 2];
for (int i = 0; i < buf.Length; i++)
{
buf[i] = br.ReadChar();
}
string xml = new String(buf);
ConstructorInfo constructor = u.System_Security_Permissions_PermissionSetAttribute.GetPseudoCustomAttributeConstructor(u.System_Security_Permissions_SecurityAction);
List <CustomAttributeNamedArgument> args = new List <CustomAttributeNamedArgument>();
args.Add(new CustomAttributeNamedArgument(GetProperty(null, u.System_Security_Permissions_PermissionSetAttribute, "XML", u.System_String),
new CustomAttributeTypedArgument(u.System_String, xml)));
list.Add(new CustomAttributeData(asm.ManifestModule, constructor, new object[] { action }, args));
}
}
private CustomAttributeData(ConstructorInfo constructor, int securityAction, IList<CustomAttributeNamedArgument> namedArguments)
{
Universe u = constructor.Module.universe;
this.lazyConstructor = constructor;
List<CustomAttributeTypedArgument> list = new List<CustomAttributeTypedArgument>();
list.Add(new CustomAttributeTypedArgument(u.System_Security_Permissions_SecurityAction, securityAction));
this.lazyConstructorArguments = list.AsReadOnly();
this.lazyNamedArguments = namedArguments;
}
private static IList<CustomAttributeTypedArgument> ReadConstructorArguments(Module context, ByteReader br, ConstructorInfo constructor)
{
MethodSignature sig = constructor.MethodSignature;
int count = sig.GetParameterCount();
List<CustomAttributeTypedArgument> list = new List<CustomAttributeTypedArgument>(count);
for (int i = 0; i < count; i++)
{
list.Add(ReadFixedArg(context, br, sig.GetParameterType(i)));
}
return list.AsReadOnly();
}
void ReadConstructorArguments(StringBuilder sb, ByteReader br, ConstructorInfo constructor, int level)
{
bool first = true;
foreach (var parameter in constructor.GetParameters())
{
if (!first)
{
AppendNewLine(sb, level);
}
first = false;
ReadFixedArg(sb, br, parameter.ParameterType);
}
}
static void Process(ConstructorInfo ctorInfo)
{
foreach (var attr in ctorInfo.__GetCustomAttributes (TypeManager.AttributeType, false))
if (attr.AttributeType.FullName == "Mono.Embedding.ThunkAttribute")
Process(ctorInfo, TypeManager.VoidType, attr);
}
// 4) Pseudo Custom Attribute, .NET 1.x declarative security or result of CustomAttributeBuilder.ToData()
internal CustomAttributeData(Module module, ConstructorInfo constructor, List<CustomAttributeTypedArgument> constructorArgs, List<CustomAttributeNamedArgument> namedArguments)
{
this.module = module;
this.customAttributeIndex = -1;
this.declSecurityIndex = -1;
this.lazyConstructor = constructor;
lazyConstructorArguments = constructorArgs.AsReadOnly();
if (namedArguments == null)
{
this.lazyNamedArguments = Empty<CustomAttributeNamedArgument>.Array;
}
else
{
this.lazyNamedArguments = namedArguments.AsReadOnly();
}
}
internal ConstructorInfo GetSerializationConstructor()
{
if (baseSerializationCtor == null)
{
baseSerializationCtor = Serialization.AddAutomagicSerializationToWorkaroundBaseClass(typeBuilder, wrapper.BaseTypeWrapper.GetSerializationConstructor());
}
return baseSerializationCtor;
}
private static void LoadAll()
{
// Types
function = Load(typeof(TotemFunction));
value = Load(typeof(TotemValue));
tstring = Load(typeof(TotemString));
arguments = Load(typeof(TotemArguments));
parameter = Load(typeof(TotemParameter));
@bool = Load(typeof(TotemBool));
map = Load(typeof(TotemMap));
array = Load(typeof(TotemArray));
scope = Load(typeof(TotemFunction.ScopeWrapper));
arr_parameters = Load(typeof(TotemParameter[]));
sys_bool = Load(typeof(bool));
// Methods
value_val = Load(typeof(TotemValue)).GetProperty("ByTotemValue").GetGetMethod();
function_run = Load(typeof(TotemFunction)).GetMethod("TotemRun", r.BindingFlags.NonPublic | r.BindingFlags.Instance);
execute = Load(typeof(TotemValue)).GetMethod("Execute");
function_ctor = Load(typeof(TotemFunction)).GetConstructor(r.BindingFlags.NonPublic | r.BindingFlags.Instance, null, new IKType[] { Load(typeof(TotemScope)), Load(typeof(string)), Load(typeof(TotemParameter[])) }, null);
function_local_set = Load(typeof(TotemFunction)).GetMethod("LocalSet", r.BindingFlags.NonPublic | r.BindingFlags.Instance);
function_local_get = Load(typeof(TotemFunction)).GetMethod("LocalGet", r.BindingFlags.NonPublic | r.BindingFlags.Instance);
function_local_dec = Load(typeof(TotemFunction)).GetMethod("LocalDec", r.BindingFlags.NonPublic | r.BindingFlags.Instance);
function_env = Load(typeof(TotemFunction)).GetProperty("Scope", r.BindingFlags.NonPublic | r.BindingFlags.Instance).GetGetMethod(true);
arguments_ctor = Load(typeof(TotemArguments)).GetConstructor(IKType.EmptyTypes);
arguments_add = Load(typeof(TotemArguments)).GetMethod("Add", r.BindingFlags.Public | r.BindingFlags.Instance | r.BindingFlags.DeclaredOnly);
number_ctor_long = Load(typeof(TotemNumber)).GetConstructor(new IKType[] { Load(typeof(long)) });
string_ctor = Load(typeof(TotemString)).GetConstructor(new IKType[] { Load(typeof(string)) });
parameter_ctor = Load(typeof(TotemParameter)).GetConstructor(new IKType[] { Load(typeof(string)), Load(typeof(TotemValue)) });
undefined = Load(typeof(TotemValue)).GetProperty("Undefined").GetGetMethod();
@null = Load(typeof(TotemValue)).GetProperty("Null").GetGetMethod();
value_add = Load(typeof(TotemValue)).GetMethod("op_Addition", r.BindingFlags.Static | r.BindingFlags.Public);
value_sub = Load(typeof(TotemValue)).GetMethod("op_Subtraction", r.BindingFlags.Static | r.BindingFlags.Public);
value_mul = Load(typeof(TotemValue)).GetMethod("op_Multiply", r.BindingFlags.Static | r.BindingFlags.Public);
value_div = Load(typeof(TotemValue)).GetMethod("op_Division", r.BindingFlags.Static | r.BindingFlags.Public);
value_eq = Load(typeof(TotemValue)).GetMethod("op_Equality", r.BindingFlags.Static | r.BindingFlags.Public);
value_neq = Load(typeof(TotemValue)).GetMethod("op_Inequality", r.BindingFlags.Static | r.BindingFlags.Public);
value_lt = Load(typeof(TotemValue)).GetMethod("op_LessThan", r.BindingFlags.Static | r.BindingFlags.Public);
value_gt = Load(typeof(TotemValue)).GetMethod("op_GreaterThan", r.BindingFlags.Static | r.BindingFlags.Public);
value_lte = Load(typeof(TotemValue)).GetMethod("op_LessThanOrEqual", r.BindingFlags.Static | r.BindingFlags.Public);
value_gte = Load(typeof(TotemValue)).GetMethod("op_GreaterThanOrEqual", r.BindingFlags.Static | r.BindingFlags.Public);
value_incr = Load(typeof(TotemValue)).GetMethod("op_Increment", r.BindingFlags.Static | r.BindingFlags.Public);
value_decr = Load(typeof(TotemValue)).GetMethod("op_Decrement", r.BindingFlags.Static | r.BindingFlags.Public);
value_istrue = Load(typeof(TotemValue)).GetMethod("op_Explicit", r.BindingFlags.Static | r.BindingFlags.Public, null, r.CallingConventions.Standard, new IKType[] { Load(typeof(TotemValue)) }, null);
value_lookup_get = Load(typeof(TotemValue)).GetProperty("Item", value, new IKType[] { value }).GetGetMethod();
value_lookup_set = Load(typeof(TotemValue)).GetProperty("Item", value, new IKType[] { value }).GetSetMethod();
scope_ctor = Load(typeof(TotemFunction.ScopeWrapper)).GetConstructor(new IKType[] { Load(typeof(TotemFunction)) });
dispose = Load(typeof(IDisposable)).GetMethod("Dispose");
get_prop = Load(typeof(TotemValue)).GetMethod("GetProp");
set_prop = Load(typeof(TotemValue)).GetMethod("SetProp");
bool_ctor = Load(typeof(TotemBool)).GetConstructor(new IKType[] { Load(typeof(bool)) });
map_ctor = map.GetConstructor(IKType.EmptyTypes);
map_add = map.GetMethod("AddItem");
array_ctor = array.GetConstructor(IKType.EmptyTypes);
array_add = array.GetMethod("AddItem");
}
internal static void ReadDeclarativeSecurity(Assembly asm, List<CustomAttributeData> list, int action, ByteReader br)
{
Universe u = asm.universe;
if (br.PeekByte() == '.')
{
br.ReadByte();
int count = br.ReadCompressedInt();
for (int j = 0; j < count; j++)
{
Type type = ReadType(asm, br);
ConstructorInfo constructor;
if (type == u.System_Security_Permissions_HostProtectionAttribute && action == (int)System.Security.Permissions.SecurityAction.LinkDemand)
{
constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
}
else
{
constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { u.System_Security_Permissions_SecurityAction }, null);
}
// LAMESPEC there is an additional length here (probably of the named argument list)
ByteReader slice = br.Slice(br.ReadCompressedInt());
// LAMESPEC the count of named arguments is a compressed integer (instead of UInt16 as NumNamed in custom attributes)
list.Add(new CustomAttributeData(constructor, action, ReadNamedArguments(asm, slice, slice.ReadCompressedInt(), type)));
}
}
else
{
// .NET 1.x format (xml)
char[] buf = new char[br.Length / 2];
for (int i = 0; i < buf.Length; i++)
{
buf[i] = br.ReadChar();
}
string xml = new String(buf);
ConstructorInfo constructor = u.System_Security_Permissions_PermissionSetAttribute.GetConstructor(new Type[] { u.System_Security_Permissions_SecurityAction });
List<CustomAttributeNamedArgument> args = new List<CustomAttributeNamedArgument>();
args.Add(new CustomAttributeNamedArgument(u.System_Security_Permissions_PermissionSetAttribute.GetProperty("XML"),
new CustomAttributeTypedArgument(u.System_String, xml)));
list.Add(new CustomAttributeData(constructor, action, args));
}
}
internal static CustomAttributeData CreateDllImportPseudoCustomAttribute(Module module, ImplMapFlags flags, string entryPoint, string dllName, MethodImplAttributes attr)
{
Type type = module.universe.System_Runtime_InteropServices_DllImportAttribute;
ConstructorInfo constructor = type.GetPseudoCustomAttributeConstructor(module.universe.System_String);
List <CustomAttributeNamedArgument> list = new List <CustomAttributeNamedArgument>();
System.Runtime.InteropServices.CharSet charSet;
switch (flags & ImplMapFlags.CharSetMask)
{
case ImplMapFlags.CharSetAnsi:
charSet = System.Runtime.InteropServices.CharSet.Ansi;
break;
case ImplMapFlags.CharSetUnicode:
charSet = System.Runtime.InteropServices.CharSet.Unicode;
break;
case ImplMapFlags.CharSetAuto:
#if NETSTANDARD
charSet = (System.Runtime.InteropServices.CharSet) 4;
#else
charSet = System.Runtime.InteropServices.CharSet.Auto;
#endif
break;
case ImplMapFlags.CharSetNotSpec:
default:
#if NETSTANDARD
charSet = (System.Runtime.InteropServices.CharSet) 1;
#else
charSet = System.Runtime.InteropServices.CharSet.None;
#endif
break;
}
System.Runtime.InteropServices.CallingConvention callingConvention;
switch (flags & ImplMapFlags.CallConvMask)
{
case ImplMapFlags.CallConvCdecl:
callingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl;
break;
case ImplMapFlags.CallConvFastcall:
#if NETSTANDARD
callingConvention = (System.Runtime.InteropServices.CallingConvention) 5;
#else
callingConvention = System.Runtime.InteropServices.CallingConvention.FastCall;
#endif
break;
case ImplMapFlags.CallConvStdcall:
callingConvention = System.Runtime.InteropServices.CallingConvention.StdCall;
break;
case ImplMapFlags.CallConvThiscall:
callingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall;
break;
case ImplMapFlags.CallConvWinapi:
callingConvention = System.Runtime.InteropServices.CallingConvention.Winapi;
break;
default:
callingConvention = 0;
break;
}
AddNamedArgument(list, type, "EntryPoint", entryPoint);
AddNamedArgument(list, type, "CharSet", module.universe.System_Runtime_InteropServices_CharSet, (int)charSet);
AddNamedArgument(list, type, "ExactSpelling", (int)flags, (int)ImplMapFlags.NoMangle);
AddNamedArgument(list, type, "SetLastError", (int)flags, (int)ImplMapFlags.SupportsLastError);
AddNamedArgument(list, type, "PreserveSig", (int)attr, (int)MethodImplAttributes.PreserveSig);
AddNamedArgument(list, type, "CallingConvention", module.universe.System_Runtime_InteropServices_CallingConvention, (int)callingConvention);
AddNamedArgument(list, type, "BestFitMapping", (int)flags, (int)ImplMapFlags.BestFitOn);
AddNamedArgument(list, type, "ThrowOnUnmappableChar", (int)flags, (int)ImplMapFlags.CharMapErrorOn);
return(new CustomAttributeData(module, constructor, new object[] { dllName }, list));
}
private static IList <CustomAttributeTypedArgument> ReadConstructorArguments(Module context, ByteReader br, ConstructorInfo constructor)
{
MethodSignature sig = constructor.MethodSignature;
int count = sig.GetParameterCount();
List <CustomAttributeTypedArgument> list = new List <CustomAttributeTypedArgument>(count);
for (int i = 0; i < count; i++)
{
list.Add(ReadFixedArg(context, br, sig.GetParameterType(i)));
}
return(list.AsReadOnly());
}
internal ParameterInfoWrapper(ConstructorInfo ctor, ParameterInfo forward)
{
this.ctor = ctor;
this.forward = forward;
}
IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType, IUnresolvedMember accessorOwner)
{
if (method == null)
return null;
var m = new DefaultUnresolvedMethod(parentType, method.Name);
m.EntityType = methodType;
m.AccessorOwner = accessorOwner;
m.HasBody = method.GetMethodBody () != null;
var genericArguments = method.GetGenericArguments ();
if (genericArguments != null) {
for (int i = 0; i < genericArguments.Length; i++) {
if (genericArguments[i].GenericParameterPosition != i)
throw new InvalidOperationException("g.Position != i");
m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(
EntityType.Method, i, genericArguments[i].Name));
}
for (int i = 0; i < genericArguments.Length; i++) {
var tp = (DefaultUnresolvedTypeParameter)m.TypeParameters[i];
AddConstraints(tp, genericArguments[i]);
tp.ApplyInterningProvider(interningProvider);
}
}
m.ReturnType = KnownTypeReference.Void;
if (HasAnyAttributes(method))
AddAttributes(method, m.Attributes, m.ReturnTypeAttributes);
TranslateModifiers(method, m);
foreach (var p in method.GetParameters ()) {
m.Parameters.Add(ReadParameter(p));
}
FinishReadMember(m, method);
return m;
}
// 4) Pseudo Custom Attribute, .NET 1.x declarative security
internal CustomAttributeData(Module module, ConstructorInfo constructor, object[] args, List<CustomAttributeNamedArgument> namedArguments)
: this(module, constructor, WrapConstructorArgs(args, constructor.MethodSignature), namedArguments)
{
}
public IUnresolvedMethod ReadConstructor(ConstructorInfo method, IUnresolvedTypeDefinition parentType, EntityType methodType = EntityType.Method)
{
return ReadConstructor(method, parentType, methodType, null);
}
// 5) Unresolved declarative security
internal CustomAttributeData(Assembly asm, ConstructorInfo constructor, int securityAction, byte[] blob, int index)
{
this.module = asm.ManifestModule;
this.customAttributeIndex = -1;
this.declSecurityIndex = index;
Universe u = constructor.Module.universe;
this.lazyConstructor = constructor;
List<CustomAttributeTypedArgument> list = new List<CustomAttributeTypedArgument>();
list.Add(new CustomAttributeTypedArgument(u.System_Security_Permissions_SecurityAction, securityAction));
this.lazyConstructorArguments = list.AsReadOnly();
this.declSecurityBlob = blob;
}
static bool HasAnyAttributes(ConstructorInfo methodDefinition)
{
if (methodDefinition.Attributes.HasFlag (MethodAttributes.PinvokeImpl))
return true;
if (methodDefinition.MethodImplementationFlags.HasFlag (MethodImplAttributes.CodeTypeMask))
return true;
return methodDefinition.CustomAttributes.Any ();
}
bool DecodeCABlob(StringBuilder sb, ConstructorInfo constructor, byte[] blob, int level)
{
try
{
// CustomAttribute
var br = new ByteReader(blob, 2, blob.Length - 4);
ReadConstructorArguments(sb, br, constructor, level);
br = new ByteReader(blob, blob.Length - (br.Length + 2), br.Length + 2);
int named = br.ReadUInt16();
if (constructor.GetParameters().Length != 0 && named != 0)
{
AppendNewLine(sb, level);
}
ReadNamedArguments(sb, br, named, level, false);
return true;
}
catch (IKVM.Reflection.BadImageFormatException) { }
catch (ArgumentOutOfRangeException) { }
return false;
}
void AddAttributes(ConstructorInfo methodDefinition, IList<IUnresolvedAttribute> attributes, IList<IUnresolvedAttribute> returnTypeAttributes)
{
var implAttributes = methodDefinition.MethodImplementationFlags;
#region PreserveSigAttribute
if (implAttributes == MethodImplAttributes.PreserveSig) {
attributes.Add(preserveSigAttribute);
implAttributes = 0;
}
#endregion
#region MethodImplAttribute
if (implAttributes != MethodImplAttributes.IL) {
var methodImpl = new DefaultUnresolvedAttribute(methodImplAttributeTypeRef, new[] { methodImplOptionsTypeRef });
methodImpl.PositionalArguments.Add(CreateSimpleConstantValue(methodImplOptionsTypeRef, (int)implAttributes));
attributes.Add(interningProvider.Intern(methodImpl));
}
#endregion
AddCustomAttributes(methodDefinition.CustomAttributes, attributes);
if (methodDefinition.Attributes.HasFlag (MethodAttributes.HasSecurity)) {
AddSecurityAttributes(CustomAttributeData.__GetDeclarativeSecurity (methodDefinition), attributes);
}
}
internal ConstructorInfoWithReflectedType(Type reflectedType, ConstructorInfo ctor)
{
Debug.Assert(reflectedType != ctor.DeclaringType);
this.reflectedType = reflectedType;
this.ctor = ctor;
}
// 4) Pseudo Custom Attribute, .NET 1.x declarative security
internal CustomAttributeData(Module module, ConstructorInfo constructor, object[] args, List <CustomAttributeNamedArgument> namedArguments)
: this(module, constructor, WrapConstructorArgs(args, constructor.MethodSignature), namedArguments)
{
}