/// <summary>
/// Emits an array.
/// </summary>
/// <param name="generator"> The generator. </param>
/// <param name="arrayType"> Type of the array. </param>
/// <param name="emitElements"> The emit elements. </param>
public static void EmitArray(this ILGenerator generator, Type arrayType, IList<Action<ILGenerator>> emitElements)
{
var tLocal = generator.DeclareLocal(arrayType.MakeArrayType());
generator.Emit(OpCodes.Ldc_I4, emitElements.Count);
generator.Emit(OpCodes.Newarr, arrayType);
generator.EmitStoreLocation(tLocal.LocalIndex);
for (var i = 0; i < emitElements.Count; i++) {
generator.EmitLoadLocation(tLocal.LocalIndex);
generator.Emit(OpCodes.Ldc_I4, i);
emitElements[i](generator);
generator.Emit(OpCodes.Stelem_Ref);
}
generator.EmitLoadLocation(tLocal.LocalIndex);
}
internal Type MakeElementTypes(Type type)
{
for (int i = this.m_elementTypes.Length - 1; i >= 0; i--)
{
if (this.m_elementTypes[i] == 3)
{
type = type.MakeArrayType();
}
else
{
if (this.m_elementTypes[i] == 2)
{
type = type.MakeArrayType(this.m_elementTypes[--i]);
}
else
{
if (this.m_elementTypes[i] == 1)
{
type = type.MakePointerType();
}
else
{
if (this.m_elementTypes[i] == 4)
{
type = type.MakeByRefType();
}
}
}
}
}
return type;
}
internal Type Resolve(Type type)
{
if (_isBound)
return type.MakeArrayType(1);
else if (_dimensions == 1)
return type.MakeArrayType();
return type.MakeArrayType(_dimensions);
}
public Type Resolve (Type type)
{
if (bound)
return type.MakeArrayType (1);
else if (dimensions == 1)
return type.MakeArrayType ();
return type.MakeArrayType (dimensions);
}
private static object DeserializeArray(BinaryReader sourceReader, Type elementType, int elementSize, int elementCount)
{
var arrayDataAddress = sourceReader.BaseStream.Position;
var fields = elementType.Fields(
Flags.Public |
Flags.NonPublic |
Flags.Instance);
List<FieldDelegateInformation> fieldMethods;
var item = elementType.CreateInstance();
ProcessFieldTypes(fields, out fieldMethods);
var array = elementType.MakeArrayType().CreateInstance(elementCount);
for (var i = 0; i < elementCount; ++i)
{
var element = elementType.CreateInstance();
sourceReader.BaseStream.Position = arrayDataAddress + i * elementSize;
InvokeFields(sourceReader, element, fields, fieldMethods);
array.SetElement(i, element);
}
return array;
}
public static Type MakeArray (Type t, List<int> sizes, List<int> loBounds)
{
var mt = t as MetadataType;
if (mt != null) {
if (sizes == null) {
sizes = new List<int> ();
sizes.Add (1);
}
mt.m_arraySizes = sizes;
mt.m_arrayLoBounds = loBounds;
return mt;
}
if (sizes == null || sizes.Count == 1)
return t.MakeArrayType ();
return t.MakeArrayType (sizes.Capacity);
}
internal static System.Type RemapBaseType(System.Type type)
{
var typeMap = GetInheritedTypeMap();
int arrayDepth = 0;
System.Type currentType = type;
while (currentType.IsArray)
{
currentType = currentType.GetElementType();
++arrayDepth;
}
if (typeMap.ContainsKey(currentType))
{
type = typeMap[currentType];
while (arrayDepth-- > 0)
{
type = type.MakeArrayType();
}
}
return(type);
}
public static Type MakeArrayType(Type elementType)
{
#if CF
return Array.CreateInstance(elementType, 0).GetType(); // ouch
#else
return elementType.MakeArrayType();
#endif
}
/// <summary>
/// Builds <see cref="IArrayAccessor"/> for arrays with elements of type <paramref name="arrayElementType"/>.
/// </summary>
public static IArrayAccessor BuildForArrayOf(Type arrayElementType)
{
Guard.AgainstNull(arrayElementType, "arrayElementType");
Type arrayType = arrayElementType.MakeArrayType();
return new ArrayAccessor(arrayElementType, BuildGetMethod(arrayType, arrayElementType),
BuildSetMethod(arrayType, arrayElementType));
}
/// <summary>
/// Creates an array of the given type and stores it in a returned local.
/// </summary>
/// <param name="gen">The generator to inject the code into.</param>
/// <param name="type">The type of the array.</param>
/// <param name="size">The size of the array.</param>
/// <returns>A local builder that now contains the array.</returns>
public static LocalBuilder CreateArray(this ILGenerator gen, Type type, int size)
{
var ret = gen.DeclareLocal(type.MakeArrayType());
gen.Emit(OpCodes.Ldc_I4, size);
gen.Emit(OpCodes.Newarr, type);
gen.Emit(OpCodes.Stloc, ret);
return ret;
}
public static LocalBuilder CreateArray(this ILGenerator body, Type arrayType, int length)
{
var array = body.DeclareLocal(arrayType.MakeArrayType());
body.Emit(OpCodes.Ldc_I4, length);
body.Emit(OpCodes.Newarr, arrayType);
body.Emit(OpCodes.Stloc, array);
return array;
}
protected override System.Type MakeArrayType(ArrayTypeSlim type, System.Type elementType, int?rank)
{
var res = default(System.Type);
if (elementType != null)
{
if (rank == null)
{
res = elementType.MakeArrayType();
}
else
{
res = elementType.MakeArrayType(rank.Value);
}
}
return(res);
}
Type EmitArrayInitializer(Type ElementType, CodeExpression Expr, int Index)
{
Generator.Emit(OpCodes.Dup);
Generator.Emit(OpCodes.Ldc_I4, Index);
Type Generated = EmitExpression(Expr);
ForceTopStack(Generated, ElementType);
Generator.Emit(OpCodes.Stelem_Ref);
return ElementType.MakeArrayType();
}
protected void CheckReturnTypeCanBeSatisfiedByArrayOf(Type type)
{
var arrayType = type.MakeArrayType();
if (ComponentType.IsAssignableFrom(arrayType))
{
return;
}
ThrowUnsupportedCollectionType();
}
// Automatically infers the name of the symbol based on its type
// Used for intermediate values usually
public SymbolDefinition CreateUnnamedSymbol(string symbolType, SymbolDeclTypeFlags declType)
{
System.Type resolvedType = resolver.ResolveExternType(symbolType);
if (declType.HasFlag(SymbolDeclTypeFlags.Array))
{
resolvedType = resolvedType.MakeArrayType();
}
return(CreateUnnamedSymbol(resolvedType, declType));
}
protected virtual object StandardParse(string[] values, Type targetType, Type elementType)
{
var parser = StringParsing.GetParser(elementType);
var arr = Activator.CreateInstance(elementType.MakeArrayType(), values.Count());
for (var i = 0; i < values.Length; i++)
((Array)arr).SetValue(parser.Parse(values[i], elementType), i);
return arr;
}
internal Type MakeElementTypes(Type type)
{
for (int i = m_elementTypes.Length - 1; i >= 0; i --)
{
if (m_elementTypes[i] == SzArray)
{
type = type.MakeArrayType();
}
else if (m_elementTypes[i] == Array)
{
type = type.MakeArrayType(m_elementTypes[--i]);
}
else if ((m_elementTypes[i] == Pointer))
{
type = type.MakePointerType();
}
else if ((m_elementTypes[i] == ByRef))
{
type = type.MakeByRefType();
}
}
return type;
}
public CastElement(ExpressionElement castExpression, string[] destTypeParts, bool isArray, IServiceProvider services)
{
MyCastExpression = castExpression;
MyDestType = GetDestType(destTypeParts, services);
if (MyDestType == null) {
base.ThrowCompileException(CompileErrorResourceKeys.CouldNotResolveType, CompileExceptionReason.UndefinedName, GetDestTypeString(destTypeParts, isArray));
}
if (isArray == true) {
MyDestType = MyDestType.MakeArrayType();
}
if (this.IsValidCast(MyCastExpression.ResultType, MyDestType) == false) {
this.ThrowInvalidCastException();
}
}
/// <summary>
/// Create the QM Func Source starting from a pre-parsed bunch of header info.
/// </summary>
/// <param name="f"></param>
public QMFuncSource(QMFuncHeader f)
{
this._header = f;
Name = "QMFunction".CreateUniqueVariableName();
Arguments = f.Arguments.Select(a => new QMFunctionArgument(a));
StatementBlock = null;
// If this is a sequence, then we need to get a non-normal type.
if (_header.IsSequence)
{
_sequenceType = _header.QM.GetResultType().GetGenericArguments().First();
_sequenceType = _sequenceType.MakeArrayType();
}
// Now we can create the cached variables, etc.
CacheVariable = DeclarableParameter.CreateDeclarableParameterExpression(ResultType);
CacheVariableGood = DeclarableParameter.CreateDeclarableParameterExpression(typeof(bool));
}
public static System.Type GetFinalType(TypeKind typeKind, System.Type baseType)
{
if (typeKind != TypeKind.Simple)
{
if (typeKind != TypeKind.Array)
{
if (typeKind != TypeKind.List)
{
throw new ArgumentException("Internal error: got weird type kind");
}
System.Type[] typeArguments = new System.Type[] { baseType };
return(typeof(List <>).MakeGenericType(typeArguments));
}
}
else
{
return(baseType);
}
return(baseType.MakeArrayType());
}
public void SetKeys(ColorKey[] colorKeys, AlphaKey[] alphaKeys)
{
if (colorKeys != null)
{
Array colorKeyParam = (Array)Activator.CreateInstance(s_tyGradientColorKey.MakeArrayType(), new object[] { colorKeys.Length });
for (int i = 0; i < colorKeys.Length; ++i)
{
colorKeyParam.SetValue(Activator.CreateInstance(s_tyGradientColorKey, colorKeys[i].color, colorKeys[i].time), i);
}
s_piColorKeys.SetValue(_gradient, colorKeyParam, null);
}
if (alphaKeys != null)
{
Array alphaKeyParam = (Array)Activator.CreateInstance(s_tyGradientAlphaKey.MakeArrayType(), new object[] { alphaKeys.Length });
for (int i = 0; i < alphaKeys.Length; ++i)
{
alphaKeyParam.SetValue(Activator.CreateInstance(s_tyGradientAlphaKey, alphaKeys[i].alpha, alphaKeys[i].time), i);
}
s_piAlphaKeys.SetValue(_gradient, alphaKeyParam, null);
}
}
protected virtual Type GetType(string literalType, bool canBeNull)
{
bool isNullable = literalType.EndsWith("?");
if (isNullable)
{
literalType = literalType.Substring(0, literalType.Length - 1);
}
bool isArray = literalType.EndsWith("[]");
if (isArray)
{
literalType = literalType.Substring(0, literalType.Length - 2);
}
Type type = GetSimpleType(literalType);
if (type == null)
{
return(type);
}
if (isArray)
{
type = type.MakeArrayType();
}
if (isNullable)
{
type = typeof(Nullable <>).MakeGenericType(type);
}
else if (canBeNull)
{
if (type.IsValueType)
{
type = typeof(Nullable <>).MakeGenericType(type);
}
}
return(type);
}
private object ReadObject()
{
if (_reader.NodeType != JsonNodeType.Object)
{
throw new SerializationException("Failed to deserialize due to malformed json.");
}
_reader.Read();
if (_reader.NodeType != JsonNodeType.String || _reader.Name != ID_TYPE)
{
throw new SerializationException("Failed to deserialize due to malformed json: objects must contain a @type property.");
}
var tp = Type.GetType(_reader.Value as string);
if (tp == null)
{
tp = TypeUtil.FindType(_reader.Value as string, true);
}
if (tp == null)
{
throw new SerializationException("Failed to deserialize due to malformed json: objects must contain a @type property.");
}
object result;
ISerializationSurrogate surrogate;
ISurrogateSelector selector;
if (this.SurrogateSelector != null && (surrogate = this.SurrogateSelector.GetSurrogate(tp, this.Context, out selector)) != null)
{
var si = this.ReadAsSerializationInfo(tp);
try
{
result = surrogate.SetObjectData(FormatterServices.GetUninitializedObject(tp), si, this.Context, selector);
}
catch (System.Exception ex)
{
throw new SerializationException("Failed to deserialize.", ex);
}
}
else if (typeof(ISerializable).IsAssignableFrom(tp))
{
var si = this.ReadAsSerializationInfo(tp);
var constructor = GetSerializationConstructor(tp);
if (constructor == null)
{
throw new SerializationException("Failed to deserialize due to ISerializable type '" + tp.FullName + "' not implementing the appropriate constructor.");
}
try
{
result = constructor.Invoke(new object[] { si, this.Context });
}
catch (System.Exception ex)
{
throw new SerializationException("Failed to deserialize.", ex);
}
}
else
{
var members = FormatterServices.GetSerializableMembers(tp, Context);
var data = new object[members.Length];
while (_reader.Read())
{
switch (_reader.NodeType)
{
case JsonNodeType.None:
case JsonNodeType.EndArray:
throw new SerializationException("Failed to deserialize due to malformed json.");
case JsonNodeType.Object:
{
var nm = _reader.Name;
int i = GetIndexOfMemberName(members, nm);
if (i < 0)
{
this.ReadPastObject();
}
else
{
data[i] = this.ReadObject();
}
}
break;
case JsonNodeType.Array:
{
var nm = _reader.Name;
int i = GetIndexOfMemberName(members, nm);
if (i < 0)
{
this.ReadPastArray();
}
else
{
_reader.Read();
if (_reader.NodeType != JsonNodeType.String)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
System.Type arrayType = null;
try
{
var stp = _reader.Value as string;
//bool isArray = (stp != null && stp.EndsWith("[]"));
//if (isArray) stp = stp.Substring(0, stp.Length - 2);
//arrayType = Type.GetType(stp);
//if (arrayType == null) arrayType = TypeUtil.FindType(stp, true);
//if (arrayType != null && isArray) arrayType = arrayType.MakeArrayType();
if (string.IsNullOrEmpty(stp))
{
arrayType = null;
}
else if (stp.EndsWith("[]"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = arrayType.MakeArrayType();
}
}
else if (stp.EndsWith("<>"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = typeof(List <>).MakeGenericType(arrayType);
}
}
}
catch (System.Exception)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
if (arrayType == null)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
var innerType = arrayType.IsArray ? arrayType.GetElementType() : arrayType.GetGenericArguments()[0];
data[i] = this.ReadArray(nm, innerType, !arrayType.IsArray);
}
}
break;
case JsonNodeType.String:
case JsonNodeType.Number:
case JsonNodeType.Boolean:
case JsonNodeType.Null:
{
int i = GetIndexOfMemberName(members, _reader.Name);
if (i < 0)
{
this.ReadPastObject();
}
else
{
data[i] = ConvertJsonValueToType(_reader.Value, (members[i] as System.Reflection.FieldInfo).FieldType);
}
}
break;
case JsonNodeType.EndObject:
goto Result;
}
}
Result:
result = FormatterServices.GetUninitializedObject(tp);
FormatterServices.PopulateObjectMembers(result, members, data);
}
if (result is IDeserializationCallback)
{
(result as IDeserializationCallback).OnDeserialization(this);
}
return(result);
}
static CodeConditionStatement CreateArraySetValueCondition(Type type)
{
string lambda = type == typeof(decimal) ? "x => x.GetNumber()" :
type == typeof(bool) ? "x => x.GetBool()" :
type == typeof(string) ? "x => x.GetString()" :
string.Format("x => ({0})x.GetNumber()", type.FullName);
var toArray = CodeHelper
.Arg("srcObj")
.InvokeMethod("GetList")
.InvokeMethod("Select",
new CodeSnippetExpression(lambda))
.InvokeMethod("ToArray");
return CreateSetValueCondition(type.MakeArrayType(), toArray);
}
/// <summary>
/// Creates a <see cref="NewArrayExpression"/> that represents creating an array that has a specified rank.
/// </summary>
/// <param name="type">A <see cref="Type"/> that represents the element type of the array.</param>
/// <param name="bounds">An IEnumerable{T} that contains Expression objects to use to populate the Expressions collection.</param>
/// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="P:NodeType"/> property equal to type and the <see cref="P:Expressions"/> property set to the specified value.</returns>
public static NewArrayExpression NewArrayBounds(Type type, IEnumerable<Expression> bounds) {
ContractUtils.RequiresNotNull(type, "type");
ContractUtils.RequiresNotNull(bounds, "bounds");
if (type.Equals(typeof(void))) {
throw Error.ArgumentCannotBeOfTypeVoid();
}
ReadOnlyCollection<Expression> boundsList = bounds.ToReadOnly();
int dimensions = boundsList.Count;
if (dimensions <= 0) throw Error.BoundsCannotBeLessThanOne();
for (int i = 0; i < dimensions; i++) {
Expression expr = boundsList[i];
RequiresCanRead(expr, "bounds");
if (!TypeUtils.IsInteger(expr.Type)) {
throw Error.ArgumentMustBeInteger();
}
}
Type arrayType;
if (dimensions == 1) {
//To get a vector, need call Type.MakeArrayType().
//Type.MakeArrayType(1) gives a non-vector array, which will cause type check error.
arrayType = type.MakeArrayType();
} else {
arrayType = type.MakeArrayType(dimensions);
}
return NewArrayExpression.Make(ExpressionType.NewArrayBounds, arrayType, bounds.ToReadOnly());
}
public Type GetFrameworkType(TypeReference typeReference, bool isOptional)
{
if (typeReference.FullyQualifiedName != null)
{
var classType = TryGetClassType(typeReference.FullyQualifiedName);
if (classType != null)
{
return(classType);
}
var enumType = TryGetEnumType(typeReference.FullyQualifiedName);
if (enumType != null)
{
return(MakeNullableIfOptional(enumType));
}
var interfaceType = TryGetInterfaceType(typeReference.FullyQualifiedName);
if (interfaceType != null)
{
return(interfaceType);
}
throw new ArgumentException("Type reference has a fully qualified name, but is neither a class nor an enum", nameof(typeReference));
}
if (typeReference.Primitive != null)
{
switch (typeReference.Primitive)
{
case PrimitiveType.Any:
return(typeof(object));
case PrimitiveType.Boolean:
return(MakeNullableIfOptional(typeof(bool)));
case PrimitiveType.Date:
return(MakeNullableIfOptional(typeof(DateTime)));
case PrimitiveType.Json:
return(typeof(JObject));
case PrimitiveType.Number:
return(MakeNullableIfOptional(typeof(double)));
case PrimitiveType.String:
return(typeof(string));
default:
throw new ArgumentException($"Unknown primitive type {typeReference.Primitive}", nameof(typeReference));
}
}
if (typeReference.Collection != null)
{
Type elementType = GetFrameworkType(typeReference.Collection.ElementType, false);
switch (typeReference.Collection.Kind)
{
case CollectionKind.Array:
return(elementType.MakeArrayType());
case CollectionKind.Map:
return(typeof(IDictionary <,>).MakeGenericType(typeof(string), elementType));
default:
throw new ArgumentException($"Unknown collection kind {typeReference.Collection.Kind}", nameof(typeReference));
}
}
if (typeReference.Union != null)
{
return(typeof(object));
}
throw new ArgumentException("Invalid type reference", nameof(typeReference));
Type MakeNullableIfOptional(Type type)
{
return(isOptional ? typeof(Nullable <>).MakeGenericType(type) : type);
}
}
public static string SetGenericArgumentType(string serializedTypeString, Type type)
{
if (!IsGeneric(serializedTypeString))
{
if (IsBaseTypeGeneric(serializedTypeString))
{
throw new ArgumentException("Trying to set a different generic type. Reset old one first.");
}
throw new ArgumentException("Trying to set generic argument type for non generic type.");
}
SerializedTypeData data = SplitTypeString(serializedTypeString);
data.genericTypeName = data.typeName;
data.isGeneric = false;
switch (data.typeName)
{
case "T":
data.typeName = ToShortTypeName(type);
break;
case "T[]":
data.typeName = ToShortTypeName(type.MakeArrayType());
break;
default:
{
Type[] typeArguments = new Type[] { type };
data.typeName = ToShortTypeName(Type.GetType(data.typeName, true).GetGenericTypeDefinition().MakeGenericType(typeArguments));
break;
}
}
return ToString(data);
}
ObjectWriter CreateWriter(Type type)
{
if (type == typeof(string)) {
// String contents are written in the object creation section,
// not into the field value section.
return delegate {};
}
bool isArray = type.IsArray;
if (isArray) {
if (type.GetArrayRank() != 1)
throw new NotSupportedException();
type = type.GetElementType();
if (!type.IsValueType) {
return delegate (SerializationContext context, object array) {
foreach (object val in (object[])array) {
context.WriteObjectID(val);
}
};
} else if (type == typeof(byte)) {
return delegate (SerializationContext context, object array) {
context.writer.Write((byte[])array);
};
}
}
List<FieldInfo> fields = GetSerializableFields(type);
if (fields.Count == 0) {
// The writer has nothing to do for this object.
return delegate { };
}
DynamicMethod dynamicMethod = new DynamicMethod(
(isArray ? "WriteArray_" : "Write_") + type.Name,
typeof(void), new [] { typeof(SerializationContext), typeof(object) },
true);
ILGenerator il = dynamicMethod.GetILGenerator();
var writer = il.DeclareLocal(typeof(BinaryWriter));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, writerField);
il.Emit(OpCodes.Stloc, writer); // writer = context.writer;
if (isArray) {
var instance = il.DeclareLocal(type.MakeArrayType());
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type.MakeArrayType());
il.Emit(OpCodes.Stloc, instance); // instance = (type[])arg_1;
// for (int i = 0; i < instance.Length; i++) write instance[i];
var loopStart = il.DefineLabel();
var loopHead = il.DefineLabel();
var loopVariable = il.DeclareLocal(typeof(int));
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable = 0
il.Emit(OpCodes.Br, loopHead); // goto loopHead;
il.MarkLabel(loopStart);
if (type.IsEnum || type.IsPrimitive) {
if (type.IsEnum) {
type = type.GetEnumUnderlyingType();
}
Debug.Assert(type.IsPrimitive);
il.Emit(OpCodes.Ldloc, writer); // writer
il.Emit(OpCodes.Ldloc, instance); // writer, instance
il.Emit(OpCodes.Ldloc, loopVariable); // writer, instance, loopVariable
switch (Type.GetTypeCode(type)) {
case TypeCode.Boolean:
case TypeCode.SByte:
case TypeCode.Byte:
il.Emit(OpCodes.Ldelem_I1); // writer, instance[loopVariable]
il.Emit(callVirt, writeByte); // writer.Write(instance[loopVariable]);
break;
case TypeCode.Char:
case TypeCode.Int16:
case TypeCode.UInt16:
il.Emit(OpCodes.Ldelem_I2); // writer, instance[loopVariable]
il.Emit(callVirt, writeShort); // writer.Write(instance[loopVariable]);
break;
case TypeCode.Int32:
case TypeCode.UInt32:
il.Emit(OpCodes.Ldelem_I4); // writer, instance[loopVariable]
il.Emit(callVirt, writeInt); // writer.Write(instance[loopVariable]);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
il.Emit(OpCodes.Ldelem_I8); // writer, instance[loopVariable]
il.Emit(callVirt, writeLong); // writer.Write(instance[loopVariable]);
break;
case TypeCode.Single:
il.Emit(OpCodes.Ldelem_R4); // writer, instance[loopVariable]
il.Emit(callVirt, writeFloat); // writer.Write(instance[loopVariable]);
break;
case TypeCode.Double:
il.Emit(OpCodes.Ldelem_R8); // writer, instance[loopVariable]
il.Emit(callVirt, writeDouble); // writer.Write(instance[loopVariable]);
break;
default:
throw new NotSupportedException("Unknown primitive type " + type);
}
} else {
il.Emit(OpCodes.Ldloc, instance); // instance
il.Emit(OpCodes.Ldloc, loopVariable); // instance, loopVariable
il.Emit(OpCodes.Ldelem, type); // instance[loopVariable]
EmitWriteValueType(il, writer, type);
}
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldc_I4_1); // loopVariable, 1
il.Emit(OpCodes.Add); // loopVariable+1
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable++;
il.MarkLabel(loopHead);
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldloc, instance); // loopVariable, instance
il.Emit(OpCodes.Ldlen); // loopVariable, instance.Length
il.Emit(OpCodes.Conv_I4);
il.Emit(OpCodes.Blt, loopStart); // if (loopVariable < instance.Length) goto loopStart;
} else if (type.IsValueType) {
// boxed value type
if (type.IsEnum || type.IsPrimitive) {
il.Emit(OpCodes.Ldloc, writer);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Unbox_Any, type);
WritePrimitiveValue(il, type);
} else {
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Unbox_Any, type);
EmitWriteValueType(il, writer, type);
}
} else {
// reference type
var instance = il.DeclareLocal(type);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type);
il.Emit(OpCodes.Stloc, instance); // instance = (type)arg_1;
foreach (FieldInfo field in fields) {
EmitWriteField(il, writer, instance, field); // write instance.Field
}
}
il.Emit(OpCodes.Ret);
return (ObjectWriter)dynamicMethod.CreateDelegate(typeof(ObjectWriter));
}
ObjectScanner CreateScanner(Type type)
{
bool isArray = type.IsArray;
if (isArray) {
if (type.GetArrayRank() != 1)
throw new NotSupportedException();
type = type.GetElementType();
if (!type.IsValueType) {
return delegate (SerializationContext context, object array) {
foreach (object val in (object[])array) {
context.Mark(val);
}
};
}
}
for (Type baseType = type; baseType != null; baseType = baseType.BaseType) {
if (!baseType.IsSerializable)
throw new SerializationException("Type " + baseType + " is not [Serializable].");
}
List<FieldInfo> fields = GetSerializableFields(type);
fields.RemoveAll(f => !IsReferenceOrContainsReferences(f.FieldType));
if (fields.Count == 0) {
// The scanner has nothing to do for this object.
return delegate { };
}
DynamicMethod dynamicMethod = new DynamicMethod(
(isArray ? "ScanArray_" : "Scan_") + type.Name,
typeof(void), new [] { typeof(SerializationContext), typeof(object) },
true);
ILGenerator il = dynamicMethod.GetILGenerator();
if (isArray) {
var instance = il.DeclareLocal(type.MakeArrayType());
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type.MakeArrayType());
il.Emit(OpCodes.Stloc, instance); // instance = (type[])arg_1;
// for (int i = 0; i < instance.Length; i++) scan instance[i];
var loopStart = il.DefineLabel();
var loopHead = il.DefineLabel();
var loopVariable = il.DeclareLocal(typeof(int));
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable = 0
il.Emit(OpCodes.Br, loopHead); // goto loopHead;
il.MarkLabel(loopStart);
il.Emit(OpCodes.Ldloc, instance); // instance
il.Emit(OpCodes.Ldloc, loopVariable); // instance, loopVariable
il.Emit(OpCodes.Ldelem, type); // &instance[loopVariable]
EmitScanValueType(il, type);
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldc_I4_1); // loopVariable, 1
il.Emit(OpCodes.Add); // loopVariable+1
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable++;
il.MarkLabel(loopHead);
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldloc, instance); // loopVariable, instance
il.Emit(OpCodes.Ldlen); // loopVariable, instance.Length
il.Emit(OpCodes.Conv_I4);
il.Emit(OpCodes.Blt, loopStart); // if (loopVariable < instance.Length) goto loopStart;
} else if (type.IsValueType) {
// boxed value type
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Unbox_Any, type);
EmitScanValueType(il, type);
} else {
// reference type
var instance = il.DeclareLocal(type);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type);
il.Emit(OpCodes.Stloc, instance); // instance = (type)arg_1;
foreach (FieldInfo field in fields) {
EmitScanField(il, instance, field); // scan instance.Field
}
}
il.Emit(OpCodes.Ret);
return (ObjectScanner)dynamicMethod.CreateDelegate(typeof(ObjectScanner));
}
ObjectReader CreateReader(Type type)
{
if (type == typeof(string)) {
// String contents are written in the object creation section,
// not into the field value section; so there's nothing to read here.
return delegate {};
}
bool isArray = type.IsArray;
if (isArray) {
if (type.GetArrayRank() != 1)
throw new NotSupportedException();
type = type.GetElementType();
if (!type.IsValueType) {
return delegate (DeserializationContext context, object arrayInstance) {
object[] array = (object[])arrayInstance;
for (int i = 0; i < array.Length; i++) {
array[i] = context.ReadObject();
}
};
} else if (type == typeof(byte)) {
return delegate (DeserializationContext context, object arrayInstance) {
byte[] array = (byte[])arrayInstance;
BinaryReader binaryReader = context.Reader;
int pos = 0;
int bytesRead;
do {
bytesRead = binaryReader.Read(array, pos, array.Length - pos);
pos += bytesRead;
} while (bytesRead > 0);
if (pos != array.Length)
throw new EndOfStreamException();
};
}
}
var fields = GetSerializableFields(type);
if (fields.Count == 0) {
// The reader has nothing to do for this object.
return delegate { };
}
DynamicMethod dynamicMethod = new DynamicMethod(
(isArray ? "ReadArray_" : "Read_") + type.Name,
MethodAttributes.Public | MethodAttributes.Static,
CallingConventions.Standard,
typeof(void), new [] { typeof(DeserializationContext), typeof(object) },
type,
true);
ILGenerator il = dynamicMethod.GetILGenerator();
var reader = il.DeclareLocal(typeof(BinaryReader));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, readerField);
il.Emit(OpCodes.Stloc, reader); // reader = context.reader;
if (isArray) {
var instance = il.DeclareLocal(type.MakeArrayType());
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type.MakeArrayType());
il.Emit(OpCodes.Stloc, instance); // instance = (type[])arg_1;
// for (int i = 0; i < instance.Length; i++) read &instance[i];
var loopStart = il.DefineLabel();
var loopHead = il.DefineLabel();
var loopVariable = il.DeclareLocal(typeof(int));
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable = 0
il.Emit(OpCodes.Br, loopHead); // goto loopHead;
il.MarkLabel(loopStart);
if (type.IsEnum || type.IsPrimitive) {
if (type.IsEnum) {
type = type.GetEnumUnderlyingType();
}
Debug.Assert(type.IsPrimitive);
il.Emit(OpCodes.Ldloc, instance); // instance
il.Emit(OpCodes.Ldloc, loopVariable); // instance, loopVariable
ReadPrimitiveValue(il, reader, type); // instance, loopVariable, value
switch (Type.GetTypeCode(type)) {
case TypeCode.Boolean:
case TypeCode.SByte:
case TypeCode.Byte:
il.Emit(OpCodes.Stelem_I1); // instance[loopVariable] = value;
break;
case TypeCode.Char:
case TypeCode.Int16:
case TypeCode.UInt16:
il.Emit(OpCodes.Stelem_I2); // instance[loopVariable] = value;
break;
case TypeCode.Int32:
case TypeCode.UInt32:
il.Emit(OpCodes.Stelem_I4); // instance[loopVariable] = value;
break;
case TypeCode.Int64:
case TypeCode.UInt64:
il.Emit(OpCodes.Stelem_I8); // instance[loopVariable] = value;
break;
case TypeCode.Single:
il.Emit(OpCodes.Stelem_R4); // instance[loopVariable] = value;
break;
case TypeCode.Double:
il.Emit(OpCodes.Stelem_R8); // instance[loopVariable] = value;
break;
default:
throw new NotSupportedException("Unknown primitive type " + type);
}
} else {
il.Emit(OpCodes.Ldloc, instance); // instance
il.Emit(OpCodes.Ldloc, loopVariable); // instance, loopVariable
il.Emit(OpCodes.Ldelema, type); // instance[loopVariable]
EmitReadValueType(il, reader, type);
}
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldc_I4_1); // loopVariable, 1
il.Emit(OpCodes.Add); // loopVariable+1
il.Emit(OpCodes.Stloc, loopVariable); // loopVariable++;
il.MarkLabel(loopHead);
il.Emit(OpCodes.Ldloc, loopVariable); // loopVariable
il.Emit(OpCodes.Ldloc, instance); // loopVariable, instance
il.Emit(OpCodes.Ldlen); // loopVariable, instance.Length
il.Emit(OpCodes.Conv_I4);
il.Emit(OpCodes.Blt, loopStart); // if (loopVariable < instance.Length) goto loopStart;
} else if (type.IsValueType) {
// boxed value type
il.Emit(OpCodes.Ldarg_1); // instance
il.Emit(OpCodes.Unbox, type); // &(Type)instance
if (type.IsEnum || type.IsPrimitive) {
if (type.IsEnum) {
type = type.GetEnumUnderlyingType();
}
Debug.Assert(type.IsPrimitive);
ReadPrimitiveValue(il, reader, type); // &(Type)instance, value
switch (Type.GetTypeCode(type)) {
case TypeCode.Boolean:
case TypeCode.SByte:
case TypeCode.Byte:
il.Emit(OpCodes.Stind_I1);
break;
case TypeCode.Char:
case TypeCode.Int16:
case TypeCode.UInt16:
il.Emit(OpCodes.Stind_I2);
break;
case TypeCode.Int32:
case TypeCode.UInt32:
il.Emit(OpCodes.Stind_I4);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
il.Emit(OpCodes.Stind_I8);
break;
case TypeCode.Single:
il.Emit(OpCodes.Stind_R4);
break;
case TypeCode.Double:
il.Emit(OpCodes.Stind_R8);
break;
default:
throw new NotSupportedException("Unknown primitive type " + type);
}
} else {
EmitReadValueType(il, reader, type);
}
} else {
// reference type
var instance = il.DeclareLocal(type);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, type);
il.Emit(OpCodes.Stloc, instance); // instance = (type)arg_1;
foreach (FieldInfo field in fields) {
EmitReadField(il, reader, instance, field); // read instance.Field
}
}
il.Emit(OpCodes.Ret);
return (ObjectReader)dynamicMethod.CreateDelegate(typeof(ObjectReader));
}
/// <summary>
/// Creates a Generic List of type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static System.Array CreateGenericArrayInstance(this System.Type type, int size)
{
return((System.Array)Activator.CreateInstance(type.MakeArrayType(), size));
}
private SerializationInfo ReadAsSerializationInfo(System.Type tp)
{
var si = new SerializationInfo(tp, this.Converter);
while (_reader.Read())
{
switch (_reader.NodeType)
{
case JsonNodeType.None:
case JsonNodeType.EndArray:
throw new SerializationException("Failed to deserialize due to malformed json.");
case JsonNodeType.Object:
{
var nm = _reader.Name;
si.AddValue(nm, this.ReadObject());
}
break;
case JsonNodeType.Array:
{
var nm = _reader.Name;
_reader.Read();
if (_reader.NodeType != JsonNodeType.String)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
System.Type arrayType = null;
try
{
var stp = _reader.Value as string;
//bool isArray = (stp != null && stp.EndsWith("[]"));
//if (isArray) stp = stp.Substring(0, stp.Length - 2);
//arrayType = Type.GetType(stp);
//if (arrayType == null) arrayType = TypeUtil.FindType(stp, true);
//if (arrayType != null && isArray) arrayType = arrayType.MakeArrayType();
if (string.IsNullOrEmpty(stp))
{
arrayType = null;
}
else if (stp.EndsWith("[]"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = arrayType.MakeArrayType();
}
}
else if (stp.EndsWith("<>"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = typeof(List <>).MakeGenericType(arrayType);
}
}
}
catch (System.Exception)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
if (arrayType == null)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
var innerType = arrayType.IsArray ? arrayType.GetElementType() : arrayType.GetGenericArguments()[0];
si.AddValue(nm, this.ReadArray(nm, innerType, !arrayType.IsArray));
}
break;
case JsonNodeType.String:
case JsonNodeType.Number:
case JsonNodeType.Boolean:
case JsonNodeType.Null:
{
si.AddValue(_reader.Name, _reader.Value);
}
break;
case JsonNodeType.EndObject:
goto Result;
}
}
Result:
return(si);
}
/// <summary>
/// Creates a new array of the specified element type.
/// </summary>
/// <param name="ilGenerator">The intermediate language generator.</param>
/// <param name="elementType">The element type.</param>
/// <param name="size">The array size.</param>
/// <returns>The new array.</returns>
public static LocalBuilder NewArray(this ILGenerator ilGenerator, Type elementType, int size)
{
if (ilGenerator == null)
throw new ArgumentNullException("ilGenerator");
if (elementType == null)
throw new ArgumentNullException("elementType");
var localBuilder = ilGenerator.DeclareLocal(elementType.MakeArrayType());
ilGenerator.EmitLoadValue(size);
ilGenerator.Emit(OpCodes.Newarr, elementType);
ilGenerator.Emit(OpCodes.Stloc, localBuilder);
return localBuilder;
}
private object ReadArray(string nm, System.Type innerType, bool keepAsList)
{
var ltp = typeof(List <>);
ltp = ltp.MakeGenericType(innerType);
var lst = Activator.CreateInstance(ltp) as System.Collections.IList;
if (lst == null)
{
throw new SerializationException("Failed to deserialize due to malformed json.");
}
while (_reader.Read())
{
switch (_reader.NodeType)
{
case JsonNodeType.None:
case JsonNodeType.EndObject:
throw new SerializationException("Failed to deserialize due to malformed json.");
case JsonNodeType.Object:
{
lst.Add(ConvertJsonValueToType(this.ReadObject(), innerType));
}
break;
case JsonNodeType.Array:
{
_reader.Read();
if (_reader.NodeType != JsonNodeType.String)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
System.Type arrayType = null;
try
{
var stp = _reader.Value as string;
//bool isArray = (stp != null && stp.EndsWith("[]"));
//if (isArray) stp = stp.Substring(0, stp.Length - 2);
//arrayType = Type.GetType(stp);
//if (arrayType == null) arrayType = TypeUtil.FindType(stp, true);
//if (arrayType != null && isArray) arrayType = arrayType.MakeArrayType();
if (string.IsNullOrEmpty(stp))
{
arrayType = null;
}
else if (stp.EndsWith("[]"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = arrayType.MakeArrayType();
}
}
else if (stp.EndsWith("<>"))
{
stp = stp.Substring(0, stp.Length - 2);
arrayType = Type.GetType(stp);
if (arrayType == null)
{
arrayType = TypeUtil.FindType(stp, true);
}
if (arrayType != null)
{
arrayType = typeof(List <>).MakeGenericType(arrayType);
}
}
}
catch (System.Exception)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
if (arrayType == null)
{
throw new SerializationException("Failed to deserialize due to malformed json: array must begin with a @type string. (" + nm + ")");
}
var nextInnerType = arrayType.IsArray ? arrayType.GetElementType() : arrayType.GetGenericArguments()[0];
lst.Add(this.ReadArray("", nextInnerType, !arrayType.IsArray));
}
break;
case JsonNodeType.String:
case JsonNodeType.Number:
case JsonNodeType.Boolean:
case JsonNodeType.Null:
{
var obj = ConvertJsonValueToType(_reader.Value, innerType);
lst.Add(obj);
}
break;
case JsonNodeType.EndArray:
goto Result;
}
}
Result:
if (keepAsList)
{
return(lst);
}
else
{
var arr = Array.CreateInstance(innerType, lst.Count);
lst.CopyTo(arr, 0);
return(arr);
}
}
internal ArrayConverter(BclType elementType) : base(elementType.MakeArrayType())
{
_elementType = elementType;
}
static Type fixType(TypeReference typeReference, Type type)
{
while (typeReference is TypeSpecification) {
var ts = (TypeSpecification)typeReference;
if (typeReference is ArrayType) {
var arrayType = (ArrayType)typeReference;
if (arrayType.IsVector)
type = type.MakeArrayType();
else
type = type.MakeArrayType(arrayType.Rank);
}
else if (typeReference is ByReferenceType) {
type = type.MakeByRefType();
}
else if (typeReference is PointerType) {
type = type.MakePointerType();
}
else if (typeReference is GenericInstanceType) {
var git = (GenericInstanceType)typeReference;
var args = new Type[git.GenericArguments.Count];
bool isGenericTypeDef = true;
for (int i = 0; i < args.Length; i++) {
var typeRef = git.GenericArguments[i];
if (!(typeRef.GetElementType() is GenericParameter))
isGenericTypeDef = false;
args[i] = Resolver.resolve(typeRef);
}
if (!isGenericTypeDef)
type = type.MakeGenericType(args);
}
typeReference = ts.ElementType;
}
return type;
}
/// <summary>
/// Creates an array of the given type and stores it in a returned local.
/// </summary>
/// <param name="arrayType">The type of the array.</param>
/// <param name="size">The size of the array.</param>
/// <returns>A local builder that now contains the array.</returns>
public LocalBuilder CreateArray(Type arrayType, int size)
{
var ret = CreateTemporary(arrayType.MakeArrayType());
CurrentGenerator.Emit(OpCodes.Ldc_I4, size);
CurrentGenerator.Emit(OpCodes.Newarr, arrayType);
CurrentGenerator.Emit(OpCodes.Stloc, ret);
return ret;
}
/// <summary>
/// Return instances of all registered types requested.
/// </summary>
/// <remarks>
/// <para>
/// This method is useful if you've registered multiple types with the same
/// <see cref="Type"/> but different names.
/// </para>
/// <para>
/// Be aware that this method does NOT return an instance for the default (unnamed) registration.
/// </para>
/// </remarks>
/// <param name="t">The type requested.</param>
/// <param name="resolverOverrides">Any overrides for the resolve calls.</param>
/// <returns>Set of objects of type <paramref name="t"/>.</returns>
public IEnumerable<object> ResolveAll(Type t, params ResolverOverride[] resolverOverrides)
{
Guard.ArgumentNotNull(t, "t");
return (IEnumerable<object>)this.Resolve(t.MakeArrayType(), resolverOverrides);
}
/// <summary>
/// Creates a new array expression of the specified type from the provided initializers.
/// </summary>
/// <param name="type">A Type that represents the element type of the array.</param>
/// <param name="initializers">The expressions used to create the array elements.</param>
/// <returns>An instance of the <see cref="NewArrayExpression"/>.</returns>
public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression> initializers) {
ContractUtils.RequiresNotNull(type, "type");
ContractUtils.RequiresNotNull(initializers, "initializers");
if (type.Equals(typeof(void))) {
throw Error.ArgumentCannotBeOfTypeVoid();
}
ReadOnlyCollection<Expression> initializerList = initializers.ToReadOnly();
Expression[] newList = null;
for (int i = 0, n = initializerList.Count; i < n; i++) {
Expression expr = initializerList[i];
RequiresCanRead(expr, "initializers");
if (!TypeUtils.AreReferenceAssignable(type, expr.Type)) {
if (!TryQuote(type, ref expr)){
throw Error.ExpressionTypeCannotInitializeArrayType(expr.Type, type);
}
if (newList == null) {
newList = new Expression[initializerList.Count];
for (int j = 0; j < i; j++) {
newList[j] = initializerList[j];
}
}
}
if (newList != null) {
newList[i] = expr;
}
}
if (newList != null) {
initializerList = new TrueReadOnlyCollection<Expression>(newList);
}
return NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList);
}
private static Array GetArrayObj(ParamValue propertyValue, Type type, string guid, out int dimensions,
out Type arrayBaseType)
{
dimensions = type.FullName.Split(new[] { "[]" }, StringSplitOptions.None).Length - 1;
arrayBaseType = type.GetElementType();
for (int ii = 1; ii < dimensions; ii++)
{
arrayBaseType = arrayBaseType.GetElementType();
}
var parameterObject = arrayBaseType.MakeArrayType();
for (int ii = 1; ii < dimensions; ii++)
{
parameterObject = parameterObject.MakeArrayType();
}
List<int> arrayIndexes = propertyValue.ArrayIndexes.Select(o => o.Int).ToList();
Array aOo = Array.CreateInstance(arrayBaseType, arrayIndexes.ToArray());
int i = 0;
#region traverse array elements
foreach (var lElement in propertyValue.ArrayElements)
{
object arrayElementObj = GetArrayElementObject(arrayBaseType, guid, lElement);
List<int> indexes = new List<int>();
for (int ir = 0; ir < arrayIndexes.Count; ir++)
{
#region old logic, check if incorrect delete
//int tot = 0;
//for (int ri = arrayIndexes.Count - 1; ri > ir; ri--)
//{
// tot += arrayIndexes[ri];
//}
//if (tot == 0)
//{
// tot = arrayIndexes[arrayIndexes.Count - 1];
//}
//if (ir == arrayIndexes.Count - 1)
//{
// indexes.Add(i%tot);
//}
//else
//{
// indexes.Add(i/tot);
//}
#endregion
TestHelper.GetArrayIndexesFromLinearIndex(arrayIndexes, ir, indexes, i);
}
aOo.SetValue(arrayElementObj, indexes.ToArray());
i++;
}
#endregion
return aOo;
}
static System.Type ResolveType(string typeFullName, Dictionary <string, TypeBuilder> typeBuilders)
{
System.Type resolvedType = null;
if (typeFullName == "Java.Lang.Object")
{
return(typeof(object));
}
else if (typeFullName == "Android.Runtime.IJavaObject" ||
typeFullName == "Java.Interop.IJavaObjectEx")
{
// Classes bound to Java APIs implement these interfaces.
// It's safe to discard them in the portable assembly.
return(null);
}
else if (typeFullName == "Java.Util.IEventListener" ||
typeFullName == "Java.IO.ISerializable")
{
// IEventListener and ISerializable are just tagging interfaces with no methods,
// so they are save to discard.
return(null);
}
else if (typeFullName == "Java.Util.EventObject")
{
// EventObject is a base class for Java events. It has a getSource() method.
// TODO: Consider generating a GetSource() method when discarding this base class.
return(typeof(System.Object));
}
else if (typeFullName.EndsWith("]"))
{
////Log.Normal("Resolving array type " + typeFullName);
if (typeFullName.IndexOfAny(new char[] { '*', ',' }) >= 0 ||
typeFullName.IndexOf(']') < typeFullName.Length - 1)
{
throw new NotSupportedException("Multi-dimensional and jagged arrays are not supported.");
}
string elementTypeFullName = typeFullName.Substring(0, typeFullName.IndexOf('['));
System.Type elementType = ResolveType(elementTypeFullName, typeBuilders);
resolvedType = elementType.MakeArrayType();
}
else if (typeFullName.EndsWith(">"))
{
////Log.Normal("Resolving generic type " + typeFullName);
int ltIndex = typeFullName.IndexOf('<');
string genericArguments = typeFullName.Substring(ltIndex + 1, typeFullName.Length - ltIndex - 2);
IEnumerable <string> genericArgumentTypeFullNames = genericArguments.Split(',').Select(t => t.Trim());
System.Type[] genericArgumentTypes = genericArgumentTypeFullNames.Select(
t => ResolveType(t, typeBuilders)).ToArray();
string genericTypeDefinitionFullName = typeFullName.Substring(0, ltIndex) +
'`' + genericArgumentTypes.Length;
System.Type genericDefinition = ResolveType(genericTypeDefinitionFullName, typeBuilders);
resolvedType = genericDefinition.MakeGenericType(genericArgumentTypes);
}
else if (typeBuilders.ContainsKey(typeFullName))
{
////Log.Normal("Resolving type " + typeFullName + " from emitted module.");
TypeBuilder resolvedTypeBuilder;
typeBuilders.TryGetValue(typeFullName, out resolvedTypeBuilder);
resolvedType = resolvedTypeBuilder;
}
else if (!(typeFullName.StartsWith("Android.") || typeFullName.StartsWith("Java.")))
{
////Log.Normal("Resolving type " + typeFullName + " from BCL.");
resolvedType = System.Type.GetType(typeFullName, false);
if (resolvedType == null)
{
// Also check in the "System" assembly in addition to mscorlib.
resolvedType = typeof(System.Uri).Assembly.GetType(typeFullName, false);
}
}
if (resolvedType == null)
{
throw new InvalidOperationException("Failed to resolve type: " + typeFullName);
}
return(resolvedType);
}
static Type CreateArray (Type type, int rank)
{
return type.MakeArrayType (rank);
}
private object lua_NewArray(Type typ, int len)
{
return Activator.CreateInstance(typ.MakeArrayType(), len);
}
