public DefineParameter ( int iSequence, System attributes, string strParamName ) : System.Reflection.Emit.ParameterBuilder | ||
iSequence | int | |
attributes | System | |
strParamName | string | |
return | System.Reflection.Emit.ParameterBuilder |
public static void DefineParams(ConstructorBuilder constructorBuilder, IEnumerable<RppParameterInfo> constructorParams) { int index = 1; foreach (var param in constructorParams) { constructorBuilder.DefineParameter(index++, ParameterAttributes.None, RppClass.StringConstructorArgName(param.Name)); } }
internal void Compile(ConstructorBuilder c) { if (Builder == null) { int ofs = (c.IsStatic ? 0 : 1); Builder = c.DefineParameter(this.Index + ofs, this.Attributes, this.Name); } }
private static void DefineParameterNames( ConstructorBuilder constructor, ConstructorMetadata constructorMetadata) { for (var i = 0; i < constructorMetadata.Parameters.Length; i++) { var parameter = constructorMetadata.Parameters[i]; constructor.DefineParameter(parameter.Sequence, ParameterAttributes.None, parameter.Name); } }
public void Execute() { constructorBuilder = builder().TypeBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, this.types().ToArray()); int counter = 1; foreach(Type type in this.types()) { constructorBuilder.DefineParameter(counter, ParameterAttributes.None, type.Name + "_" + counter); counter++; } }
internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments) { this.maintype = maintype; var args = ArgumentsUtil.InitializeAndConvert(arguments); builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args); // if we don't copy the parameter attributes, the default binder will fail // when trying to resolve constructors from the passed argument values. for (int i = 0; i < args.Length; ++i) { var arg = arguments[i]; var paramBuilder = builder.DefineParameter(i + 1, arg.ParameterAttributes, ""); if (arg.DefaultValue != DBNull.Value) paramBuilder.SetConstant(arg.DefaultValue); } }
private void NegTestCaseVerificationHelper( ConstructorBuilder constructor, int sequence, ParameterAttributes attribute, string paramName, Type desiredException) { Assert.Throws(desiredException, () => { constructor.DefineParameter(sequence, attribute, paramName); }); }
// TODO: use in Python's OverrideConstructor: public static ParameterBuilder DefineParameterCopy(ConstructorBuilder builder, int paramIndex, ParameterInfo info) { var result = builder.DefineParameter(1 + paramIndex, info.Attributes, info.Name); CopyParameterAttributes(info, result); return result; }
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index, PredefinedAttributes pa) { if (builder != null) throw new InternalErrorException ("builder already exists"); if (mb == null) builder = cb.DefineParameter (index, Attributes, Name); else builder = mb.DefineParameter (index, Attributes, Name); if (OptAttributes != null) OptAttributes.Emit (); if (HasDefaultValue) { // // Emit constant values for true constants only, the other // constant-like expressions will rely on default value expression // Constant c = default_expr as Constant; if (c != null) { if (default_expr.Type == TypeManager.decimal_type) { builder.SetCustomAttribute (Const.CreateDecimalConstantAttribute (c, pa)); } else { builder.SetConstant (c.GetTypedValue ()); } } } if (parameter_type != null) { if (parameter_type == InternalType.Dynamic) { pa.Dynamic.EmitAttribute (builder); } else if (parameter_type.HasDynamicElement) { pa.Dynamic.EmitAttribute (builder, parameter_type); } } }
public static void RegisterBuilders(this IReadOnlyList<ParameterStructure> prm, ConstructorBuilder builder, bool isInstance) { for (var i = 0; i < prm.Count; ++i) { var p = prm[i]; var pb = builder.DefineParameter(i + 1, p.Attributes, p.Name); p.RegisterBuilder(pb, isInstance); } }
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index) { if (mb == null) builder = cb.DefineParameter (index, Attributes, Name); else builder = mb.DefineParameter (index, Attributes, Name); if (OptAttributes != null) OptAttributes.Emit (); if (HasDefaultValue) { // // Emit constant values for true constants only, the other // constant-like expressions will rely on default value expression // Constant c = default_expr as Constant; if (c != null) { if (default_expr.Type == TypeManager.decimal_type) { builder.SetCustomAttribute (Const.CreateDecimalConstantAttribute (c)); } else { builder.SetConstant (c.GetTypedValue ()); } } } if (parameter_type == InternalType.Dynamic) { PredefinedAttributes.Get.Dynamic.EmitAttribute (builder); } else { var trans_flags = TypeManager.HasDynamicTypeUsed (parameter_type); if (trans_flags != null) { var pa = PredefinedAttributes.Get.DynamicTransform; if (pa.Constructor != null || pa.ResolveConstructor (Location, ArrayContainer.MakeType (TypeManager.bool_type))) { builder.SetCustomAttribute ( new CustomAttributeBuilder (pa.Constructor, new object [] { trans_flags })); } } } }
private void DefineParameter(MethodBuilder methodBuilder, ConstructorBuilder constructorBuilder, Cci.IParameterDefinition paramDef) { // No explicit param row is needed if param has no flags (other than optionally IN), // no name and no references to the param row, such as CustomAttribute, Constant, or FieldMarshall var attributes = paramDef.GetAttributes(_context); var defaultValue = paramDef.GetDefaultValue(_context); if (defaultValue != null || paramDef.IsOptional || paramDef.IsOut || paramDef.IsMarshalledExplicitly || attributes.Any() || paramDef.Name.Length > 0) { int index = paramDef is Cci.ReturnValueParameter ? 0 : paramDef.Index + 1; ParameterAttributes attrs = (ParameterAttributes)Cci.MetadataWriter.GetParameterFlags(paramDef); ParameterBuilder paramBuilder = (methodBuilder != null) ? methodBuilder.DefineParameter(index, attrs, paramDef.Name) : constructorBuilder.DefineParameter(index, attrs, paramDef.Name); if (defaultValue != null) { object rawValue = defaultValue.Value; if (rawValue == null) { var paramTypeRef = paramDef.GetType(_context); if (paramTypeRef.IsValueType) { SetParameterDefaultStructValue(paramBuilder); } else { paramBuilder.SetConstant(null); } } else { // TODO (tomat): Ref.Emit has too strict checks on the constant type. While it is ok to emit value, // e.g. of type Int16 for parameter of type Int32 to metadata, Ref.Emit checks if these types are Type.IsAssignableFrom. // To make this work we need to convert. // // We also need to support Nullable<T>. if (rawValue.GetType().IsPrimitive) { // parameter type has already been resolved once when defining the method, so just retrive it: Type paramType = ResolveType(paramDef.GetType(_context)); if (paramType.IsGenericType && paramType.GetGenericTypeDefinition() == typeof(Nullable<>)) { paramType = paramType.GetGenericArguments()[0]; } if (paramType.IsEnum) { // If emitting the enum, it isn't "created" as this stage so Enum.GetUnderlyingType() will throw // Otherwise, if the enum is already defined, we should use Enum.GetUnderlyingType() to get the correct type paramType = paramType is TypeBuilder ? paramType.UnderlyingSystemType : Enum.GetUnderlyingType(paramType); } rawValue = Convert.ChangeType(rawValue, paramType, System.Globalization.CultureInfo.InvariantCulture); } paramBuilder.SetConstant(rawValue); } } if (paramDef.IsMarshalledExplicitly) { // FieldMarshal var marshallingInformation = paramDef.MarshallingInformation; if (marshallingInformation != null) { paramBuilder.SetCustomAttribute(GetMarshalAsAttribute(marshallingInformation)); } else { Debug.Assert(!paramDef.MarshallingDescriptor.IsDefaultOrEmpty); // TODO: throw new NotImplementedException(); } } EmitCustomAttributes(paramBuilder, attributes); } }
/// <summary> /// Sets attributes of generated override/implement/export stub parameters. /// </summary> /// <param name="stub">The stub constructor builder. /// </param> /// <param name="formalParams">Formal parameters of the implementing PHP method.</param> /// <param name="templateParams">Parameters of the overload being overriden/implemented/exported.</param> public static void DefineStubParameters(ConstructorBuilder/*!*/ stub, PHP.Core.AST.FormalParam[] formalParams, ParameterInfo[]/*!*/ templateParams) { for (int i = 0; i < templateParams.Length; i++) { string name; // take the overriding parameter name if available if (formalParams != null && i < formalParams.Length) name = formalParams[i].Name.ToString(); else name = templateParams[i].Name; stub.DefineParameter(i + 1, templateParams[i].Attributes, name); } }
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index) { if (mb == null) builder = cb.DefineParameter (index, Attributes, Name); else builder = mb.DefineParameter (index, Attributes, Name); if (OptAttributes != null) OptAttributes.Emit (); }
private void ConvertConstructorParameters(ICommonMethodNode value, ConstructorBuilder methb) { ParameterBuilder pb = null; IParameterNode[] parameters = value.parameters; for (int i = 0; i < parameters.Length; i++) { object default_value = null; if (parameters[i].default_value != null) default_value = helper.GetConstantForExpression(parameters[i].default_value); ParameterAttributes pa = ParameterAttributes.None; if (parameters[i].parameter_type == parameter_type.var) pa = ParameterAttributes.Retval; if (default_value != null) pa |= ParameterAttributes.Optional; pb = methb.DefineParameter(i + 1, pa, parameters[i].name); if (default_value != null) pb.SetConstant(default_value); helper.AddParameter(parameters[i], pb); if (parameters[i].is_params) pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); } }
public override bool Define () { if (IsGeneric) { foreach (TypeParameter type_param in TypeParameters) { if (!type_param.Resolve (this)) return false; } foreach (TypeParameter type_param in TypeParameters) { if (!type_param.DefineType (this)) return false; } } member_cache = new MemberCache (TypeManager.multicast_delegate_type, this); // FIXME: POSSIBLY make this static, as it is always constant // Type [] const_arg_types = new Type [2]; const_arg_types [0] = TypeManager.object_type; const_arg_types [1] = TypeManager.intptr_type; const MethodAttributes ctor_mattr = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public; ConstructorBuilder = TypeBuilder.DefineConstructor (ctor_mattr, CallingConventions.Standard, const_arg_types); ConstructorBuilder.DefineParameter (1, ParameterAttributes.None, "object"); ConstructorBuilder.DefineParameter (2, ParameterAttributes.None, "method"); // // HACK because System.Reflection.Emit is lame // IParameterData [] fixed_pars = new IParameterData [] { new ParameterData ("object", Parameter.Modifier.NONE), new ParameterData ("method", Parameter.Modifier.NONE) }; AParametersCollection const_parameters = new ParametersImported ( fixed_pars, new Type[] { TypeManager.object_type, TypeManager.intptr_type }); TypeManager.RegisterMethod (ConstructorBuilder, const_parameters); member_cache.AddMember (ConstructorBuilder, this); ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.Runtime); // // Here the various methods like Invoke, BeginInvoke etc are defined // // First, call the `out of band' special method for // defining recursively any types we need: if (!Parameters.Resolve (this)) return false; // // Invoke method // // Check accessibility foreach (Type partype in Parameters.Types){ if (!IsAccessibleAs (partype)) { Report.SymbolRelatedToPreviousError (partype); Report.Error (59, Location, "Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'", TypeManager.CSharpName (partype), GetSignatureForError ()); return false; } } ReturnType = ReturnType.ResolveAsTypeTerminal (this, false); if (ReturnType == null) return false; ret_type = ReturnType.Type; if (!IsAccessibleAs (ret_type)) { Report.SymbolRelatedToPreviousError (ret_type); Report.Error (58, Location, "Inconsistent accessibility: return type `" + TypeManager.CSharpName (ret_type) + "' is less " + "accessible than delegate `" + GetSignatureForError () + "'"); return false; } CheckProtectedModifier (); if (RootContext.StdLib && TypeManager.IsSpecialType (ret_type)) { Method.Error1599 (Location, ret_type, Report); return false; } TypeManager.CheckTypeVariance (ret_type, Variance.Covariant, this); // // We don't have to check any others because they are all // guaranteed to be accessible - they are standard types. // CallingConventions cc = Parameters.CallingConvention; InvokeBuilder = TypeBuilder.DefineMethod ("Invoke", mattr, cc, ret_type, Parameters.GetEmitTypes ()); InvokeBuilder.SetImplementationFlags (MethodImplAttributes.Runtime); TypeManager.RegisterMethod (InvokeBuilder, Parameters); member_cache.AddMember (InvokeBuilder, this); // // Don't emit async method for compiler generated delegates (e.g. dynamic site containers) // if (TypeManager.iasyncresult_type != null && TypeManager.asynccallback_type != null && !IsCompilerGenerated) { DefineAsyncMethods (cc); } return true; }
public virtual void ApplyAttributes (MethodBuilder mb, ConstructorBuilder cb, int index) { if (mb == null) builder = cb.DefineParameter (index, Attributes, Name); else builder = mb.DefineParameter (index, Attributes, Name); if (OptAttributes != null) OptAttributes.Emit (); if (HasDefaultValue) { // // Emit constant values for true constants only, the other // constant-like expressions will rely on default value expression // Constant c = default_expr as Constant; if (c != null) { if (default_expr.Type == TypeManager.decimal_type) { builder.SetCustomAttribute (Const.CreateDecimalConstantAttribute (c)); } else { builder.SetConstant (c.GetValue ()); } } } if (TypeManager.IsDynamicType (parameter_type)) PredefinedAttributes.Get.Dynamic.EmitAttribute (builder, Location); }