protected ESSlot Compute(ESSlot slot1, ESSlot slot2, BinaryPrimitiveOpType binOperation)
{
ESSlot result = new ESSlot(ESSlotType.Val);
Object val1Converted = null;
Object val2Converted = null;
ClassToken resultToken = null;
PrimitiveType commonPrimType = default(PrimitiveType);
if (slot1.TypeToken == slot2.TypeToken && IsPrimaryType(slot1.TypeToken.PrimitiveType))
{
val1Converted = slot1.Val;
val2Converted = slot2.Val;
resultToken = slot1.TypeToken;
commonPrimType = resultToken.PrimitiveType;
}
else
{
//Get common primary type
commonPrimType = GetCommonPrimaryType(slot1.TypeToken.PrimitiveType, slot2.TypeToken.PrimitiveType);
//Convert slot vals
val1Converted = slot1.Val;
val2Converted = slot2.Val;
//val1Converted = GetConvertOperation(slot1.TypeToken.PrimitiveType, commonPrimType)(slot1.Val);
//val2Converted = GetConvertOperation(slot2.TypeToken.PrimitiveType, commonPrimType)(slot2.Val);
resultToken = GetTokenForPrimitive(commonPrimType);
}
result.Val = GetBinaryOperation(commonPrimType, binOperation)(val1Converted, val2Converted);
result.TypeToken = resultToken;
return(result);
}
public TypeObject GetTypeObject(ClassToken token)
{
TypeObject result = null;
_typeObjects.TryGetValue(token, out result);
return(result);
}
public bool FirstIsOfTypeOrDerivedFromSecond(ClassToken checkingClass, ClassToken targetClass)
{
var checking = _typesHeap.GetTypeObject(checkingClass);
if (checking == null)
{
throw new InvalidOperationException("Checking class has not been loaded");
}
return(checking.TypeDesc.IsOfTypeOrDerivedFrom(targetClass));
}
public EHTable AddCatchHandler(Int32 tryFrom, Int32 tryTo, ClassToken exToken, Int32 handlerFrom, Int32 handlerTo)
{
_table.Add(new EHTryEntity()
{
HandlerType = EHHandlerType.Catch,
TryOffset = tryFrom,
TryLength = tryTo - tryFrom,
ExceptionToken = exToken,
HandlerOffset = handlerFrom,
HandlerLength = handlerTo - handlerFrom,
Index = _currIndex++
});
return(this);
}
protected void EntryPointRet(ESSlot slot, ClassToken returnType)
{
Object result = null;
if ((returnType.IsPrimitive) && (!_primitiveOperations.IsPrimaryType(slot.TypeToken.PrimitiveType)))
{
result = _primitiveOperations.GetUnaryOperation(slot.TypeToken.PrimitiveType, UnaryPrimitiveOpType.GetStoreRep)(slot.Val);
}
else
{
result = slot.Val;
}
_setEntryPointRet(result);
}
public MethodLoader(MethodInfo methodInfo)
{
MethodInfo = methodInfo;
var mbody = MethodInfo.GetMethodBody();
RawInstructions = GetRawInstructionsFromBytes(mbody.GetILAsByteArray());
ILInstructions = ConvertRawInstructions(RawInstructions);
EHTable = CreateEHTable(mbody.ExceptionHandlingClauses);
Locals = ExtractLocals();
MaxStackSize = MethodInfo.GetMethodBody().MaxStackSize;
MethodName = MethodInfo.Name;
ReturnType = (MethodInfo.ReturnType != null) ? new ClassToken(MethodInfo.ReturnType) : null;
Arguments = ExtractArguments();
InheritanceAttributes = ExtractInheritanceAttrs();
Properties = ExtractProperties();
MemberAccessibility = ExtractMemberAccessibility();
}
public bool IsOfTypeOrDerivedFrom(ClassToken token)
{
bool result = false;
TypeDesc curr = this;
do
{
if (curr.Metadata.Equals(token))
{
result = true;
break;
}
else
{
curr = curr.BaseClass;
}
}while (curr != null);
return(result);
}
public EHTable AddCatchHandler(string tryFromLabel, string tryToLabel, ClassToken exToken, string handlerFromLabel, string handlerToLabel)
{
return(AddCatchHandler(_labelResolver.GetNumber(tryFromLabel), _labelResolver.GetNumber(tryToLabel), exToken, _labelResolver.GetNumber(handlerFromLabel), _labelResolver.GetNumber(handlerToLabel)));
}
public EHTryEntity GetCatchIfExists(Int32 instIndex, ClassToken exToken)
{
return(_table.Where(x => x.HandlerType == EHHandlerType.Catch).Where(x => x.ExceptionToken.Equals(exToken)).Where(x => x.IncludesInstruction(instIndex)).FirstOrDefault());
}
public bool TypeIsLoaded(ClassToken typeMetadata)
{
return(_typesHeap.ContainsType(typeMetadata));
}
public ESSlot(ESSlotType slotType, ClassToken typeToken)
{
SType = slotType;
TypeToken = typeToken;
}
private ClassToken GetClassTokenForType(Type type)
{
ClassToken token = new ClassToken(type);
return(token);
}
public bool ContainsType(ClassToken token)
{
return(_typeObjects.ContainsKey(token));
}
public void AddTypeObject(ClassToken token, TypeObject typeObject)
{
_typeObjects.Add(token, typeObject);
}
//public Int32 HeapObjAddr;
public TypeObject(ClassToken token, TypeDesc typeDesc, VTable vTable)
{
TypeDesc = typeDesc;
VTable = vTable;
Token = token;
}
public ExeptionInfo(ClassToken token, Int32 heapAddress)
{
Token = token;
HeapAddress = heapAddress;
}
public MethodDesc AddReturnType(ClassToken returnType)
{
//ReturnsValue = true;
ReturnType = returnType;
return(this);
}
