public override void TraverseChildren(IParameterDefinition parameterDefinition) { PrintParameterDefinitionModifiers(parameterDefinition); PrintParameterDefinitionType(parameterDefinition); PrintToken(CSharpToken.Space); PrintParameterDefinitionName(parameterDefinition); }
private static void Ldarg(ILGenerator ilGenerator, IParameterDefinition parameter, int i) { switch (i) { case 0: ilGenerator.Emit(OperationCode.Ldarg_0); break; case 1: ilGenerator.Emit(OperationCode.Ldarg_1); break; case 2: ilGenerator.Emit(OperationCode.Ldarg_2); break; case 3: ilGenerator.Emit(OperationCode.Ldarg_3); break; default: ilGenerator.Emit(i <= byte.MaxValue ? OperationCode.Ldarg_S : OperationCode.Ldarg, parameter); break; } }
/// <summary> /// /// </summary> /// <param name="parameter"></param> protected void LoadParameter(IParameterDefinition /*?*/ parameter) { ushort parIndex = GetParameterIndex(parameter); if (parIndex == 0) { this.ilGenerator.Emit(OperationCode.Ldarg_0, parameter); } else if (parIndex == 1) { this.ilGenerator.Emit(OperationCode.Ldarg_1, parameter); } else if (parIndex == 2) { this.ilGenerator.Emit(OperationCode.Ldarg_2, parameter); } else if (parIndex == 3) { this.ilGenerator.Emit(OperationCode.Ldarg_3, parameter); } else if (parIndex <= byte.MaxValue) { this.ilGenerator.Emit(OperationCode.Ldarg_S, parameter); } else { this.ilGenerator.Emit(OperationCode.Ldarg, parameter); } }
private bool ParamNamesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod) { int paramCount = implMethod.ParameterCount; Contract.Assert(paramCount == contractMethod.ParameterCount); IParameterDefinition[] implParams = implMethod.Parameters.ToArray(); IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray(); bool match = true; for (int i = 0; i < paramCount; i++) { IParameterDefinition implParam = implParams[i]; IParameterDefinition contractParam = contractParams[i]; if (!implParam.Name.Value.Equals(contractParam.Name.Value)) { differences.AddIncompatibleDifference(this, "Parameter name on member '{0}' is '{1}' in the implementation but '{2}' in the contract.", implMethod.FullName(), implParam.Name.Value, contractParam.Name.Value); match = false; } } return(match); }
public virtual void Visit(IParameterDefinition parameterDefinition) { var marshalling = parameterDefinition.MarshallingInformation; Debug.Assert((marshalling != null || !parameterDefinition.MarshallingDescriptor.IsDefaultOrEmpty) == parameterDefinition.IsMarshalledExplicitly); this.Visit(parameterDefinition.GetAttributes(Context)); this.Visit(parameterDefinition.CustomModifiers); IMetadataConstant defaultValue = parameterDefinition.GetDefaultValue(Context); if (defaultValue != null) { this.Visit((IMetadataExpression)defaultValue); } if (marshalling != null) { // Note, we are not visiting MarshallingDescriptor. It is used only for // NoPia embedded/local types and VB Dev11 simply copies the bits without // cracking them. this.Visit(marshalling); } this.Visit(parameterDefinition.GetType(Context)); }
/// <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); } }
public virtual void PrintParameterDefinitionModifiers(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); if (parameterDefinition.Index == 0) { var meth = parameterDefinition.ContainingSignature as IMethodDefinition; if (meth != null ) { if (Utils.FindAttribute(meth.Attributes, SpecialAttribute.Extension) != null) { PrintToken(CSharpToken.This); PrintToken(CSharpToken.Space); } } } foreach (var attribute in SortAttributes(parameterDefinition.Attributes)) { if (Utils.GetAttributeType(attribute) == SpecialAttribute.ParamArray) sourceEmitterOutput.Write("params"); else this.PrintAttribute(parameterDefinition, attribute, false, null); PrintToken(CSharpToken.Space); } if (parameterDefinition.IsOut && !parameterDefinition.IsIn && parameterDefinition.IsByReference) { // C# out keyword means [Out] ref (with no [In] allowed) PrintKeywordOut(); } else { if (parameterDefinition.IsIn) PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.In", null, false, null); if (parameterDefinition.IsOut) PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.Out", null, false, null); if (parameterDefinition.IsByReference) PrintKeywordRef(); } }
private bool ParamNamesAndTypesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod) { int paramCount = implMethod.ParameterCount; Debug.Assert(paramCount == contractMethod.ParameterCount); IParameterDefinition[] implParams = implMethod.Parameters.ToArray(); IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray(); bool match = true; for (int i = 0; i < paramCount; i++) { IParameterDefinition implParam = implParams[i]; IParameterDefinition contractParam = contractParams[i]; if (!implParam.Name.Value.Equals(contractParam.Name.Value)) { differences.AddIncompatibleDifference("DelegateParamNameMustMatch", $"Parameter name on delegate '{implMethod.ContainingType.FullName()}' is '{implParam.Name.Value}' in the {Implementation} but '{contractParam.Name.Value}' in the {Contract}."); match = false; } if (!_typeComparer.Equals(implParam.Type, contractParam.Type)) { differences.AddTypeMismatchDifference("DelegateParamTypeMustMatch", implParam.Type, contractParam.Type, $"Type for parameter '{implParam.Name.Value}' on delegate '{implMethod.ContainingType.FullName()}' is '{implParam.Type.FullName()}' in the {Implementation} but '{contractParam.Type.FullName()}' in the {Contract}."); match = false; } } return(match); }
public override object RewriteReference(IParameterDefinition parameterDefinition) { var mappedParameter = this.parameterMap.Find((uint)parameterDefinition.Name.UniqueKey); Contract.Assume(mappedParameter != null); return(mappedParameter); }
public static bool CompareParameterName(IParameterDefinition parameter, string name, bool useCase) { return(name.Equals(parameter.Name, useCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture) || name.Equals(parameter.ShortName, useCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture)); }
public override void TraverseChildren(IParameterDefinition parameterDefinition) { PrintParameterDefinitionModifiers(parameterDefinition); PrintParameterDefinitionName(parameterDefinition); PrintToken(VBToken.Space); PrintToken(VBToken.As); PrintToken(VBToken.Space); PrintParameterDefinitionType(parameterDefinition); }
public static void DisplayCommandParameter(TriggerBase trigger, IParameterDefinition parameter) { trigger.Reply("\t(" + trigger.Bold("{0}") + " : {1})", new object[] { parameter.GetUsage(), parameter.Description ?? "" }); }
public override void VisitReference(IParameterDefinition parameterDefinition) { if (Process(parameterDefinition)) { visitor.Visit(parameterDefinition); } base.VisitReference(parameterDefinition); }
public override void TraverseChildren(ITargetExpression targetExpression) { base.TraverseChildren(targetExpression); ITypeReference type = Dummy.TypeReference; ILocalDefinition /*?*/ local = targetExpression.Definition as ILocalDefinition; if (local != null) { if (local.IsReference) { if (local.IsPinned) { type = Immutable.PointerType.GetPointerType(local.Type, this.host.InternFactory); } else { type = Immutable.ManagedPointerType.GetManagedPointerType(local.Type, this.host.InternFactory); } } else { type = local.Type; } } else { IParameterDefinition /*?*/ parameter = targetExpression.Definition as IParameterDefinition; if (parameter != null) { type = parameter.Type; } else { IFieldReference /*?*/ field = targetExpression.Definition as IFieldReference; if (field != null) { type = field.Type; } else { IPropertyDefinition /*?*/ property = targetExpression.Definition as IPropertyDefinition; if (property != null) { type = property.Type; } else { IExpression /*?*/ expression = targetExpression.Definition as IExpression; if (expression != null) { type = expression.Type; } } } } } ((TargetExpression)targetExpression).Type = type; }
private bool CheckModifiersOnParametersAndReturnValue(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod) { int paramCount = implMethod.ParameterCount; Contract.Assert(paramCount == contractMethod.ParameterCount); if (paramCount == 0) { return(true); } IParameterDefinition[] implParams = implMethod.Parameters.ToArray(); IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray(); bool match = true; for (int i = 0; i < paramCount; i++) { IParameterDefinition implParam = implParams[i]; IParameterDefinition contractParam = contractParams[i]; //TODO: Do we care about the compatibility with marshalling attributes Out\In? They don't seem to be set consistently. if (GetModifier(implParam) != GetModifier(contractParam)) { differences.AddIncompatibleDifference(this, "Modifiers on parameter '{0}' on method '{1}' are '{2}' in the implementation but '{3}' in the contract.", implParam.Name.Value, implMethod.FullName(), GetModifier(implParam), GetModifier(contractParam)); match = false; } // Now check custom modifiers, primarily focused on const & volatile if (implParam.IsModified || contractParam.IsModified) { var union = implParam.CustomModifiers.Union(contractParam.CustomModifiers); if (implParam.CustomModifiers.Count() != union.Count()) { differences.AddIncompatibleDifference(this, "Custom modifiers on parameter '{0}' on method '{1}' are '{2}' in the implementation but '{3}' in the contract.", implParam.Name.Value, implMethod.FullName(), PrintCustomModifiers(implParam.CustomModifiers), PrintCustomModifiers(contractParam.CustomModifiers)); match = false; } } } string implReturnModifier = GetReturnValueModifier(implMethod); string contractReturnModifier = GetReturnValueModifier(contractMethod); if (implReturnModifier != contractReturnModifier) { differences.AddIncompatibleDifference(this, "Modifiers on return type of method '{0}' are '{1}' in the implementation but '{2}' in the contract.", implMethod.FullName(), implReturnModifier, contractReturnModifier); match = false; } return(match); }
public ParameterDefinition(IParameterDefinition copyFrom) : base(copyFrom) { Context = copyFrom.Context; DataType = copyFrom.DataType; IsRequired = copyFrom.IsRequired; IsVariadic = copyFrom.IsVariadic; Name = copyFrom.Name; Type = copyFrom.Type; }
private string GetModifier(IParameterDefinition parameter) { if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference) return "out"; else if (parameter.IsByReference) return "ref"; return "in"; }
IEnumerable <IContractElement> GetReleventContracts <TContractElement>(IParameterDefinition parameter, IEnumerable <TContractElement> contractElements) where TContractElement : IContractElement { Contract.Requires(parameter != null); Contract.Requires(contractElements != null); return(from contractElement in contractElements where (contractElement as IContractElement).OriginalSource.Contains(parameter.Name.Value) select(contractElement as IContractElement)); }
public CciParameterDetails(IParameterDefinition parameter) { if (parameter == null) { throw new ArgumentNullException("parameter"); } _parameter = parameter; }
public override IParameterDefinition Rewrite(IParameterDefinition parameterDefinition) { //we need to copy the parameters because they still come from the closure method. var copy = new ParameterDefinition(); copy.Copy(parameterDefinition, this.host.InternFactory); copy.ContainingSignature = this.anonymousDelegate; this.parameterMap.Add((uint)parameterDefinition.Name.UniqueKey, copy); return(copy); }
/// <summary> /// /// </summary> /// <param name="parameter"></param> protected void LoadParameterAddress(IParameterDefinition /*?*/ parameter) { ushort parIndex = GetParameterIndex(parameter); if (parIndex <= byte.MaxValue) { this.ilGenerator.Emit(OperationCode.Ldarga_S, parameter); } else { this.ilGenerator.Emit(OperationCode.Ldarga, parameter); } }
/// <summary> /// /// </summary> /// <param name="parameter"></param> protected void StoreParameter(IParameterDefinition /*?*/ parameter) { ushort parIndex = GetParameterIndex(parameter); if (parIndex <= byte.MaxValue) { this.ilGenerator.Emit(OperationCode.Starg_S, parameter); } else { this.ilGenerator.Emit(OperationCode.Starg, parameter); } }
/// <summary> /// Puts the specified instruction onto the Microsoft intermediate language (MSIL) stream followed by the index of the given local variable. /// </summary> /// <param name="opcode">The Microsoft intermediate language (MSIL) instruction to be put onto the stream.</param> /// <param name="parameter">A parameter definition.</param> public void Emit(OperationCode opcode, IParameterDefinition parameter) { this.operations.Add(new Operation(opcode, this.offset, this.GetCurrentSequencePoint(), parameter)); this.offset += SizeOfOperationCode(opcode); if (opcode == OperationCode.Ldarg_S || opcode == OperationCode.Ldarga_S || opcode == OperationCode.Starg_S) { this.offset += 1; } else if (opcode == OperationCode.Ldarg || opcode == OperationCode.Ldarga || opcode == OperationCode.Starg) { this.offset += 2; } }
private string GetModifier(IParameterDefinition parameter) { if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference) { return("out"); } else if (parameter.IsByReference) { return("ref"); } return("in"); }
public virtual void PrintParameterDefinitionModifiers(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); if (parameterDefinition.Index == 0) { var meth = parameterDefinition.ContainingSignature as IMethodDefinition; if (meth != null) { if (Utils.FindAttribute(meth.Attributes, SpecialAttribute.Extension) != null) { PrintToken(CSharpToken.This); PrintToken(CSharpToken.Space); } } } foreach (var attribute in SortAttributes(parameterDefinition.Attributes)) { if (Utils.GetAttributeType(attribute) == SpecialAttribute.ParamArray) { sourceEmitterOutput.Write("params"); } else { this.PrintAttribute(parameterDefinition, attribute, false, null); } PrintToken(CSharpToken.Space); } if (parameterDefinition.IsOut && !parameterDefinition.IsIn && parameterDefinition.IsByReference) { // C# out keyword means [Out] ref (with no [In] allowed) PrintKeywordOut(); } else { if (parameterDefinition.IsIn) { PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.In", null, false, null); } if (parameterDefinition.IsOut) { PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.Out", null, false, null); } if (parameterDefinition.IsByReference) { PrintKeywordRef(); } } }
/// <summary> /// Translates the parameter list position of the given parameter to an IL parameter index. In other words, /// it adds 1 to the parameterDefinition.Index value if the containing method has an implicit this parameter. /// </summary> private static ushort GetParameterIndex(IParameterDefinition /*?*/ parameterDefinition) { if (parameterDefinition == null) { return(0); } ushort parameterIndex = parameterDefinition.Index; if (!parameterDefinition.ContainingSignature.IsStatic) { parameterIndex++; } return(parameterIndex); }
public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype) { this.underlyingParameter = parameterDefinition; var parameterToken = parameterDefinition.Token(); var typeToken = parameterDefinition.Type.Token(); var parameterName = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value); if (String.IsNullOrWhiteSpace(parameterName)) parameterName = "P" + parameterDefinition.Index.ToString(); this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true); if (parameterDefinition.IsByReference) { this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false); } else { this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype)); } }
private static string GetParameterSignature(IParameterDefinition pDefinition) { // TODO: if pDefinition.IsByReference string signatureContainer = null; if (pDefinition.ContainingSignature is IMethodDefinition) { signatureContainer = GetMethodSignature(pDefinition.ContainingSignature as IMethodDefinition); } else { throw new NotSupportedException(); } return(signatureContainer + "|" + pDefinition.ToString()); }
private static bool IsParameterSupported(IParameterDefinition parameterDefinition) { var parameterType = parameterDefinition.Type; // special short-circuit for specific marshalling. if (parameterDefinition.IsMarshalledExplicitly) { var unmanagedType = parameterDefinition.MarshallingInformation.UnmanagedType; switch (unmanagedType) { case UnmanagedType.LPWStr: case UnmanagedType.LPStr: return(parameterType.IsString() || parameterType.IsStringArray()); case UnmanagedType.LPArray: if (parameterType.IsBlittable()) { return(true); } if (parameterType.IsStringArray()) { var elementType = parameterDefinition.MarshallingInformation.ElementType; if (elementType == UnmanagedType.LPStr || elementType == UnmanagedType.LPWStr) { return(true); } } return(false); } } // blittable, delegates and strings -- these last two have special marshalling we take care of if (parameterType.TypeCode == PrimitiveTypeCode.Boolean || parameterType.IsBlittable() || parameterType.IsDelegate() || parameterType.IsString()) { return(true); } // we also support string[] since it's so common, by converting it to IntPtr[] in a try/finally if (parameterType.IsStringArray()) { return(true); } // TODO: Support ICustomMarshaler return(false); }
private void WriteParameter(IParameterDefinition parameter, ITypeReference containingType, bool extensionMethod, byte?methodNullableContextValue) { WriteAttributes(parameter.Attributes, true); if (extensionMethod) { WriteKeyword("this"); } if (parameter.IsParameterArray) { WriteKeyword("params"); } if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference) { WriteKeyword("out"); } else { // For In/Out we should not emit them until we find a scenario that is needs them. //if (parameter.IsIn) // WriteFakeAttribute("System.Runtime.InteropServices.In", writeInline: true); //if (parameter.IsOut) // WriteFakeAttribute("System.Runtime.InteropServices.Out", writeInline: true); if (parameter.IsByReference) { if (parameter.Attributes.HasIsReadOnlyAttribute()) { WriteKeyword("in"); } else { WriteKeyword("ref"); } } } WriteTypeName(parameter.Type, containingType, parameter.Attributes, methodNullableContextValue); WriteIdentifier(parameter.Name); if (parameter.IsOptional && parameter.HasDefaultValue) { WriteSymbol(" = "); WriteMetadataConstant(parameter.DefaultValue, parameter.Type); } }
/// <summary> /// A parameter definition that is just a new name (and object identity) for an existing parameter. The existing parameter /// can be recovered via the OriginalParameter property. /// </summary> /// <param name="originalParameter">The parameter for which the new parameter provides a new name and new object identity.</param> /// <param name="name"></param> /// <param name="containingType"></param> public SSAParameterDefinition(IParameterDefinition originalParameter, IName name, ITypeDefinition containingType) { Contract.Requires(originalParameter != null); Contract.Requires(name != null); Contract.Requires(containingType != null); this.originalParameter = originalParameter; this.name = name; if (originalParameter.Type is Dummy) { this.type = containingType; //should only happen if the parameter is the this parameter. } else { this.type = originalParameter.Type; } }
private string GetModifier(IParameterDefinition parameter) { if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference) { return("out"); } else if (parameter.IsByReference) { if (parameter.Attributes.HasIsReadOnlyAttribute()) { return("in"); } return("ref"); } return("<none>"); }
public override void TraverseChildren(IBoundExpression boundExpression) { base.TraverseChildren(boundExpression); ITypeReference type = Dummy.TypeReference; ILocalDefinition /*?*/ local = boundExpression.Definition as ILocalDefinition; if (local != null) { type = local.Type; if (local.IsReference) { if (local.IsPinned) { type = Immutable.PointerType.GetPointerType(type, this.host.InternFactory); } else { type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory); } } } else { IParameterDefinition /*?*/ parameter = boundExpression.Definition as IParameterDefinition; if (parameter != null) { type = parameter.Type; if (parameter.IsByReference) { type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory); } } else { IFieldReference /*?*/ field = boundExpression.Definition as IFieldReference; if (field != null) { type = field.Type; } } } ((BoundExpression)boundExpression).Type = type; }
XElement GetParamElement(XElement member, IParameterDefinition param) { Contract.Requires(member != null); Contract.Ensures(Contract.Result <XElement>() != null); foreach (var el in member.Elements("param")) { if (el.Attribute("name").Value == param.Name.Value) { return(el); } } var paramElement = new XElement("param"); paramElement.SetAttributeValue("name", param.Name); return(paramElement); }
public MethodParameter(IParameterDefinition parameterDefinition) { this.underlyingParameter = parameterDefinition; Bpl.Type ptype = Bpl.Type.Int; var parameterToken = parameterDefinition.Token(); var typeToken = parameterDefinition.Type.Token(); var parameterName = parameterDefinition.Name.Value; if (!parameterDefinition.IsOut) { this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true); } if (parameterDefinition.IsByReference || parameterDefinition.IsOut) { this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false); } else { this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype)); } }
/// <summary> /// Performs some computation with the given parameter definition. /// </summary> public virtual void Visit(IParameterDefinition parameterDefinition) { }
private static string GetParameterSignature(IParameterDefinition pDefinition) { // TODO: if pDefinition.IsByReference string signatureContainer = null; if (pDefinition.ContainingSignature is IMethodDefinition) signatureContainer = GetMethodSignature(pDefinition.ContainingSignature as IMethodDefinition); else throw new NotSupportedException(); return signatureContainer + "|" + pDefinition.ToString(); }
public void Visit(IParameterDefinition parameterDefinition) { this.traverser.Traverse(parameterDefinition); }
public void VisitReference(IParameterDefinition parameterDefinition) { Contract.Assume(false); }
/// <summary> /// Puts the specified instruction onto the Microsoft intermediate language (MSIL) stream followed by the index of the given local variable. /// </summary> /// <param name="opcode">The Microsoft intermediate language (MSIL) instruction to be put onto the stream.</param> /// <param name="parameter">A parameter definition.</param> public void Emit(OperationCode opcode, IParameterDefinition parameter) { this.operations.Add(new Operation(opcode, this.offset, this.GetCurrentSequencePoint(), parameter)); this.offset += SizeOfOperationCode(opcode); if (opcode == OperationCode.Ldarg_S || opcode == OperationCode.Ldarga_S || opcode == OperationCode.Starg_S) this.offset += 1; else if (opcode == OperationCode.Ldarg || opcode == OperationCode.Ldarga || opcode == OperationCode.Starg) this.offset += 2; }
public void VisitReference(IParameterDefinition parameterDefinition) { throw new NotImplementedException(); }
public void AddOriginalParameter(IParameterDefinition parameter) { var parameterInfo = new ReplacementParameterInfo(); parameterInfo.Name = parameter.Name.Value; parameterInfo.IsOut = parameter.IsOut; parameterInfo.IsRef = parameter.IsByReference; parameterInfo.Type = parameter.Type; parameterInfo.Definition = parameter; }
/// <summary> /// Performs some computation with the given parameter definition. /// </summary> public void VisitReference(IParameterDefinition parameterDefinition) { }
public virtual void PrintParameterDefinitionType(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); PrintTypeReference(parameterDefinition.Type); }
protected IParameterDefinition[] GetModuleParameters(bool useParamInfo, ISignature signatureDefinition, int paramCount) { MethodDefinition/*?*/ moduleMethod = signatureDefinition as MethodDefinition; int paramIndex = 0; var parameters = new IParameterDefinition[paramCount]; while (paramIndex < paramCount) { bool dummyPinned; var customModifiers = this.GetCustomModifiers(out dummyPinned); byte currByte = this.SignatureMemoryReader.PeekByte(0); if (currByte == ElementType.Sentinel) { this.SignatureMemoryReader.SkipBytes(1); var requiredParameters = new IParameterDefinition[paramIndex]; for (int i = 0; i < paramIndex; i++) requiredParameters[i] = parameters[i]; return requiredParameters; } 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(); } ParamInfo? paramInfo = useParamInfo ? this.GetParamInfo(paramIndex + 1) : null; IParameterDefinition moduleParameter; if (paramInfo.HasValue) { var paramArrayType = typeReference as IArrayTypeReference; moduleParameter = new ParameterWithMetadata(this.PEFileToObjectModel, paramIndex, customModifiers, typeReference, moduleMethod, isByReference, (paramIndex == paramCount - 1) && paramArrayType != null && paramArrayType.IsVector, paramInfo.Value.ParamRowId, paramInfo.Value.ParamName, paramInfo.Value.ParamFlags); } else moduleParameter = new ParameterWithoutMetadata(this.PEFileToObjectModel, paramIndex, customModifiers, typeReference, signatureDefinition, isByReference); parameters[paramIndex++] = moduleParameter; } return parameters; }
public virtual void PrintParameterDefinitionName(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); PrintIdentifier(parameterDefinition.Name); }
private void WriteParameter(IParameterDefinition parameter, bool extensionMethod) { WriteAttributes(parameter.Attributes, true); if (extensionMethod) WriteKeyword("this"); if (parameter.IsParameterArray) WriteKeyword("params"); if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference) { WriteKeyword("out"); } else { // For In/Out we should not emit them until we find a scenario that is needs thems. //if (parameter.IsIn) // WriteFakeAttribute("System.Runtime.InteropServices.In", writeInline: true); //if (parameter.IsOut) // WriteFakeAttribute("System.Runtime.InteropServices.Out", writeInline: true); if (parameter.IsByReference) WriteKeyword("ref"); } WriteTypeName(parameter.Type, isDynamic: IsDynamic(parameter.Attributes)); WriteIdentifier(parameter.Name); if (parameter.IsOptional && parameter.HasDefaultValue) { WriteSymbol("="); WriteMetadataConstant(parameter.DefaultValue, parameter.Type); } }
private static HLParameter CreateParameter(IParameterDefinition pDefinition) { HLParameter parameter = new HLParameter(); //parameter.Definition = pDefinition; parameter.Name = pDefinition.Name.Value; parameter.Signature = HLDomain.GetParameterSignature(pDefinition); sParameters[parameter.Signature] = parameter; //if (pDefinition.ContainingSignature is IMethodDefinition) parameter.MethodContainer = GetOrCreateMethod(pDefinition.ContainingSignature as IMethodDefinition); //else throw new NotSupportedException(); ITypeReference type = pDefinition.Type; if (pDefinition.IsByReference) type = MutableModelHelper.GetManagedPointerTypeReference(type, Host.InternFactory, type); parameter.IsReference = pDefinition.IsByReference; parameter.Type = GetOrCreateType(type); return parameter; }
public virtual void onMetadataElement(IParameterDefinition parameterDefinition) { }
/// <summary> /// Performs some computation with the given parameter definition. /// </summary> public void Visit(IParameterDefinition parameterDefinition) { if (parameterDefinition.HasDefaultValue) { var parameterType = parameterDefinition.Type; if (parameterType.IsEnum && parameterType.ResolvedType != Dummy.Type) parameterType = parameterType.ResolvedType.UnderlyingType; if (!TypeHelper.TypesAreEquivalent(parameterDefinition.DefaultValue.Type, parameterType)) this.ReportError(MetadataError.MetadataConstantTypeMismatch, parameterDefinition.DefaultValue, parameterDefinition); } if (parameterDefinition.IsMarshalledExplicitly) { if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.LPArray) { if (parameterDefinition.MarshallingInformation.ParamIndex != null) { var index = parameterDefinition.MarshallingInformation.ParamIndex.Value; if (index >= IteratorHelper.EnumerableCount(parameterDefinition.ContainingSignature.Parameters)) this.ReportError(MetadataError.ParameterIndexIsInvalid, parameterDefinition.MarshallingInformation, parameterDefinition); if (parameterDefinition.MarshallingInformation.NumberOfElements > 0) this.ReportError(MetadataError.NumberOfElementsSpecifiedExplicitlyAsWellAsByAParameter, parameterDefinition); } else { //The ECMA spec seems to suggest that this check is needed. //The MSDN documentation claims that these values are ignored when marshalling from the CLR to COM. //Actual code found in the .NET Framework fail this test. So disable it for now. //if (parameterDefinition.MarshallingInformation.NumberOfElements == 0 && parameterDefinition.IsOut) // this.ReportError(MetadataError.ParameterMarshalledArraysMustHaveSizeKnownAtCompileTime, parameterDefinition.MarshallingInformation, parameterDefinition); } } if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValArray) { this.ReportError(MetadataError.ParameterCannotBeMarshalledAsByValArray, parameterDefinition.MarshallingInformation, parameterDefinition); } if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValTStr) { if (parameterDefinition.MarshallingInformation.NumberOfElements == 0) this.ReportError(MetadataError.ParameterMarshalledArraysMustHaveSizeKnownAtCompileTime, parameterDefinition.MarshallingInformation, parameterDefinition); } } }
/// <summary> /// Get mutable copy of a parameter definition of an anonymous delegate. The parameters of anonymous delegate /// are not visited until the code of a souce method body is visited. /// </summary> /// <param name="parameterDefinition"></param> /// <returns></returns> private ParameterDefinition GetMutableCopyParamAnonymDeleg(IParameterDefinition parameterDefinition) { ParameterDefinition/*?*/ result; object/*?*/ cachedValue = null; this.cache.TryGetValue(parameterDefinition, out cachedValue); result = cachedValue as ParameterDefinition; if (result != null) return result; result = new ParameterDefinition(); this.cache.Add(parameterDefinition, result); this.cache.Add(result, result); result.Copy(parameterDefinition, this.host.InternFactory); return result; }
public static HLParameter GetParameter(IParameterDefinition pDefinition) { return sParameters[GetParameterSignature(pDefinition)]; }
/// <summary> /// Traverses the children of the parameter definition. /// </summary> public virtual void TraverseChildren(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); this.Traverse(parameterDefinition.Attributes); if (this.stopTraversal) return; if (parameterDefinition.IsModified) { this.Traverse(parameterDefinition.CustomModifiers); if (this.stopTraversal) return; } if (parameterDefinition.HasDefaultValue) { this.Traverse(parameterDefinition.DefaultValue); if (this.stopTraversal) return; } if (parameterDefinition.IsMarshalledExplicitly) { this.Traverse(parameterDefinition.MarshallingInformation); if (this.stopTraversal) return; } this.Traverse(parameterDefinition.Type); }
//^ ensures this.path.Count == old(this.path.Count); /// <summary> /// Performs some computation with the given parameter definition. /// </summary> /// <param name="parameterDefinition"></param> public virtual void Visit(IParameterDefinition parameterDefinition) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(parameterDefinition); this.Visit(parameterDefinition.Attributes); if (parameterDefinition.IsModified) this.Visit(parameterDefinition.CustomModifiers); if (parameterDefinition.HasDefaultValue) this.Visit((IMetadataExpression)parameterDefinition.DefaultValue); if (parameterDefinition.IsMarshalledExplicitly) this.Visit(parameterDefinition.MarshallingInformation); this.Visit(parameterDefinition.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 override void TraverseChildren(IParameterDefinition parameterDefinition) { MethodEnter(parameterDefinition); base.TraverseChildren(parameterDefinition); MethodExit(); }
/// <summary> /// Traverses the parameter definition. /// </summary> public void Traverse(IParameterDefinition parameterDefinition) { Contract.Requires(parameterDefinition != null); if (!this.objectsThatHaveAlreadyBeenTraversed.Add(parameterDefinition)) return; if (this.preorderVisitor != null) this.preorderVisitor.Visit(parameterDefinition); if (this.stopTraversal) return; this.TraverseChildren(parameterDefinition); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(parameterDefinition); }
private void LoadParameter(IParameterDefinition parameter) { TranslatedExpressions.Push(Bpl.Expr.Ident(this.sink.FindParameterVariable(parameter, this.contractContext))); return; }