/// <summary>
/// Appends a formatted parameters.
/// </summary>
protected virtual void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
{
IParameterDefinition def = param as IParameterDefinition;
if (def != null && (formattingOptions & NameFormattingOptions.ParameterModifiers) != 0)
{
if (def.IsOut)
{
sb.Append("out ");
}
else if (def.IsParameterArray)
{
sb.Append("params ");
}
else if (def.IsByReference)
{
sb.Append("ref ");
}
}
sb.Append(_typeNameFormatter.GetTypeName(param.Type, formattingOptions));
if (def != null && (formattingOptions & NameFormattingOptions.ParameterName) != 0)
{
sb.Append(" ");
sb.Append(def.Name.Value);
}
}
// Append "@" to a byref param's type
protected override void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
{
// HACK: This is to support CCI1 syntax where generic type arguments are not shown for nested types.
if (param.Type is INestedTypeReference)
{
formattingOptions = formattingOptions | NameFormattingOptions.OmitTypeArguments;
}
base.AppendParameter(param, (formattingOptions & ~NameFormattingOptions.OmitContainingType), sb);
if (param.IsByReference)
{
sb.Append('@');
}
if (param.IsModified)
{
int count = 0;
foreach (ICustomModifier modifier in param.CustomModifiers)
{
count++;
//if (count>1)
//{ throw new NotImplementedException("Can't create a signature with more than one custom modifier"); }
AppendCustomModifier(formattingOptions, sb, modifier);
}
}
}
private bool PassingObligationTo(IMethodReference method, IParameterTypeInformation p)
{
switch (method.Name.Value)
{
case "Add": return(true);
}
return(false);
}
public override void Visit(IParameterTypeInformation parameterTypeInformation)
{
if (Process(parameterTypeInformation))
{
visitor.Visit(parameterTypeInformation);
}
base.Visit(parameterTypeInformation);
}
public override BoogieType GetBoogieType(IParameterTypeInformation var)
{
if (var.IsByReference)
{
return(BoogieType.Addr);
}
return(GetBoogieType(var.Type));
}
public virtual void Visit(IParameterTypeInformation parameterTypeInformation)
{
if (parameterTypeInformation.IsModified)
{
this.Visit(parameterTypeInformation.CustomModifiers);
}
this.Visit(parameterTypeInformation.GetType(Context));
}
internal LockReplacer(SourceMethodBody sourceMethodBody) {
Contract.Requires(sourceMethodBody != null);
this.host = sourceMethodBody.host; Contract.Assume(sourceMethodBody.host != null);
this.sourceLocationProvider = sourceMethodBody.sourceLocationProvider;
this.numberOfReferencesToLocal = sourceMethodBody.numberOfReferencesToLocal; Contract.Assume(sourceMethodBody.numberOfReferencesToLocal != null);
this.numberOfAssignmentsToLocal = sourceMethodBody.numberOfAssignmentsToLocal; Contract.Assume(sourceMethodBody.numberOfAssignmentsToLocal != null);
this.bindingsThatMakeALastUseOfALocalVersion = sourceMethodBody.bindingsThatMakeALastUseOfALocalVersion; Contract.Assume(sourceMethodBody.bindingsThatMakeALastUseOfALocalVersion != null);
var systemThreading = new Immutable.NestedUnitNamespaceReference(this.host.PlatformType.SystemObject.ContainingUnitNamespace,
this.host.NameTable.GetNameFor("Threading"));
var systemThreadingMonitor = new Immutable.NamespaceTypeReference(this.host, systemThreading, this.host.NameTable.GetNameFor("Monitor"), 0,
isEnum: false, isValueType: false, typeCode: PrimitiveTypeCode.NotPrimitive);
var parameters = new IParameterTypeInformation[2];
this.monitorEnter = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Enter"), 0, parameters);
parameters[0] = new SimpleParameterTypeInformation(monitorEnter, 0, this.host.PlatformType.SystemObject);
parameters[1] = new SimpleParameterTypeInformation(monitorEnter, 1, this.host.PlatformType.SystemBoolean, isByReference: true);
this.monitorExit = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Exit"), 0, this.host.PlatformType.SystemObject);
}
internal LockReplacer(SourceMethodBody sourceMethodBody)
{
Contract.Requires(sourceMethodBody != null);
this.host = sourceMethodBody.host; Contract.Assume(sourceMethodBody.host != null);
this.sourceLocationProvider = sourceMethodBody.sourceLocationProvider;
this.numberOfReferencesToLocal = sourceMethodBody.numberOfReferencesToLocal; Contract.Assume(sourceMethodBody.numberOfReferencesToLocal != null);
this.numberOfAssignmentsToLocal = sourceMethodBody.numberOfAssignmentsToLocal; Contract.Assume(sourceMethodBody.numberOfAssignmentsToLocal != null);
this.bindingsThatMakeALastUseOfALocalVersion = sourceMethodBody.bindingsThatMakeALastUseOfALocalVersion; Contract.Assume(sourceMethodBody.bindingsThatMakeALastUseOfALocalVersion != null);
var systemThreading = new Immutable.NestedUnitNamespaceReference(this.host.PlatformType.SystemObject.ContainingUnitNamespace,
this.host.NameTable.GetNameFor("Threading"));
var systemThreadingMonitor = new Immutable.NamespaceTypeReference(this.host, systemThreading, this.host.NameTable.GetNameFor("Monitor"), 0,
isEnum: false, isValueType: false, typeCode: PrimitiveTypeCode.NotPrimitive);
var parameters = new IParameterTypeInformation[2];
this.monitorEnter = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Enter"), 0, parameters);
parameters[0] = new SimpleParameterTypeInformation(monitorEnter, 0, this.host.PlatformType.SystemObject);
parameters[1] = new SimpleParameterTypeInformation(monitorEnter, 1, this.host.PlatformType.SystemBoolean, isByReference: true);
this.monitorExit = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Exit"), 0, this.host.PlatformType.SystemObject);
}
public override void TraverseChildren(IParameterTypeInformation parameterTypeInformation) {
base.TraverseChildren(parameterTypeInformation);
}
public void Visit(IParameterTypeInformation parameterTypeInformation)
{
Contract.Assume(false);
}
/// <summary>
/// Traverses the parameter type information.
/// </summary>
public void Traverse(IParameterTypeInformation parameterTypeInformation)
{
Contract.Requires(parameterTypeInformation != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(parameterTypeInformation);
if (this.stopTraversal) return;
this.TraverseChildren(parameterTypeInformation);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(parameterTypeInformation);
}
public void Visit(IParameterTypeInformation parameterTypeInformation)
{
throw new NotImplementedException();
}
uint GetParameterTypeListInternId(IEnumerator<IParameterTypeInformation> parameterTypeInformations, uint pCount) {
Contract.Requires(parameterTypeInformations != null);
if (pCount == 0)
return 0;
IParameterTypeInformation[] paras = new IParameterTypeInformation[pCount];
uint i = 0;
while (parameterTypeInformations.MoveNext())
{
Contract.Assume(parameterTypeInformations.Current != null);
paras[i ++] = parameterTypeInformations.Current;
}
//Assert(i == pCount);
uint tailInternedId = 0;
while (i > 0)
{
i --;
uint currentParameterInternedId = this.GetParameterTypeInternId(paras[i]);
uint value = this.ParameterTypeListHashtable.Find(currentParameterInternedId, tailInternedId);
if (value == 0)
{
value = this.CurrentParameterTypeListInternValue++;
this.ParameterTypeListHashtable.Add(currentParameterInternedId, tailInternedId, value);
}
tailInternedId = value;
}
return tailInternedId;
}
public override void TraverseChildren(IParameterTypeInformation parameterTypeInformation)
{ MethodEnter(parameterTypeInformation);
base.TraverseChildren(parameterTypeInformation);
MethodExit(); }
/// <summary>
/// Performs some computation with the given parameter type information.
/// </summary>
public virtual void Visit(IParameterTypeInformation parameterTypeInformation)
{
}
/// <summary>
/// Rewrites the given parameter type information.
/// </summary>
public virtual IParameterTypeInformation Rewrite(IParameterTypeInformation parameterTypeInformation)
{
return parameterTypeInformation;
}
/// <summary>
/// Generates IL for the specified lock statement.
/// </summary>
/// <param name="lockStatement">The lock statement.</param>
public override void TraverseChildren(ILockStatement lockStatement)
{
if (this.host.SystemCoreAssemblySymbolicIdentity.Version.Major < 4) {
this.GenerateDownLevelLockStatement(lockStatement);
return;
}
var systemThreading = new NestedUnitNamespaceReference(this.host.PlatformType.SystemObject.ContainingUnitNamespace,
this.host.NameTable.GetNameFor("Threading"));
var systemThreadingMonitor = new NamespaceTypeReference(this.host, systemThreading, this.host.NameTable.GetNameFor("Monitor"), 0,
isEnum: false, isValueType: false, typeCode: PrimitiveTypeCode.NotPrimitive);
var parameters = new IParameterTypeInformation[2];
var monitorEnter = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Enter"), 0, parameters);
parameters[0] = new SimpleParameterTypeInformation(monitorEnter, 0, this.host.PlatformType.SystemObject);
parameters[1] = new SimpleParameterTypeInformation(monitorEnter, 1, this.host.PlatformType.SystemBoolean, isByReference: true);
var monitorExit = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Exit"), 0, this.host.PlatformType.SystemObject);
this.EmitSequencePoint(lockStatement.Locations);
var guardObject = new TemporaryVariable(lockStatement.Guard.Type, this.method);
var lockTaken = new TemporaryVariable(this.host.PlatformType.SystemBoolean, this.method);
//try
var savedCurrentTryCatch = this.currentTryCatch;
this.currentTryCatch = lockStatement;
var savedCurrentTryCatchFinallyEnd = this.currentTryCatchFinallyEnd;
this.currentTryCatchFinallyEnd = new ILGeneratorLabel();
this.generator.BeginTryBody();
this.Traverse(lockStatement.Guard);
this.generator.Emit(OperationCode.Dup); this.StackSize++;
this.VisitAssignmentTo(guardObject);
this.LoadAddressOf(lockTaken, null);
this.generator.Emit(OperationCode.Call, monitorEnter);
this.StackSize-=2;
this.Traverse(lockStatement.Body);
if (!this.lastStatementWasUnconditionalTransfer)
this.generator.Emit(OperationCode.Leave, this.currentTryCatchFinallyEnd);
//finally
this.generator.BeginFinallyBlock();
//if (status)
var endIf = new ILGeneratorLabel();
this.LoadLocal(lockTaken);
this.generator.Emit(OperationCode.Brfalse_S, endIf);
this.StackSize--;
this.LoadLocal(guardObject);
this.generator.Emit(OperationCode.Call, monitorExit);
this.StackSize--;
this.generator.MarkLabel(endIf);
//monitor exit
this.generator.Emit(OperationCode.Endfinally);
this.generator.EndTryBody();
this.generator.MarkLabel(this.currentTryCatchFinallyEnd);
this.currentTryCatchFinallyEnd = savedCurrentTryCatchFinallyEnd;
this.currentTryCatch = savedCurrentTryCatch;
this.lastStatementWasUnconditionalTransfer = false;
}
public override void Visit(IParameterTypeInformation parameterTypeInformation)
{
allElements.Add(new InvokInfo(Traverser, "IParameterTypeInformation", parameterTypeInformation));
}
uint GetParameterTypeInternId(IParameterTypeInformation parameterTypeInformation) {
Contract.Requires(parameterTypeInformation != null);
uint typeReferenceInternId = this.GetTypeReferenceInternId(parameterTypeInformation.Type);
uint customModifiersInternId = 0;
if (parameterTypeInformation.IsModified)
customModifiersInternId = this.GetCustomModifierListInternId(parameterTypeInformation.CustomModifiers.GetEnumerator());
foreach (ParameterTypeStore parameterTypeStore in this.ParameterTypeHashtable.GetValuesFor(typeReferenceInternId)) {
if (
parameterTypeStore.IsByReference == parameterTypeInformation.IsByReference
&& parameterTypeStore.CustomModifiersInternId == customModifiersInternId
) {
return parameterTypeStore.InternedId;
}
}
ParameterTypeStore parameterTypeStore1 = new ParameterTypeStore(parameterTypeInformation.IsByReference, customModifiersInternId, this.CurrentParameterTypeInternValue++);
this.ParameterTypeHashtable.Add(typeReferenceInternId, parameterTypeStore1);
return parameterTypeStore1.InternedId;
}
public bool TryGetParameterReference(CSharpParameter semanticParameter, ushort index, out IParameterTypeInformation cciParameter)
{
cciParameter = null;
#region Check input
if (semanticParameter == null)
{
return(false);
}
#endregion
#region Set up our working cci parameter
Microsoft.Cci.MutableCodeModel.ParameterTypeInformation workingParameter = null;
cciParameter = workingParameter = new Microsoft.Cci.MutableCodeModel.ParameterTypeInformation();
#endregion
#region Get our parameter type
ITypeReference paramType;
if (!TryGetTypeReference(semanticParameter.Type, out paramType))
{
goto ReturnFalse;
}
workingParameter.Type = paramType;
#endregion
#region Get our index
workingParameter.Index = index;
#endregion
#region Get our reference status
workingParameter.IsByReference = semanticParameter.IsOut || semanticParameter.IsRef;
#endregion
#region ReturnTrue:
//ReturnTrue:
return(cciParameter != Dummy.ParameterTypeInformation);
#endregion
#region ReturnFalse:
ReturnFalse:
if (semanticParameter.Name != null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to build parameter reference for: " + semanticParameter.Name.Text);
}
return(false);
#endregion
}
private MethodInfo GetGenericMethodFrom(IMethodReference methodReference, MemberInfo[] members) {
MethodInfo result = null;
var parameterCount = methodReference.ParameterCount;
var parameters = new IParameterTypeInformation[parameterCount];
int i = 0; foreach (var par in methodReference.Parameters) parameters[i++] = par;
var referencedMethodIsStatic = methodReference.IsStatic;
foreach (var member in members) {
var method = member as MethodInfo;
if (method == null || !method.IsGenericMethodDefinition) continue;
if (methodReference.GenericParameterCount != method.GetGenericArguments().Length) continue;
if (!this.CallingConventionsMatch(method, methodReference)) continue;
var mrtype = method.ReturnType;
if (methodReference.ReturnValueIsByRef) mrtype = mrtype.GetElementType();
if (!this.TypesMatch(methodReference.Type, mrtype, method)) continue;
if (methodReference.ReturnValueIsModified) {
if (!this.ModifiersMatch(method.ReturnParameter.GetOptionalCustomModifiers(), method.ReturnParameter.GetRequiredCustomModifiers(), methodReference.ReturnValueCustomModifiers)) continue;
}
var memberParameterInfos = method.GetParameters();
if (parameterCount != memberParameterInfos.Length) continue;
bool matched = true;
for (i = 0; i < parameterCount; i++) {
var mparInfo = memberParameterInfos[i];
var mparType = mparInfo.ParameterType;
var ipar = parameters[i];
if (ipar.IsByReference) mparType = mparType.GetElementType();
if (!this.TypesMatch(ipar.Type, mparType, method)) { matched = false; break; }
if (ipar.IsModified) {
if (!this.ModifiersMatch(mparInfo.GetOptionalCustomModifiers(), mparInfo.GetRequiredCustomModifiers(), ipar.CustomModifiers)) continue;
}
}
if (!matched) continue;
result = method;
break;
}
if (result != null)
this.methodMap.Add(methodReference.InternedKey, result);
return result;
}
private MethodInfo GetGenericMethodFrom(IMethodReference methodReference, MemberInfo[] members)
{
MethodInfo result = null;
var parameterCount = methodReference.ParameterCount;
var parameters = new IParameterTypeInformation[parameterCount];
int i = 0; foreach (var par in methodReference.Parameters)
{
parameters[i++] = par;
}
var referencedMethodIsStatic = methodReference.IsStatic;
foreach (var member in members)
{
var method = member as MethodInfo;
if (method == null || !method.IsGenericMethodDefinition)
{
continue;
}
if (methodReference.GenericParameterCount != method.GetGenericArguments().Length)
{
continue;
}
if (!this.CallingConventionsMatch(method, methodReference))
{
continue;
}
var mrtype = method.ReturnType;
if (methodReference.ReturnValueIsByRef)
{
mrtype = mrtype.GetElementType();
}
if (!this.TypesMatch(methodReference.Type, mrtype, method))
{
continue;
}
if (methodReference.ReturnValueIsModified)
{
if (!this.ModifiersMatch(method.ReturnParameter.GetOptionalCustomModifiers(), method.ReturnParameter.GetRequiredCustomModifiers(), methodReference.ReturnValueCustomModifiers))
{
continue;
}
}
var memberParameterInfos = method.GetParameters();
if (parameterCount != memberParameterInfos.Length)
{
continue;
}
bool matched = true;
for (i = 0; i < parameterCount; i++)
{
var mparInfo = memberParameterInfos[i];
var mparType = mparInfo.ParameterType;
var ipar = parameters[i];
if (ipar.IsByReference)
{
mparType = mparType.GetElementType();
}
if (!this.TypesMatch(ipar.Type, mparType, method))
{
matched = false; break;
}
if (ipar.IsModified)
{
if (!this.ModifiersMatch(mparInfo.GetOptionalCustomModifiers(), mparInfo.GetRequiredCustomModifiers(), ipar.CustomModifiers))
{
continue;
}
}
}
if (!matched)
{
continue;
}
result = method;
break;
}
if (result != null)
{
this.methodMap.Add(methodReference.InternedKey, result);
}
return(result);
}
public override void Visit(IParameterTypeInformation parameterTypeInformation)
{
if(Process(parameterTypeInformation)){visitor.Visit(parameterTypeInformation);}
base.Visit(parameterTypeInformation);
}
public virtual void Visit(IParameterTypeInformation parameterTypeInformation)
{
this.Visit(parameterTypeInformation.CustomModifiers);
this.Visit(parameterTypeInformation.GetType(Context));
}
public bool TryGetParameterReference(IParameterSymbol semanticParameter, ushort index, out IParameterTypeInformation cciParameter) {
cciParameter = null;
#region Check input
if (semanticParameter == null) {
return false;
}
#endregion
#region Set up our working cci parameter
Microsoft.Cci.MutableCodeModel.ParameterTypeInformation workingParameter = null;
cciParameter = workingParameter = new Microsoft.Cci.MutableCodeModel.ParameterTypeInformation();
#endregion
#region Get our parameter type
ITypeReference paramType;
if (!TryGetTypeReference(semanticParameter.Type, out paramType))
goto ReturnFalse;
workingParameter.Type = paramType;
#endregion
#region Get our index
workingParameter.Index = index;
#endregion
#region Get our reference status
workingParameter.IsByReference = semanticParameter.RefKind == RefKind.Out || semanticParameter.RefKind == RefKind.Ref;
#endregion
#region ReturnTrue:
//ReturnTrue:
return cciParameter != Dummy.ParameterTypeInformation;
#endregion
#region ReturnFalse:
ReturnFalse:
if (semanticParameter.Name != null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to build parameter reference for: " + semanticParameter.Name);
}
return false;
#endregion
}
protected IParameterTypeInformation[] GetModuleParameterTypeInformations(ISignature signature, int paramCount) {
var parameterTypes = new IParameterTypeInformation[paramCount];
for (var index = 0; index < paramCount; index++) {
bool dummyPinned;
var customModifiers = this.GetCustomModifiers(out dummyPinned);
byte currByte = this.SignatureMemoryReader.PeekByte(0);
if (currByte == ElementType.Sentinel) {
this.SignatureMemoryReader.SkipBytes(1);
if (index < paramCount) Array.Resize(ref parameterTypes, index);
break;
}
bool isByReference = false;
ITypeReference/*?*/ typeReference;
if (currByte == ElementType.TypedReference) {
this.SignatureMemoryReader.SkipBytes(1);
typeReference = this.PEFileToObjectModel.PlatformType.SystemTypedReference;
} else {
if (currByte == ElementType.ByReference) {
this.SignatureMemoryReader.SkipBytes(1);
isByReference = true;
}
typeReference = this.GetTypeReference();
}
var parameterType = new ParameterInfo(this.PEFileToObjectModel, index, customModifiers, typeReference, signature, isByReference);
parameterTypes[index] = parameterType;
}
return parameterTypes;
}
private MethodBase /*?*/ GetMethodFrom(Type containingType, IMethodReference methodReference, MemberInfo[] members)
{
//Generic methods need special treatment because their signatures refer to their generic parameters
//and we can't map those to types unless we can first map the generic method.
if (methodReference.IsGeneric)
{
return(this.GetGenericMethodFrom(methodReference, members));
}
MethodBase result = null;
var methodReturnType = this.GetType(methodReference.Type);
if (methodReturnType == null)
{
return(null);
}
if (methodReference.ReturnValueIsByRef)
{
methodReturnType = methodReturnType.MakeByRefType();
}
var parameterCount = methodReference.ParameterCount;
var parameters = new IParameterTypeInformation[parameterCount];
var parameterTypes = parameterCount == 0 ? null : new Type[parameterCount];
int parameterIndex = 0;
foreach (var parameter in methodReference.Parameters)
{
parameters[parameterIndex] = parameter;
var ptype = this.GetType(parameter.Type);
if (ptype == null)
{
return(null);
}
if (parameter.IsByReference)
{
ptype = ptype.MakeByRefType();
}
parameterTypes[parameterIndex++] = ptype;
}
foreach (var member in members)
{
var methodBase = member as MethodBase;
if (methodBase == null || methodBase.IsGenericMethodDefinition)
{
continue;
}
if (!this.CallingConventionsMatch(methodBase, methodReference))
{
continue;
}
if (methodBase.IsConstructor)
{
if (methodReference.Type.TypeCode != PrimitiveTypeCode.Void)
{
continue;
}
}
else
{
var method = (MethodInfo)methodBase;
if (!AreEquivalient(containingType, method.ReturnType, methodReturnType))
{
continue;
}
if (methodReference.ReturnValueIsModified)
{
if (!this.ModifiersMatch(method.ReturnParameter.GetOptionalCustomModifiers(), method.ReturnParameter.GetRequiredCustomModifiers(), methodReference.ReturnValueCustomModifiers))
{
continue;
}
}
}
var memberParameterInfos = methodBase.GetParameters();
if (parameterCount != memberParameterInfos.Length)
{
continue;
}
bool matched = true;
for (int i = 0; i < parameterCount; i++)
{
var mparInfo = memberParameterInfos[i];
var ipar = parameters[i];
var part = parameterTypes[i];
if (!AreEquivalient(containingType, mparInfo.ParameterType, part))
{
matched = false; break;
}
if (ipar.IsModified)
{
if (!this.ModifiersMatch(mparInfo.GetOptionalCustomModifiers(), mparInfo.GetRequiredCustomModifiers(), ipar.CustomModifiers))
{
continue;
}
}
}
if (!matched)
{
continue;
}
result = methodBase;
break;
}
if (result != null)
{
this.methodMap.Add(methodReference.InternedKey, result);
}
return(result);
}
private void GenerateDownLevelLockStatement(ILockStatement lockStatement)
{
var systemThreading = new NestedUnitNamespaceReference(this.host.PlatformType.SystemObject.ContainingUnitNamespace,
this.host.NameTable.GetNameFor("Threading"));
var systemThreadingMonitor = new NamespaceTypeReference(this.host, systemThreading, this.host.NameTable.GetNameFor("Monitor"), 0,
isEnum: false, isValueType: false, typeCode: PrimitiveTypeCode.NotPrimitive);
var parameters = new IParameterTypeInformation[2];
var monitorEnter = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Enter"), 0, this.host.PlatformType.SystemObject);
var monitorExit = new MethodReference(this.host, systemThreadingMonitor, CallingConvention.Default, this.host.PlatformType.SystemVoid,
this.host.NameTable.GetNameFor("Exit"), 0, this.host.PlatformType.SystemObject);
this.EmitSequencePoint(lockStatement.Locations);
var guardObject = new TemporaryVariable(lockStatement.Guard.Type, this.method);
this.Traverse(lockStatement.Guard);
this.generator.Emit(OperationCode.Dup); this.StackSize++;
this.VisitAssignmentTo(guardObject);
this.generator.Emit(OperationCode.Call, monitorEnter);
this.StackSize--;
//try
var savedCurrentTryCatch = this.currentTryCatch;
this.currentTryCatch = lockStatement;
var savedCurrentTryCatchFinallyEnd = this.currentTryCatchFinallyEnd;
this.currentTryCatchFinallyEnd = new ILGeneratorLabel();
this.generator.BeginTryBody();
this.Traverse(lockStatement.Body);
if (!this.lastStatementWasUnconditionalTransfer)
this.generator.Emit(OperationCode.Leave, this.currentTryCatchFinallyEnd);
//finally
this.generator.BeginFinallyBlock();
//if (status)
this.LoadLocal(guardObject);
this.generator.Emit(OperationCode.Call, monitorExit);
this.StackSize--;
//monitor exit
this.generator.Emit(OperationCode.Endfinally);
this.generator.EndTryBody();
this.generator.MarkLabel(this.currentTryCatchFinallyEnd);
this.currentTryCatchFinallyEnd = savedCurrentTryCatchFinallyEnd;
this.currentTryCatch = savedCurrentTryCatch;
this.lastStatementWasUnconditionalTransfer = false;
}
public override void Visit(IParameterTypeInformation parameterTypeInformation) {
parameterTypeInformation.Type.ResolvedType.Dispatch(this);
if (parameterTypeInformation.IsModified) this.Visit(parameterTypeInformation.CustomModifiers);
if (parameterTypeInformation.IsByReference) {
int h = this.hash;
h = (h << 5 + h) ^ 2;
this.hash = h;
}
}
internal CallByRefAssignment(Instruction original, IParameterTypeInformation p)
{
this.original = original;
this.Parameter = p;
}
// Append "@" to a byref param's type
protected override void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
{
// HACK: This is to support CCI1 syntax where generic type arguments are not shown for nested types.
if (param.Type is INestedTypeReference) formattingOptions = formattingOptions | NameFormattingOptions.OmitTypeArguments;
base.AppendParameter(param, (formattingOptions & ~NameFormattingOptions.OmitContainingType), sb);
if (param.IsByReference) sb.Append('@');
if (param.IsModified)
{
int count = 0;
foreach (ICustomModifier modifier in param.CustomModifiers)
{
count++;
//if (count>1)
//{ throw new NotImplementedException("Can't create a signature with more than one custom modifier"); }
AppendCustomModifier(formattingOptions, sb, modifier);
}
}
}
public static bool IsBoogieRefType(IParameterTypeInformation var)
{
return(IsBoogieRefType(Helpers.GetBoogieType(var)));
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given parameter type information.
/// </summary>
/// <param name="parameterTypeInformation"></param>
public virtual void Visit(IParameterTypeInformation parameterTypeInformation)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(parameterTypeInformation);
if (parameterTypeInformation.IsModified)
this.Visit(parameterTypeInformation.CustomModifiers);
this.Visit(parameterTypeInformation.Type);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public abstract BoogieType GetBoogieType(IParameterTypeInformation var);
/// <summary>
/// Traverses the children of the parameter type information.
/// </summary>
public virtual void TraverseChildren(IParameterTypeInformation parameterTypeInformation)
{
Contract.Requires(parameterTypeInformation != null);
if (parameterTypeInformation.IsModified) {
this.Traverse(parameterTypeInformation.CustomModifiers);
if (this.stopTraversal) return;
}
this.Traverse(parameterTypeInformation.Type);
}
public override BoogieType GetBoogieType(IParameterTypeInformation var)
{
return(GetBoogieType(var.Type));
}
/// <summary>
/// Performs some computation with the given parameter type information.
/// </summary>
public void Visit(IParameterTypeInformation parameterTypeInformation)
{
}
// if needed we will check if the variable has been referenced
public static BoogieType GetBoogieType(IParameterTypeInformation var)
{
return(BoogieType.GetBoogieTypeTranslator().GetBoogieType(var));
}
public virtual void onMetadataElement(IParameterTypeInformation parameterTypeInformation) { }
public virtual void onMetadataElement(IParameterTypeInformation parameterTypeInformation)
{
}
public override void TraverseChildren(IParameterTypeInformation parameterTypeInformation)
{
MethodEnter(parameterTypeInformation);
base.TraverseChildren(parameterTypeInformation);
MethodExit();
}
private MethodBase/*?*/ GetMethodFrom(IMethodReference methodReference, MemberInfo[] members) {
//Generic methods need special treatment because their signatures refer to their generic parameters
//and we can't map those to types unless we can first map the generic method.
if (methodReference.IsGeneric) return this.GetGenericMethodFrom(methodReference, members);
MethodBase result = null;
var methodReturnType = this.GetType(methodReference.Type);
if (methodReturnType == null) return null;
if (methodReference.ReturnValueIsByRef) methodReturnType = methodReturnType.MakeByRefType();
var parameterCount = methodReference.ParameterCount;
var parameters = new IParameterTypeInformation[parameterCount];
var parameterTypes = parameterCount == 0 ? null : new Type[parameterCount];
int parameterIndex = 0;
foreach (var parameter in methodReference.Parameters) {
parameters[parameterIndex] = parameter;
var ptype = this.GetType(parameter.Type);
if (ptype == null) return null;
if (parameter.IsByReference) ptype = ptype.MakeByRefType();
parameterTypes[parameterIndex++] = ptype;
}
foreach (var member in members) {
var methodBase = member as MethodBase;
if (methodBase == null || methodBase.IsGenericMethodDefinition) continue;
if (!this.CallingConventionsMatch(methodBase, methodReference)) continue;
if (methodBase.IsConstructor) {
if (methodReference.Type.TypeCode != PrimitiveTypeCode.Void) continue;
} else {
var method = (MethodInfo)methodBase;
if (methodReturnType != method.ReturnType) continue;
if (methodReference.ReturnValueIsModified) {
if (!this.ModifiersMatch(method.ReturnParameter.GetOptionalCustomModifiers(), method.ReturnParameter.GetRequiredCustomModifiers(), methodReference.ReturnValueCustomModifiers)) continue;
}
}
var memberParameterInfos = methodBase.GetParameters();
if (parameterCount != memberParameterInfos.Length) continue;
bool matched = true;
for (int i = 0; i < parameterCount; i++) {
var mparInfo = memberParameterInfos[i];
var ipar = parameters[i];
var part = parameterTypes[i];
if (mparInfo.ParameterType != part) { matched = false; break; }
if (ipar.IsModified) {
if (!this.ModifiersMatch(mparInfo.GetOptionalCustomModifiers(), mparInfo.GetRequiredCustomModifiers(), ipar.CustomModifiers)) continue;
}
}
if (!matched) continue;
result = methodBase;
break;
}
if (result != null)
this.methodMap.Add(methodReference.InternedKey, result);
return result;
}
