Ejemplo n.º 1
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ParameterSignature" /> class.
 /// </summary>
 /// <param name="name">The parameter name.</param>
 /// <param name="parameterType">The parameter type.</param>
 /// <param name="isOutParameter">if set to <c>true</c>, this is an out parameter.</param>
 /// <param name="isRefParameter">if set to <c>true</c>, this is a reference parameter.</param>
 public ParameterSignature(string name, TypeSignature parameterType, bool isOutParameter, bool isRefParameter)
 {
     Name = name;
     ParameterType = parameterType;
     IsOutParameter = isOutParameter;
     IsRefParameter = isRefParameter;
 }
Ejemplo n.º 2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertySignature"/> class.
 /// </summary>
 /// <param name="identity">The Identity.</param>
 /// <param name="name">The name of the property.</param>
 /// <param name="declaringType">The declaring type.</param>
 /// <param name="propertyType">The property type.</param>
 public PropertySignature(
     string identity,
     string name,
     TypeSignature declaringType,
     TypeSignature propertyType)
 {
     Identity = identity;
     Name = name;
     DeclaringType = declaringType;
     PropertyType = propertyType;
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PropertySignature"/> class.
 /// </summary>
 /// <param name="identity">The Identity.</param>
 /// <param name="name">The name of the property.</param>
 /// <param name="declaringType">The declaring type.</param>
 /// <param name="propertyType">The property type.</param>
 public PropertySignature(
     string identity,
     string name,
     TypeSignature declaringType,
     TypeSignature propertyType)
 {
     _identity = identity;
     _name = name;
     _declaringType = declaringType;
     _propertyType = propertyType;
 }
        /// <summary>
        /// Gets the type of the dynamic object builder.
        /// </summary>
        /// <param name="properties">The properties.</param>
        /// <returns></returns>
        public static Type GetDynamicObjectBuilderType(IEnumerable<SLDataColumn> properties)
        {
            Type type;
            var signature = new TypeSignature(properties);

            if (!TypesCache.TryGetValue(signature, out type))
            {
                type = CreateDynamicObjectBuilderType(properties);
                TypesCache.Add(signature, type);
            }

            return type;
        } 
Ejemplo n.º 5
0
 internal static Type GetDynamicObjectBuilderType(ThrowingHashSet<IPropertyInfo> properties)
 {
     lock (SyncRoot)
     {
         TypeSignature signature = new TypeSignature(properties);
         Type type;
         if (!TypesCache.TryGetValue(signature, out type))
         {
             type = CreateDynamicObjectBuilderType(properties);
             TypesCache.Add(signature, type);
         }
         return type;
     }
 }
Ejemplo n.º 6
0
 /// <summary>
 /// Creates a method signature for an instance method  that has a number of parameters.
 /// </summary>
 /// <param name="returnType">The return type of the method.</param>
 /// <param name="parameterTypes">The parameter types.</param>
 /// <returns>The signature.</returns>
 public static MethodSignature CreateInstance(TypeSignature returnType, IEnumerable <TypeSignature> parameterTypes)
 => new MethodSignature(CallingConventionAttributes.HasThis, returnType, parameterTypes);
Ejemplo n.º 7
0
 /// <summary>
 /// Creates a method signature for a static method that has a number of parameters.
 /// </summary>
 /// <param name="returnType">The return type of the method.</param>
 /// <param name="parameterTypes">The parameter types.</param>
 /// <returns>The signature.</returns>
 public static MethodSignature CreateStatic(TypeSignature returnType, IEnumerable <TypeSignature> parameterTypes)
 => new MethodSignature(0, returnType, parameterTypes);
Ejemplo n.º 8
0
 /// <summary>
 /// Creates a new parameter-less method signature for a static method.
 /// </summary>
 /// <param name="returnType">The return type of the method.</param>
 /// <returns>The signature.</returns>
 public static MethodSignature CreateStatic(TypeSignature returnType)
 => new MethodSignature(0, returnType, Enumerable.Empty <TypeSignature>());
 internal ParameterSignature(TypeSignature type, bool isByRef)
 {
     Type    = type;
     IsByRef = isByRef;
 }
Ejemplo n.º 10
0
 public FunctionSignatureBuilder WithReturnType([NotNull] TypeSignature newReturnType)
 {
     _newReturnType = newReturnType;
     return(this);
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Creates a new field by type signature.
 /// </summary>
 internal FieldEntity CreateField(string name, TypeSignature signature, bool isStatic = false, bool prepare = false)
 {
     var fe = createFieldCore(name, isStatic, prepare);
     fe.TypeSignature = signature;
     return fe;
 }
Ejemplo n.º 12
0
 internal static ArrayTypeSignature Array(TypeSignature elementType, int rank)
 {
     return new ArrayTypeSignature(elementType, rank);
 }
Ejemplo n.º 13
0
 internal static PointerTypeSignature Pointer(TypeSignature pointedAtType)
 {
     return new PointerTypeSignature(pointedAtType);
 }
Ejemplo n.º 14
0
 public DefaultOperatorNode(TypeSignature type = null)
 {
     TypeSignature = type;
 }
Ejemplo n.º 15
0
 internal static QualifiedTypeSignature Qualified(TypeSignature left, string right)
 {
     return new QualifiedTypeSignature(left, right);
 }
Ejemplo n.º 16
0
        /// <summary>
        /// Returns a handle to a helper function for creating a new Object instance from the
        /// keys and values on the stack. This is used for the newobject ABC instruction. The keys
        /// must be of the String type and the values must be of the "any" type.
        /// </summary>
        /// <param name="size">The size argument to the newarray instruction, i.e. the number of
        /// key-value pairs on the stack.</param>
        /// <param name="handle">If a helper function is available or can be emitted, a handle to
        /// the function is set to this argument.</param>
        /// <returns>True if a helper function is available or can be created, otherwise false.</returns>
        public bool tryGetNewObjectHelper(int size, out EntityHandle handle)
        {
            handle = default;

            if (size > newObjectHelperMaxSize)
            {
                return(false);
            }

            if (m_newObjectHelperMethods[size] != null)
            {
                handle = m_newObjectHelperMethods[size].handle;
                return(true);
            }

            _createContainerTypeIfNotCreated();

            TypeSignature[] parameterTypes = new TypeSignature[size * 2];

            var typeSigForString = TypeSignature.forPrimitiveType(PrimitiveTypeCode.String);
            var typeSigForAny    = m_assemblyBuilder.metadataContext.getTypeSignature(typeof(ASAny));

            for (int i = 0; i < parameterTypes.Length; i++)
            {
                parameterTypes[i] = ((i & 1) == 0) ? typeSigForString : typeSigForAny;
            }

            string methodName = "newobject" + size.ToString(CultureInfo.InvariantCulture);

            var methodBuilder = m_containerType !.defineMethod(
                methodName,
                MethodAttributes.Public | MethodAttributes.Static,
                m_assemblyBuilder.metadataContext.getTypeSignature(typeof(ASObject)),
                parameterTypes
                );

            m_ilBuilder.reset();

            var objLocal = m_ilBuilder.declareLocal(typeof(ASObject));
            var dpLocal  = m_ilBuilder.declareLocal(typeof(DynamicPropertyCollection));

            m_ilBuilder.emit(ILOp.newobj, KnownMembers.objectCtor);
            m_ilBuilder.emit(ILOp.dup);
            m_ilBuilder.emit(ILOp.call, KnownMembers.getObjectDynamicPropCollection, 0);
            m_ilBuilder.emit(ILOp.stloc, dpLocal);
            m_ilBuilder.emit(ILOp.stloc, objLocal);

            // Object properties are set in top-to-bottom stack order.
            // So for example if the arguments are "a", 1, "b", 2, "a", 3 then the value of the property
            // "a" in the created object is 1, not 3.

            for (int i = size - 1; i >= 0; i--)
            {
                m_ilBuilder.emit(ILOp.ldloc, dpLocal);
                m_ilBuilder.emit(ILOp.ldarg, 2 * i);
                m_ilBuilder.emit(ILOp.ldarg, 2 * i + 1);
                m_ilBuilder.emit(ILOp.ldc_i4_1);    // isEnum = true
                m_ilBuilder.emit(ILOp.call, KnownMembers.dynamicPropCollectionSet, -4);
            }

            m_ilBuilder.emit(ILOp.ldloc, objLocal);
            m_ilBuilder.emit(ILOp.ret);

            methodBuilder.setMethodBody(m_ilBuilder.createMethodBody());

            m_newObjectHelperMethods[size] = methodBuilder;
            handle = methodBuilder.handle;

            return(true);
        }
Ejemplo n.º 17
0
 public static Func <E.TypeDef, E.TypeDef> ImplementTraversable(TypeSignature declaringType, (TypeField schema, FieldReference field)[] fields)
Ejemplo n.º 18
0
 public Function(TypeSignature ret, string name, List <Argument> args)
 {
     ReturnTypeSignature = ret;
     Name          = name;
     ArgumentsList = args;
 }
 private void UnsupportedArgumentType(TypeSignature argumentType)
 {
     _context.DiagnosticBag.RegisterException(
         new NotSupportedException($"Invalid or unsupported argument type {argumentType.FullName}."));
 }
Ejemplo n.º 20
0
 /// <summary>
 /// Creates a new security attribute with the provided type.
 /// </summary>
 /// <param name="type">The security attribute type.</param>
 public SecurityAttribute(TypeSignature type)
 {
     AttributeType = type;
 }
 WildcardTypeSignature(TypeSignatureKind typeSignatureKind, TypeSignature bound)
     : super(typeSignatureKind, "*") {
Ejemplo n.º 22
0
        private static TDescriptor BuildAppWithDescriptor <TDescriptor>(WindowsAssembly assembly, TypeSignature fieldType, TDescriptor descriptor, bool saveToDisk)
            where TDescriptor : MarshalDescriptor
        {
            const string fieldName = "MyField";

            // set up temp assembly.

            var tableStream       = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
            var fieldTable        = tableStream.GetTable <FieldDefinition>();
            var fieldMarshalTable = tableStream.GetTable <FieldMarshal>();

            // create temp field.
            var field = new FieldDefinition(fieldName,
                                            FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.HasFieldRva,
                                            new FieldSignature(fieldType));

            fieldTable.Add(field);

            // create field marshal.
            var marshal = new FieldMarshal(field, descriptor);

            field.FieldMarshal = marshal;
            fieldMarshalTable.Add(marshal);

            // build and validate.
            assembly    = Utilities.RebuildNetAssembly(assembly, saveToDisk);
            tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
            fieldTable  = tableStream.GetTable <FieldDefinition>();

            field = fieldTable.FirstOrDefault(x => x.Name == fieldName);
            Assert.IsNotNull(field);
            Assert.IsNotNull(field.FieldMarshal);
            Assert.AreEqual(descriptor.NativeType, field.FieldMarshal.MarshalDescriptor.NativeType);
            Assert.IsInstanceOfType(field.FieldMarshal.MarshalDescriptor, typeof(TDescriptor));
            return((TDescriptor)field.FieldMarshal.MarshalDescriptor);
        }
Ejemplo n.º 23
0
 /// <summary>
 /// Creates a new method with argument types given by function arguments.
 /// </summary>
 internal MethodEntity CreateMethod(string name, TypeSignature returnType, IEnumerable<FunctionArgument> args = null, bool isStatic = false, bool isVirtual = false, bool prepare = true)
 {
     return createMethodCore(name, isStatic, isVirtual, prepare, me =>
         {
             me.Arguments = new HashList<FunctionArgument>(args, x => x.Name);
             me.ReturnTypeSignature = returnType;
         }
     );
 }
Ejemplo n.º 24
0
 public TypeDesc(Type pt, TypeSignature ts, int b)
 {
     PinType = pt;
     TypeSig = ts;
     Size    = b;
 }
Ejemplo n.º 25
0
        /// <summary>
        /// Creates a new method with argument types given by function arguments.
        /// </summary>
        internal MethodEntity CreateMethod(string name, TypeSignature returnType, IEnumerable<FunctionArgument> args = null, bool isStatic = false, bool isVirtual = false, bool prepare = false)
        {
            var argHash = new HashList<FunctionArgument>();
            if(args != null)
                foreach (var curr in args)
                    argHash.Add(curr.Name, curr);

            var me = createMethodCore(name, isStatic, isVirtual, prepare);
            me.ReturnTypeSignature = returnType;
            me.Arguments = argHash;
            return me;
        }
Ejemplo n.º 26
0
 private static QualifiedTypeSignature Qualified(TypeSignature left, string right)
 {
     return(new QualifiedTypeSignature(left, right));
 }
Ejemplo n.º 27
0
 /// <summary>
 /// Initializes a new member signature.
 /// </summary>
 /// <param name="attributes">The attributes of the signature.</param>
 /// <param name="memberReturnType">The type of the object this member returns or contains.</param>
 protected MemberSignature(CallingConventionAttributes attributes, TypeSignature memberReturnType)
     : base(attributes)
 {
     MemberReturnType = memberReturnType;
 }
Ejemplo n.º 28
0
 private static ArrayTypeSignature Array(TypeSignature elementType, int rank)
 {
     return(new ArrayTypeSignature(elementType, rank));
 }
Ejemplo n.º 29
0
 /// <summary>
 /// Creates a new method signature with the provided return and parameter types.
 /// </summary>
 /// <param name="attributes">The attributes.</param>
 /// <param name="returnType">The return type of the method.</param>
 /// <param name="parameterTypes">The types of the parameter the method defines.</param>
 public MethodSignature(CallingConventionAttributes attributes, TypeSignature returnType, IEnumerable <TypeSignature> parameterTypes)
     : base(attributes, returnType, parameterTypes)
 {
 }
Ejemplo n.º 30
0
 private static PointerTypeSignature Pointer(TypeSignature pointedAtType)
 {
     return(new PointerTypeSignature(pointedAtType));
 }
Ejemplo n.º 31
0
 /// <summary>
 /// Creates a method signature for a static method that has a number of parameters.
 /// </summary>
 /// <param name="returnType">The return type of the method.</param>
 /// <param name="parameterTypes">The parameter types.</param>
 /// <returns>The signature.</returns>
 public static MethodSignature CreateStatic(TypeSignature returnType, params TypeSignature[] parameterTypes)
 => new MethodSignature(0, returnType, parameterTypes);
Ejemplo n.º 32
0
        public virtual TypeSignature ImportTypeSignature(TypeSignature signature)
        {
            if (signature is MsCorLibTypeSignature)
            {
                return(signature);
            }

            var typeDefOrRef = signature as TypeDefOrRefSignature;

            if (typeDefOrRef != null)
            {
                return(ImportTypeDefOrRefSignature(typeDefOrRef));
            }

            var arrayType = signature as ArrayTypeSignature;

            if (arrayType != null)
            {
                return(ImportArrayTypeSignature(arrayType));
            }

            var boxedType = signature as BoxedTypeSignature;

            if (boxedType != null)
            {
                return(ImportBoxedTypeSignature(boxedType));
            }

            var byRefType = signature as ByReferenceTypeSignature;

            if (byRefType != null)
            {
                return(ImportByRefTypeSignature(byRefType));
            }

            var functionPtrType = signature as FunctionPointerTypeSignature;

            if (functionPtrType != null)
            {
                return(ImportFunctionPointerTypeSignature(functionPtrType));
            }

            var genericType = signature as GenericInstanceTypeSignature;

            if (genericType != null)
            {
                return(ImportGenericInstanceTypeSignature(genericType));
            }

            var modOptType = signature as OptionalModifierSignature;

            if (modOptType != null)
            {
                return(ImportOptionalModifierSignature(modOptType));
            }

            var pinnedType = signature as PinnedTypeSignature;

            if (pinnedType != null)
            {
                return(ImportPinnedTypeSignature(pinnedType));
            }

            var pointerType = signature as PointerTypeSignature;

            if (pointerType != null)
            {
                return(ImportPointerTypeSignature(pointerType));
            }

            var modReqType = signature as RequiredModifierSignature;

            if (modReqType != null)
            {
                return(ImportRequiredModifierSignature(modReqType));
            }

            var sentinelType = signature as SentinelTypeSignature;

            if (sentinelType != null)
            {
                return(ImportSentinelTypeSignature(sentinelType));
            }

            var szArrayType = signature as SzArrayTypeSignature;

            if (szArrayType != null)
            {
                return(ImportSzArrayTypeSignature(szArrayType));
            }

            var genericParameter = signature as GenericParameterSignature;

            if (genericParameter != null)
            {
                return(ImportGenericParameterSignature(genericParameter));
            }

            throw new NotSupportedException("Invalid or unsupported type signature.");
        }
Ejemplo n.º 33
0
 /// <summary>
 /// Creates a new parameter-less method signature for an instance method.
 /// </summary>
 /// <param name="returnType">The return type of the method.</param>
 /// <returns>The signature.</returns>
 public static MethodSignature CreateInstance(TypeSignature returnType)
 => new MethodSignature(CallingConventionAttributes.HasThis, returnType, Enumerable.Empty <TypeSignature>());
Ejemplo n.º 34
0
        public void ParameterDefaultValues()
        {
            var type = TypeSignature.Interface("MyInterface2", ns, Accessibility.APublic);

            var method1 = MethodSignature.Instance("StringMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.String, "myParameter").WithDefault("default value"));
            var method2 = MethodSignature.Instance("ValueTypeMethod", type, Accessibility.APublic, TypeSignature.Int32, new MethodParameter(TypeSignature.FromType(typeof(Guid)), "myParameter").WithDefault(null));
            var typeDef = TypeDef.Empty(type)
                          .AddMember(MethodDef.InterfaceDef(method1))
                          .AddMember(MethodDef.InterfaceDef(method2));


            cx.AddType(typeDef);
            check.CheckOutput(cx);
        }
Ejemplo n.º 35
0
 /// <summary>
 /// Builds up an assembly qualified type name.
 /// </summary>
 /// <param name="signature">The type to convert to a string.</param>
 /// <returns>The built up type name.</returns>
 public static string GetAssemblyQualifiedName(TypeSignature signature) =>
 GetAssemblyQualifiedName(signature, true);
 private TypeSignature ParseByReferenceTypeSpec(TypeSignature typeName)
 {
     Expect(TypeNameTerminal.Ampersand);
     return(new ByReferenceTypeSignature(typeName));
 }
        private void WriteElement(TypeSignature argumentType, object element)
        {
            var writer = _context.Writer;

            if (argumentType.IsTypeOf("System", "Type"))
            {
                writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName((TypeSignature)element));
                return;
            }

            switch (argumentType.ElementType)
            {
            case ElementType.Boolean:
                writer.WriteByte((byte)((bool)element ? 1 : 0));
                break;

            case ElementType.Char:
                writer.WriteUInt16((char)element);
                break;

            case ElementType.I1:
                writer.WriteSByte((sbyte)element);
                break;

            case ElementType.U1:
                writer.WriteByte((byte)element);
                break;

            case ElementType.I2:
                writer.WriteInt16((short)element);
                break;

            case ElementType.U2:
                writer.WriteUInt16((ushort)element);
                break;

            case ElementType.I4:
                writer.WriteInt32((int)element);
                break;

            case ElementType.U4:
                writer.WriteUInt32((uint)element);
                break;

            case ElementType.I8:
                writer.WriteInt64((long)element);
                break;

            case ElementType.U8:
                writer.WriteUInt64((ulong)element);
                break;

            case ElementType.R4:
                writer.WriteSingle((float)element);
                break;

            case ElementType.R8:
                writer.WriteDouble((double)element);
                break;

            case ElementType.String:
                writer.WriteSerString(element as string);
                break;

            case ElementType.Object:
                TypeSignature innerTypeSig;
                object        value;

                if (element is null)
                {
                    // Most efficient way to store "null" is writing null as a string (two bytes).
                    innerTypeSig = argumentType.Module.CorLibTypeFactory.String;
                    value        = null;
                }
                else if (element is BoxedArgument boxedArgument)
                {
                    // Write the boxed argument.
                    innerTypeSig = boxedArgument.Type;
                    value        = boxedArgument.Value;
                }
                else
                {
                    _context.DiagnosticBag.RegisterException(new NotSupportedException(
                                                                 $"Object elements in a custom attribute signature should be either 'null' or an instance of {nameof(BoxedArgument)}."));

                    // Write null as a recovery.
                    innerTypeSig = argumentType.Module.CorLibTypeFactory.String;
                    value        = null;
                }

                TypeSignature.WriteFieldOrPropType(writer, innerTypeSig);
                WriteElement(innerTypeSig, value);
                break;

            case ElementType.SzArray:
                WriteArrayElement(
                    (SzArrayTypeSignature)argumentType,
                    element as IList <object> ?? new object[0],
                    element == null);
                break;

            case ElementType.Class:
            case ElementType.Enum:
            case ElementType.ValueType:
                WriteEnumValue(argumentType, element);
                break;

            default:
                UnsupportedArgumentType(argumentType);
                break;
            }
        }
 private TypeSignature ParsePointerTypeSpec(TypeSignature typeName)
 {
     Expect(TypeNameTerminal.Star);
     return(new PointerTypeSignature(typeName));
 }
Ejemplo n.º 39
0
        private static TagDataEntry GetEntry(TypeSignature type, int idx, ICCHeader header)
        {
            switch (type)
            {
                case TypeSignature.chromaticity:
                    return new chromaticityTagDataEntry(idx);
                case TypeSignature.colorantOrder:
                    return new colorantOrderTagDataEntry(idx);
                case TypeSignature.colorantTable:
                    return new colorantTableTagDataEntry(idx);
                case TypeSignature.curve:
                    return new curveTagDataEntry(idx);
                case TypeSignature.data:
                    return new dataTagDataEntry(idx);
                case TypeSignature.dateTime:
                    return new dateTimeTagDataEntry(idx);
                case TypeSignature.lut16:
                    return new lut16TagDataEntry(idx);
                case TypeSignature.lut8:
                    return new lut8TagDataEntry(idx);
                case TypeSignature.lutAToB:
                    return new lutAToBTagDataEntry(idx);
                case TypeSignature.lutBToA:
                    return new lutBToATagDataEntry(idx);
                case TypeSignature.measurement:
                    return new measurementTagDataEntry(idx);
                case TypeSignature.multiLocalizedUnicode:
                    return new multiLocalizedUnicodeTagDataEntry(idx, false);
                case TypeSignature.multiProcessElements:
                    return new multiProcessElementsTagDataEntry(idx);
                case TypeSignature.namedColor2:
                    return new namedColor2TagDataEntry(idx);
                case TypeSignature.parametricCurve:
                    return new parametricCurveTagDataEntry(idx);
                case TypeSignature.profileSequenceDesc:
                    return new profileSequenceDescTagDataEntry(idx, header);
                case TypeSignature.profileSequenceIdentifier:
                    return new profileSequenceIdentifierTagDataEntry(idx);
                case TypeSignature.responseCurveSet16:
                    return new responseCurveSet16TagDataEntry(idx);
                case TypeSignature.s15Fixed16Array:
                    return new s15Fixed16ArrayTagDataEntry(idx);
                case TypeSignature.signature:
                    return new signatureTagDataEntry(idx);
                case TypeSignature.text:
                    return new textTagDataEntry(idx);
                case TypeSignature.u16Fixed16Array:
                    return new u16Fixed16ArrayTagDataEntry(idx);
                case TypeSignature.uInt16Array:
                    return new uInt16ArrayTagDataEntry(idx);
                case TypeSignature.uInt32Array:
                    return new uInt32ArrayTagDataEntry(idx);
                case TypeSignature.uInt64Array:
                    return new uInt64ArrayTagDataEntry(idx);
                case TypeSignature.uInt8Array:
                    return new uInt8ArrayTagDataEntry(idx);
                case TypeSignature.viewingConditions:
                    return new viewingConditionsTagDataEntry(idx);
                case TypeSignature.XYZ:
                    return new XYZTagDataEntry(idx);

                default:
                    return new TagDataEntry();
            }
        }
        private void PrintTypeSig(TypeSignature typeSig)
        {
            switch (typeSig.ElementCode)
            {
            case TypeElementCode.Array:
            {
                if (typeSig.ElementType != null)
                {
                    PrintTypeSig(typeSig.ElementType);
                }

                PrintArrayDimensions(typeSig.ArrayDimensions);
            }
            break;

            case TypeElementCode.ByRef:
            {
                if (typeSig.ElementType != null)
                {
                    PrintTypeSig(typeSig.ElementType);
                }

                _builder.Append("&");
            }
            break;

            case TypeElementCode.CustomModifier:
            {
                if (typeSig.ElementType != null)
                {
                    PrintTypeSig(typeSig.ElementType);
                }
            }
            break;

            case TypeElementCode.FunctionPointer:
            {
                var callSite = ((FunctionPointer)typeSig).CallSite;

                PrintTypeSig(callSite.ReturnType);
                _builder.Append(" *");
                PrintMethodArguments(callSite.Arguments);
            }
            break;

            case TypeElementCode.GenericParameter:
            {
                PrintGenericParameterType((GenericParameterType)typeSig);
            }
            break;

            case TypeElementCode.GenericType:
            {
                PrintTypeRef(typeSig.DeclaringType, typeSig.GenericArguments.Count > 0);
                PrintGenericArguments(typeSig.GenericArguments);
            }
            break;

            case TypeElementCode.Pinned:
            {
                if (typeSig.ElementType != null)
                {
                    PrintTypeSig(typeSig.ElementType);
                }
            }
            break;

            case TypeElementCode.Pointer:
            {
                if (typeSig.ElementType != null)
                {
                    PrintTypeSig(typeSig.ElementType);
                }

                _builder.Append("*");
            }
            break;

            case TypeElementCode.DeclaringType:
                PrintTypeRef((TypeReference)typeSig);
                break;

            default:
                throw new InvalidOperationException();
            }
        }
Ejemplo n.º 41
0
 internal ParameterSignature(TypeSignature type, bool isByRef)
 {
     Type = type;
     IsByRef = isByRef;
 }
     : super(typeSignatureKind, "*") {
     this.bound = bound;
 }
Ejemplo n.º 43
0
 /// <summary>
 /// Creates a new field by type signature.
 /// </summary>
 internal FieldEntity CreateField(string name, TypeSignature signature, bool isStatic = false, bool prepare = true)
 {
     return createFieldCore(name, isStatic, prepare, fe => fe.TypeSignature = signature);
 }
Ejemplo n.º 44
0
        /// <summary>
        /// Creates a new method with argument types given by signatures.
        /// </summary>
        internal MethodEntity CreateMethod(string name, TypeSignature returnType, string[] argTypes = null, bool isStatic = false, bool isVirtual = false, bool prepare = true)
        {
            var args = argTypes?.Select((a, idx) => new FunctionArgument("arg" + idx.ToString(), a)).ToArray();

            return(CreateMethod(name, returnType, args, isStatic, isVirtual, prepare));
        }
Ejemplo n.º 45
0
        /// <summary>
        /// Creates a new method with argument types given by signatures.
        /// </summary>
        internal MethodEntity CreateMethod(string name, TypeSignature returnType, string[] argTypes = null, bool isStatic = false, bool isVirtual = false, bool prepare = false)
        {
            var args = argTypes == null
                ? null
                : argTypes.Select((a, idx) => new FunctionArgument("arg" + idx.ToString(), a)).ToArray();

            return CreateMethod(name, returnType, args, isStatic, isVirtual, prepare);
        }
 public ParameterSignatureBuilder WithType([NotNull] TypeSignature newType)
 {
     _newType = newType;
     return(this);
 }
Ejemplo n.º 47
0
 /// <summary>
 /// Creates a new field by type signature.
 /// </summary>
 internal FieldEntity CreateField(string name, TypeSignature signature, bool isStatic = false, bool prepare = true)
 {
     return(CreateFieldCore(name, isStatic, prepare, fe => fe.TypeSignature = signature));
 }
 ArrayTypeSignature(TypeSignature elementType)
     : super(TypeSignatureKind.ArrayType, "[" + elementType.Name) {