internal FunctionPointerMethodSignature(FunctionPointerMethodSymbol underlying)
 {
     _underlying = underlying;
 }
Beispiel #2
0
            public override object VisitFunctionPointerType(FunctionPointerTypeSymbol symbol, StringBuilder builder)
            {
                FunctionPointerMethodSymbol signature = symbol.Signature;

                builder.Append("delegate*");

                switch (signature.CallingConvention)
                {
                case Cci.CallingConvention.Default:
                {
                    // no calling convention specified or managed
                    // FunctionPointerMethodSymbol.getCallingConvention returns Default for both
                    // TODO: should we always emit/omit `managed` keyword or add is specified property to FunctionPointerMethodSymbol
                    builder.Append("managed");
                    break;
                }

                case Cci.CallingConvention.Unmanaged:
                {
                    // unmanaged generic or with modifiers (SuppressGCTransition)
                    builder.Append("unmanaged");

                    ImmutableArray <NamedTypeSymbol> callingConventionTypeSymbols = signature.UnmanagedCallingConventionTypes;
                    if (callingConventionTypeSymbols.Length > 0)
                    {
                        builder.Append('[');
                        for (int i = 0; i < callingConventionTypeSymbols.Length; i++)
                        {
                            var    callingConventionTypeSymbol = callingConventionTypeSymbols[i];
                            string callingConventionTypeName   = callingConventionTypeSymbol.Name;

                            int index = callingConventionTypeName.IndexOf("CallConv");
                            if (index != -1)
                            {
                                callingConventionTypeName = callingConventionTypeName.Substring(index + "CallConv".Length);
                            }

                            builder.Append(callingConventionTypeName);

                            if (i < callingConventionTypeSymbols.Length - 1)
                            {
                                builder.Append(',');
                            }
                        }
                        builder.Append(']');
                    }
                    break;
                }

                case Cci.CallingConvention.CDecl:
                {
                    builder.Append("unmanaged[Cdecl]");
                    break;
                }

                case Cci.CallingConvention.FastCall:
                {
                    builder.Append("unmanaged[Fastcall]");
                    break;
                }

                case Cci.CallingConvention.Standard:
                {
                    builder.Append("unmanaged[Stdcall]");
                    break;
                }

                case Cci.CallingConvention.ThisCall:
                {
                    builder.Append("unmanaged[Thiscall]");
                    break;
                }

                default:
                {
                    // TODO: throw unsupported exception?
                    break;
                }
                }

                builder.Append('<');
                ImmutableArray <ParameterSymbol> parameters = signature.Parameters;

                s_parameterOrReturnTypeInstance.VisitParameters(parameters, isVararg: false, emitBrackets: false, builder);

                if (parameters.Length > 0)
                {
                    builder.Append(',');
                }

                s_parameterOrReturnTypeInstance.Visit(signature.ReturnType, builder);
                builder.Append('>');

                return(null);
            }