public void Update(RuntimicSystemModel semanticModel, SemanticTypeDefinitionMask_I semanticType)
{
if (semanticType == null || semanticType.Module == null || semanticType.Module.Assembly == null)
{
throw new System.ArgumentNullException();
}
var resolutionName = Execution.Conversion.Metadata.Members.Types.Naming.GetResolutionName(semanticType);
//var resolutionName2 = resolutionName.Replace("+", "/");
var node = Get(semanticModel, resolutionName);
//var node2 = Get(semanticModel, resolutionName2);
if (node == null)
{
throw new Exception("Expected an existing node.");
}
//if (node.SemanticType != null)
//{
// throw new Exception("More than one add called.");
//}
//node.SemanticType = semanticType;
throw new System.NotImplementedException();
}
public System.Type EnsureToType(ILConversion conversion, SemanticTypeDefinitionMask_I semanticType)
{
if (!(semanticType is BoundTypeDefinitionMask_I bound))
{
throw new Exception("A semantic type must be a bound type to be resolved to a runtime type.");
}
return(EnsureToType(conversion, bound));
}
private bool IfAlreadyCreatedReturn(SemanticTypeDefinitionMask_I elementType, int rank, out SemanticArrayTypeDefinitionMask_I existing)
{
if (elementType.Arrays.TryGetValue(rank, out existing))
{
return(true);
}
return(false);
}
public System.Type EnsureToType(SemanticTypeDefinitionMask_I semanticType, out BoundTypeDefinitionMask_I resultingBound)
{
// Can only build and bake types that are definitions. References cannot be turned into full types.
if (!(semanticType is BoundTypeDefinitionMask_I bound))
{
throw new Exception("A semantic type must be a bound type to be resolved to a runtime type.");
}
resultingBound = bound;
return(EnsureToType(bound));
}
public SemanticFieldMask_I Get(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
if (!(declaringType is SemanticTypeDefinitionWithFieldsMask_I typeWithFields))
{
throw new Exception("Trying to build a field on a type that does not support fields.");
}
if (typeWithFields.Fields.ByName.TryGetValue(fieldName, out SemanticFieldMask_I field))
{
return(field);
}
return(null);
}
public void Add(BoundRuntimicModelMask_I model, SemanticTypeDefinitionMask_I semantic, int arrayTypeRank)
{
throw new System.Exception("Debug");
//var resolutionName = Cecil.Types.Naming.GetResolutionName(semantic.SourceTypeReference);
//if (!model.Unified.Arrays.TryGetValue(resolutionName, out UnifiedArrayInstanceNodeSet set))
//{
// set = new UnifiedArrayInstanceNodeSet();
// model.Unified.Arrays.Add(resolutionName, set);
//}
// set.Instances.Add(new UnifiedArrayInstanceNode()
// {
// ElementResolutionName = resolutionName,
// Rank = arrayTypeRank,
// SemanticType = semantic
// });
}
public BoundTypeDefinitionMask_I Resolve(RuntimicSystemModel model, SemanticTypeDefinitionMask_I declaringType, GenericParameter parameter)
{
if (!declaringType.IsGeneric())
{
throw new Exception("Expected the resolved semantic type to be a generic type.");
}
SemanticGenericTypeDefinitionMask_I generic = (SemanticGenericTypeDefinitionMask_I)declaringType;
if (!generic.TypeParameters.ByName.TryGetValue(parameter.Name, out SemanticGenericParameterTypeDefinitionMask_I semanticTypeParameter))
{
throw new Exception($"Expected the generic type to have a type parameter named {parameter.Name}.");
}
if (!semanticTypeParameter.IsBound())
{
throw new Exception("Expected the generic parameter type to be a bound type.");
}
return((BoundTypeDefinitionMask_I)semanticTypeParameter);
}
public void ExtendWithCrossReference(RuntimicSystemModel model, SemanticTypeDefinitionMask_I semanticType, string assemblyQualifiedNameCrossReferenceKey)
{
var resolutionName = Execution.Conversion.Metadata.Members.Types.Naming.GetResolutionName(semanticType);
var orginalNode = Get(model, resolutionName);
if (orginalNode == null)
{
throw new Exception("Could not find orginal node. Could not add cross reference.");
}
//var entry = new UnifiedTypeNode()
//{
// ResolutionName = assemblyQualifiedNameCrossReferenceKey,
// SourceTypeReference = semanticType.SourceTypeReference,
// AssemblyNode = orginalNode.AssemblyNode,
// ModuleNode = orginalNode.ModuleNode,
// SemanticType = semanticType,
//};
//Add(model, entry);
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <param name="input"></param>
/// <param name="semanticType"></param>
/// <returns></returns>
/// <remarks>Used when ensuring a bound type and it needs to get the semanticType from the type reference as soon as it resolves the type to the type reference.</remarks>
public TypeReference GetTypeReference(RuntimicSystemModel model, Type input, out SemanticTypeDefinitionMask_I semanticType)
{
throw new System.Exception("Debug");
// string resolutionName = Binding.Metadata.Members.Types.Naming.GetResolutionName(input);
// TypeReference typeDefinition = Cecil.Types.Getting.GetStoredTypeReference(model, resolutionName, out UnifiedTypeNode basicNode);
// semanticType = basicNode?.SemanticType;
//if (typeDefinition != null) return typeDefinition;
// if (!input.IsGenericType)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericArguments = input.GenericTypeArguments;
// if (genericArguments.Length < 1)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericTypeDefinition = input.GetGenericTypeDefinition();
// var genericTypeDefinition1 = GetTypeReference(model, genericTypeDefinition);
// var genericArgumentReferences = new TypeReference[genericArguments.Length];
// for (int i = 0; i < genericArguments.Length; i++)
// {
// genericArgumentReferences[i] = GetTypeReference(model, genericArguments[i]);
// }
// var result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);
// return result;
}
public void Ensure(RuntimicSystemModel semanticModel, SemanticTypeDefinitionMask_I semanticType)
{
throw new System.Exception("Debug");
// if (semanticType == null)
// {
// throw new Exception("Cannot add a semantic type that is null");
// }
//string resolutionName = Types.Naming.GetResolutionName(semanticType);
// if (semanticType.Module.Assembly == null)
// {
// throw new Exception("Every semantic module should have a semantic assembly assigned to it.");
// }
// var entry = Unified.Types.Get(semanticModel, resolutionName);
// if (entry?.SemanticType == null)
// {
// Unified.Types.Update(semanticModel, semanticType);
// }
}
public BoundTypeDefinitionMask_I Resolve(RuntimicSystemModel model, SemanticTypeDefinitionMask_I declaringType,
MethodDefinition methodDefinition, GenericParameter parameter)
{
if (!(declaringType is BoundTypeDefinitionWithMethodsMask_I boundTypeWithMethods))
{
throw new Exception("Trying to add a method to a type that does not support methods.");
}
var method = Methods.FindMethodByDefinition(model, boundTypeWithMethods, methodDefinition);
if (!method.TypeParameters.ByName.TryGetValue(parameter.Name, out SemanticGenericParameterTypeDefinitionMask_I semanticTypeParameter))
{
throw new Exception(
$"Expected the generic method to have a type parameter named {parameter.Name}.");
}
if (!semanticTypeParameter.IsBound())
{
throw new Exception("Expected the generic parameter type to be a bound type.");
}
return((BoundTypeDefinitionMask_I)semanticTypeParameter);
}
public FieldInfo GetFieldInfo(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
// 1) First check the current type for the field.
var result = Get(model, declaringType, fieldName);
// 2.a) If not found, and is generic...
if (result == null && declaringType is BoundGenericTypeDefinitionMask_I bound)
{
// 2.b) Check the blueprint for the field as it might take generic parameters.
result = Get(model, bound.Blueprint, fieldName);
}
if (result == null)
{
return(null);
}
if (!(result is BoundFieldDefinitionMask_I field))
{
throw new Exception("Cannot get a field info from a field hat is not convertible to a BoundFieldMask_I.");
}
return(field.UnderlyingField);
}
public SemanticTypeMask_I Add(RuntimicSystemModel semanticModel, SemanticModuleMask_I module, SemanticTypeDefinitionMask_I entry)
{
Add(module.Types.ByResolutionName, entry);
Models.Types.Collection.Add(semanticModel, entry);
if (entry.IsDefinition() && entry is SemanticTypeDefinitionMask_I definitionMask)
{
Add(module.Types.DefinitionsByName, definitionMask);
//Models.Types.Ensure(semanticModel, definitionMask);
}
if (entry.IsReference() && entry is TypeReferenceMask_I referenceMask)
{
Add(module.Types.ReferencesByName, referenceMask);
}
return(entry);
}
public System.Type EnsureToType(SemanticTypeDefinitionMask_I semanticType)
{
return(EnsureToType(semanticType, out BoundTypeDefinitionMask_I resultingBound));
}
public bool TryGet(RuntimicSystemModel model, string resolutionName, out SemanticTypeDefinitionMask_I typeEntry)
{
typeEntry = Get(model, resolutionName);
return(typeEntry != null);
}
public bool TryGet(RuntimicSystemModel model, TypeReference input, out SemanticTypeDefinitionMask_I typeEntry)
{
string resolutionName = Types.Naming.GetResolutionName(input);
return(TryGet(model, resolutionName, out typeEntry));
}
public void EnsureTypes(ILConversion conversion, ConvertedTypeDefinition_I converted, MethodDefinition callingMethodDefinition, Collection <Instruction> instructions)
{
for (int i = 0; i < instructions.Count; i++)
{
var instructionDefinition = instructions[i];
switch (instructionDefinition.OpCode.Code)
{
case Libs.Mono.Cecil.Cil.Code.Add:
case Libs.Mono.Cecil.Cil.Code.Add_Ovf:
case Libs.Mono.Cecil.Cil.Code.Add_Ovf_Un:
case Libs.Mono.Cecil.Cil.Code.And:
case Libs.Mono.Cecil.Cil.Code.Arglist:
case Libs.Mono.Cecil.Cil.Code.Beq:
case Libs.Mono.Cecil.Cil.Code.Beq_S:
case Libs.Mono.Cecil.Cil.Code.Bge:
case Libs.Mono.Cecil.Cil.Code.Bge_S:
case Libs.Mono.Cecil.Cil.Code.Bge_Un:
case Libs.Mono.Cecil.Cil.Code.Bge_Un_S:
case Libs.Mono.Cecil.Cil.Code.Bgt:
case Libs.Mono.Cecil.Cil.Code.Bgt_S:
case Libs.Mono.Cecil.Cil.Code.Bgt_Un:
case Libs.Mono.Cecil.Cil.Code.Bgt_Un_S:
case Libs.Mono.Cecil.Cil.Code.Ble:
case Libs.Mono.Cecil.Cil.Code.Ble_S:
case Libs.Mono.Cecil.Cil.Code.Ble_Un:
case Libs.Mono.Cecil.Cil.Code.Ble_Un_S:
case Libs.Mono.Cecil.Cil.Code.Blt:
case Libs.Mono.Cecil.Cil.Code.Blt_S:
case Libs.Mono.Cecil.Cil.Code.Blt_Un:
case Libs.Mono.Cecil.Cil.Code.Blt_Un_S:
case Libs.Mono.Cecil.Cil.Code.Bne_Un:
case Libs.Mono.Cecil.Cil.Code.Bne_Un_S:
// Unconditional Branching - Long Form
case Libs.Mono.Cecil.Cil.Code.Br:
// Inserts an breakpoint into the IL stream - takes no parameters; does not touch the evaluation stack
case Libs.Mono.Cecil.Cil.Code.Break:
// Conditional Branching - Pop a value from evaluation stack and see if it is 0. If so, branch.
case Libs.Mono.Cecil.Cil.Code.Brfalse:
// Conditional Branching - Pop a value from evaluation stack and see if it is 0. If so, branch.
case Libs.Mono.Cecil.Cil.Code.Brfalse_S:
// Conditional Branching - Pop a value from evaluation stack and see if it is 1. If so, branch.
case Libs.Mono.Cecil.Cil.Code.Brtrue:
// Conditional Branching - Pop a value from evaluation stack and see if it is 1. If so, branch.
case Libs.Mono.Cecil.Cil.Code.Brtrue_S:
// Unconditional Branching - Short Form
case Libs.Mono.Cecil.Cil.Code.Br_S:
case Libs.Mono.Cecil.Cil.Code.Ceq:
case Libs.Mono.Cecil.Cil.Code.Cgt:
case Libs.Mono.Cecil.Cil.Code.Cgt_Un:
case Libs.Mono.Cecil.Cil.Code.Ckfinite:
case Libs.Mono.Cecil.Cil.Code.Clt:
case Libs.Mono.Cecil.Cil.Code.Clt_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_I:
case Libs.Mono.Cecil.Cil.Code.Conv_I1:
case Libs.Mono.Cecil.Cil.Code.Conv_I2:
case Libs.Mono.Cecil.Cil.Code.Conv_I4:
case Libs.Mono.Cecil.Cil.Code.Conv_I8:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I1:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I1_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I2:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I2_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I4:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I4_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I8:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I8_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_I_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U1:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U1_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U2:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U2_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U4:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U4_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U8:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U8_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_Ovf_U_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_R4:
case Libs.Mono.Cecil.Cil.Code.Conv_R8:
case Libs.Mono.Cecil.Cil.Code.Conv_R_Un:
case Libs.Mono.Cecil.Cil.Code.Conv_U:
case Libs.Mono.Cecil.Cil.Code.Conv_U1:
case Libs.Mono.Cecil.Cil.Code.Conv_U2:
case Libs.Mono.Cecil.Cil.Code.Conv_U4:
case Libs.Mono.Cecil.Cil.Code.Conv_U8:
case Libs.Mono.Cecil.Cil.Code.Cpblk:
case Libs.Mono.Cecil.Cil.Code.Div:
case Libs.Mono.Cecil.Cil.Code.Div_Un:
case Libs.Mono.Cecil.Cil.Code.Dup:
case Libs.Mono.Cecil.Cil.Code.Endfilter:
case Libs.Mono.Cecil.Cil.Code.Endfinally:
case Libs.Mono.Cecil.Cil.Code.Initblk:
case Libs.Mono.Cecil.Cil.Code.Ldarg:
case Libs.Mono.Cecil.Cil.Code.Ldarga:
case Libs.Mono.Cecil.Cil.Code.Ldarga_S:
case Libs.Mono.Cecil.Cil.Code.Ldarg_0:
case Libs.Mono.Cecil.Cil.Code.Ldarg_1:
case Libs.Mono.Cecil.Cil.Code.Ldarg_2:
case Libs.Mono.Cecil.Cil.Code.Ldarg_3:
case Libs.Mono.Cecil.Cil.Code.Ldarg_S:
// Constant Loading - Push the supplied integer value onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4:
// Constant Loading - Push the supplied integer value of 0 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_0:
// Constant Loading - Push the supplied integer value of 1 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_1:
// Constant Loading - Push the supplied integer value of 2 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_2:
// Constant Loading - Push the supplied integer value of 3 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_3:
// Constant Loading - Push the supplied integer value of 4 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_4:
// Constant Loading - Push the supplied integer value of 5 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_5:
// Constant Loading - Push the supplied integer value of 6 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_6:
// Constant Loading - Push the supplied integer value of 7 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_7:
// Constant Loading - Push the supplied integer value of 8 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_8:
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_M1:
case Libs.Mono.Cecil.Cil.Code.Ldc_I4_S:
case Libs.Mono.Cecil.Cil.Code.Ldc_I8:
case Libs.Mono.Cecil.Cil.Code.Ldc_R4:
case Libs.Mono.Cecil.Cil.Code.Ldc_R8:
case Libs.Mono.Cecil.Cil.Code.Leave:
case Libs.Mono.Cecil.Cil.Code.Leave_S:
case Libs.Mono.Cecil.Cil.Code.Ldelem_Any:
case Libs.Mono.Cecil.Cil.Code.Ldelem_I:
case Libs.Mono.Cecil.Cil.Code.Ldelem_I1:
case Libs.Mono.Cecil.Cil.Code.Ldelem_I2:
case Libs.Mono.Cecil.Cil.Code.Ldelem_I4:
case Libs.Mono.Cecil.Cil.Code.Ldelem_I8:
case Libs.Mono.Cecil.Cil.Code.Ldelem_R4:
case Libs.Mono.Cecil.Cil.Code.Ldelem_R8:
case Libs.Mono.Cecil.Cil.Code.Ldelem_Ref:
case Libs.Mono.Cecil.Cil.Code.Ldelem_U1:
case Libs.Mono.Cecil.Cil.Code.Ldelem_U2:
case Libs.Mono.Cecil.Cil.Code.Ldelem_U4:
//case Mono.Cecil.Cil.Code.Ldfld:
//case Mono.Cecil.Cil.Code.Ldflda:
//case Mono.Cecil.Cil.Code.Ldftn:
case Libs.Mono.Cecil.Cil.Code.Ldlen:
case Libs.Mono.Cecil.Cil.Code.Ldind_I:
case Libs.Mono.Cecil.Cil.Code.Ldind_I1:
case Libs.Mono.Cecil.Cil.Code.Ldind_I2:
case Libs.Mono.Cecil.Cil.Code.Ldind_I4:
case Libs.Mono.Cecil.Cil.Code.Ldind_I8:
case Libs.Mono.Cecil.Cil.Code.Ldind_R4:
case Libs.Mono.Cecil.Cil.Code.Ldind_R8:
case Libs.Mono.Cecil.Cil.Code.Ldind_Ref:
case Libs.Mono.Cecil.Cil.Code.Ldind_U1:
case Libs.Mono.Cecil.Cil.Code.Ldind_U2:
case Libs.Mono.Cecil.Cil.Code.Ldind_U4:
// Local Load - Push the local value at the location specified by the supplied short value onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc:
// Local Load - Push the address of the local value at the location specified by the supplied short value onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloca:
// Local Load - Push the address of the local value at the location specified by the supplied byte value onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloca_S:
// Local Load - Push the local value 0 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc_0:
// Local Load - Push the local value 0 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc_1:
// Local Load - Push the local value 0 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc_2:
// Local Load - Push the local value 0 onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc_3:
// Local Load - Push the local value at the location specified by the supplied byte value onto the stack
case Libs.Mono.Cecil.Cil.Code.Ldloc_S:
case Libs.Mono.Cecil.Cil.Code.Ldnull:
//case Mono.Cecil.Cil.Code.Ldsfld:
//case Mono.Cecil.Cil.Code.Ldsflda:
case Libs.Mono.Cecil.Cil.Code.Ldstr:
case Libs.Mono.Cecil.Cil.Code.Localloc:
case Libs.Mono.Cecil.Cil.Code.Mul:
case Libs.Mono.Cecil.Cil.Code.Mul_Ovf:
case Libs.Mono.Cecil.Cil.Code.Mul_Ovf_Un:
case Libs.Mono.Cecil.Cil.Code.Neg:
case Libs.Mono.Cecil.Cil.Code.Nop:
case Libs.Mono.Cecil.Cil.Code.Not:
case Libs.Mono.Cecil.Cil.Code.Pop:
case Libs.Mono.Cecil.Cil.Code.Or:
case Libs.Mono.Cecil.Cil.Code.Readonly:
case Libs.Mono.Cecil.Cil.Code.Refanytype:
case Libs.Mono.Cecil.Cil.Code.Rem:
case Libs.Mono.Cecil.Cil.Code.Rem_Un:
case Libs.Mono.Cecil.Cil.Code.Ret:
case Libs.Mono.Cecil.Cil.Code.Rethrow:
case Libs.Mono.Cecil.Cil.Code.Starg:
case Libs.Mono.Cecil.Cil.Code.Starg_S:
case Libs.Mono.Cecil.Cil.Code.Stelem_Any:
case Libs.Mono.Cecil.Cil.Code.Stelem_I:
case Libs.Mono.Cecil.Cil.Code.Stelem_I1:
case Libs.Mono.Cecil.Cil.Code.Stelem_I2:
case Libs.Mono.Cecil.Cil.Code.Stelem_I4:
case Libs.Mono.Cecil.Cil.Code.Stelem_I8:
case Libs.Mono.Cecil.Cil.Code.Stelem_R4:
case Libs.Mono.Cecil.Cil.Code.Stelem_R8:
case Libs.Mono.Cecil.Cil.Code.Stelem_Ref:
case Libs.Mono.Cecil.Cil.Code.Stind_I:
case Libs.Mono.Cecil.Cil.Code.Stind_I1:
case Libs.Mono.Cecil.Cil.Code.Stind_I2:
case Libs.Mono.Cecil.Cil.Code.Stind_I4:
case Libs.Mono.Cecil.Cil.Code.Stind_I8:
case Libs.Mono.Cecil.Cil.Code.Stind_R4:
case Libs.Mono.Cecil.Cil.Code.Stind_R8:
case Libs.Mono.Cecil.Cil.Code.Stind_Ref:
// Local Store - Pops the value on the stack and stores it in local location specified by the supplied short value onto the stack
case Libs.Mono.Cecil.Cil.Code.Stloc:
// Local Store - Pops the value on the stack and stores it in local 0
case Libs.Mono.Cecil.Cil.Code.Stloc_0:
// Local Store - Pops the value on the stack and stores it in local 1
case Libs.Mono.Cecil.Cil.Code.Stloc_1:
// Local Store - Pops the value on the stack and stores it in local 2
case Libs.Mono.Cecil.Cil.Code.Stloc_2:
// Local Store - Pops the value on the stack and stores it in local 3
case Libs.Mono.Cecil.Cil.Code.Stloc_3:
// Local Store - Pops the value on the stack and stores it in local location specified by the supplied byte value onto the stack
case Libs.Mono.Cecil.Cil.Code.Stloc_S:
case Libs.Mono.Cecil.Cil.Code.Shl:
case Libs.Mono.Cecil.Cil.Code.Shr:
case Libs.Mono.Cecil.Cil.Code.Shr_Un:
case Libs.Mono.Cecil.Cil.Code.Sub:
case Libs.Mono.Cecil.Cil.Code.Sub_Ovf:
case Libs.Mono.Cecil.Cil.Code.Sub_Ovf_Un:
case Libs.Mono.Cecil.Cil.Code.Switch:
case Libs.Mono.Cecil.Cil.Code.Tail:
case Libs.Mono.Cecil.Cil.Code.Throw:
case Libs.Mono.Cecil.Cil.Code.Unaligned:
case Libs.Mono.Cecil.Cil.Code.Volatile:
case Libs.Mono.Cecil.Cil.Code.Xor:
{
break;
}
default:
{
SemanticTypeDefinitionMask_I ensuredType = null;
TypeReference typeReferenceToLookup = null;
if (instructionDefinition.Operand is TypeReference typeReference)
{
//ensuredType = Types.Scanning.EnsureType(conversion, typeReference);
}
else if (instructionDefinition.Operand is FieldReference fieldReference)
{
//ensuredType = Types.Scanning.EnsureType(conversion, fieldReference.DeclaringType);
}
else if (instructionDefinition.Operand is MethodReference methodReference)
{
//if (methodReference is Mono.Cecil.GenericInstanceMethod genericMethodReference)
//{
// for (int j = 0; j < genericMethodReference.GenericArguments.Count; j++)
// {
// var genericArgument = genericMethodReference.GenericArguments[j];
// Types.Scanning.EnsureType(conversion, genericArgument);
// }
//}
//var resolvedMethodReference = Cecil.Metadata.Members.Methods.ResolveSignatureReferenceToFullReference(conversion.Model, converted.SourceTypeReference, callingMethodDefinition, methodReference);
//typeReferenceToLookup = resolvedMethodReference.DeclaringType;
}
else if (instructionDefinition.Operand is MemberReference memberReference)
{
//ensuredType = Types.Scanning.EnsureType(conversion, memberReference.DeclaringType);
}
else
{
throw new Exception("Instruction type scanning not handled.");
}
if (typeReferenceToLookup != null)
{
if (typeReferenceToLookup.IsGenericInstance && converted.SourceTypeReference.IsGenericInstance)
{
if (typeReferenceToLookup.FullName == "System.Collections.Generic.List`1<TOutput>")
{
}
var genericTypeReferenceToLookup = (GenericInstanceType)typeReferenceToLookup;
var genericConverted = (GenericInstanceType)converted.SourceTypeReference;
if (Cecil.Types.AreSame(genericTypeReferenceToLookup.ElementType, genericConverted.ElementType))
{
break;
}
}
ensuredType = Types.Scanning.EnsureType(conversion, typeReferenceToLookup);
if (ensuredType != null &&
ensuredType is ConvertedTypeDefinition_I convertedInstructionReference
// do not add if the instruction type is itself
&& !ReferenceEquals(convertedInstructionReference, converted)
// do not add if the instruction type's blueprint is itself
&& !(convertedInstructionReference is ConvertedGenericTypeDefinition_I genericInstructionType &&
ReferenceEquals(converted, genericInstructionType.Blueprint)) &&
convertedInstructionReference.ConversionState.BuildPhase != Code.Models.E01D.Runtimic.Execution.Conversion.Metadata.Members.Types.BuildPhaseKind.TypeCreated)
{
AddDependentOrDependency(convertedInstructionReference.ConversionState.Phase3Dependents, converted);
AddDependentOrDependency(converted.ConversionState.Phase3Dependencies, convertedInstructionReference);
}
}
break;
}
}
}
}
public void Add(RuntimicSystemModel semanticModel, SemanticTypeDefinitionMask_I semanticType)
{
Unified.Types.Update(semanticModel, semanticType);
}
public TypeReference GetTypeReference(RuntimicSystemModel model, Type input, out SemanticTypeDefinitionMask_I possibleSemanticType)
{
return(Infrastructure.Models.Semantic.Types.GetTypeReference(model, input, out possibleSemanticType));
}
public TypeReference GetTypeReference(ILConversion conversion, Type input, out SemanticTypeDefinitionMask_I possibleSemanticType)
{
return(Bound.Models.Types.GetTypeReference(conversion.RuntimicSystem, input, out possibleSemanticType));
}
public SemanticTypeDefinitionMask_I Ensure(ILConversion conversion, GenericInstanceType input, SemanticTypeDefinitionMask_I declaringType)
{
var typeArguments = Bound.Metadata.Members.TypeArguments.Building.Build(conversion.RuntimicSystem, input);
var blueprint = (BoundGenericTypeDefinitionMask_I)Execution.Types.Ensuring.EnsureBound(conversion, input.ElementType, null);
if (IfAlreadyCreatedReturn(blueprint, typeArguments, out SemanticTypeDefinitionMask_I ensure))
{
return(ensure);
}
var typeArgumentTypes = GetTypes(typeArguments, out bool hasGenericParameters);
var underlyingType = Bound.MakeGenericType(blueprint, typeArgumentTypes);
var converted = (ConvertedGenericTypeDefinition_I)Types.Creation.Create(conversion.RuntimicSystem, input);
converted.Blueprint = blueprint;
blueprint.Instances.Add(converted);
converted.UnderlyingType = underlyingType;
for (var j = 0; j < typeArguments.Length; j++)
{
var currentTypeArgument = typeArguments[j];
converted.TypeArguments.All.Add(currentTypeArgument);
}
Types.Building.UpdateBuildPhase(converted, BuildPhaseKind.TypeDefined);
Types.Building.IfPossibleBuildPhase2(conversion, converted);
return(converted);
}
private bool IfAlreadyCreatedReturn(BoundGenericTypeDefinitionMask_I genericBlueprint, BoundTypeDefinitionMask_I[] typeArgumentTypes, out SemanticTypeDefinitionMask_I ensure)
{
for (int i = 0; i < genericBlueprint.Instances.Count; i++)
{
var instance = genericBlueprint.Instances[i];
var currentInstance = (BoundGenericTypeDefinitionMask_I)instance;
var found = true;
for (var j = 0; j < currentInstance.TypeArguments.All.Count; j++)
{
var currentTypeArgument = currentInstance.TypeArguments.All[j];
if (ReferenceEquals(currentTypeArgument, typeArgumentTypes[j]))
{
continue;
}
found = false;
break;
}
if (found)
{
ensure = currentInstance;
return(true);
}
}
ensure = null;
return(false);
}
public TypeDefinition GetElementType(RuntimicSystemModel semanticModel, SemanticTypeDefinitionMask_I bound)
{
var genericInstanceType = (GenericInstanceType)bound.SourceTypeReference;
return(GetElementType(semanticModel, genericInstanceType));
}
public SemanticTypeDefinitionMask_I Ensure(ILConversion conversion, TypeReference input, SemanticTypeDefinitionMask_I declaringType)
{
ArrayType arrayType = (ArrayType)input;
var elementType = Execution.Types.Ensuring.Ensure(conversion.Model, arrayType.ElementType, null, null);
if (IfAlreadyCreatedReturn(elementType, arrayType.Rank, out SemanticArrayTypeDefinitionMask_I existing))
{
return(existing);
}
ConvertedTypeDefinition converted = Types.Creation.Create(conversion, input);
var arrayDef = (ConvertedArrayTypeDefinition_I)converted;
elementType.Arrays.Add(arrayType.Rank, arrayDef);
arrayDef.ElementType = elementType;
converted.BaseType = (BoundTypeDefinitionMask_I)Execution.Types.Ensuring.Ensure(conversion.Model, typeof(System.Array));
if (!(arrayDef.ElementType is BoundTypeDefinitionMask_I boundElementType))
{
throw new Exception("The element type is not a BoundTypeDefinitionMask_I. ");
}
if (arrayType.Rank == 1)
{
// Makes a vector
converted.UnderlyingType = boundElementType.UnderlyingType.MakeArrayType();
}
else
{
// Makes an multi-dimensional array
converted.UnderlyingType = boundElementType.UnderlyingType.MakeArrayType(arrayType.Rank);
}
Types.Building.UpdateBuildPhase(converted, BuildPhaseKind.TypeCreated);
return(converted);
}
//public TypeReference GetTypeReference(InfrastructureRuntimicModelMask_I model, Type input)
//{
// string resolutionName = Binding.Metadata.Members.Types.Naming.GetResolutionName(input);
// TypeReference typeDefinition = Collection.GetStoredTypeReference(model, resolutionName);
// if (typeDefinition != null) return typeDefinition;
// if (!input.IsGenericType)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericArguments = input.GenericTypeArguments;
// if (genericArguments.Length < 1)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericTypeDefinition = input.GetGenericTypeDefinition();
// var genericTypeDefinition1 = GetTypeReference(model, genericTypeDefinition);
// var genericArgumentReferences = new TypeReference[genericArguments.Length];
// for (int i = 0; i < genericArguments.Length; i++)
// {
// genericArgumentReferences[i] = GetTypeReference(model, genericArguments[i]);
// }
// var result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);
// return result;
//}
public Type ResolveToType(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I semanticType)
{
throw new Exception("resolving a semantic type to a run time is not supported. A semantic type is designed to be used to create runtime type. Right now automatic" +
"compile support is not present.");
}
public SemanticFieldMask_I Get(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
return(Semantic.Metadata.Members.Fields.Get(model, declaringType, fieldName));
}
public SemanticTypeMask_I Add(RuntimicSystemModel model, SemanticModuleMask_I module, SemanticTypeDefinitionMask_I entry)
{
// 1.) Add the semantic type to the module
// 1.a) Add by resolution name
Add(module.Types.ByResolutionName, entry);
// 1.b) Add by defintion name
Add(module.Types.DefinitionsByName, entry);
// 2) Add the semantic to type to the base class
// nothin to do right now
// 3) Add semantic type to model
Infrastructure.Models.Semantic.Types.Ensure(model, entry);
return(entry);
}
public FieldInfo GetFieldInfo(ILConversion conversion, SemanticTypeDefinitionMask_I declaringType, string fieldReferenceName)
{
// There is nothing that is conversion specific. Shoot the call downstream.
return(Bound.Metadata.Members.Fields.GetFieldInfo(conversion.Model, declaringType, fieldReferenceName));
}
public void AssignGenericBlueprint(ConvertedTypeDefinition createdType, SemanticTypeDefinitionMask_I genericBlueprint)
{
}
