Esempio n. 1
0
        public static void EmitAddFrame(ILEmitter /*!*/ il, IPlace /*!*/ scriptContextPlace, int typeArgCount, int argCount,
                                        Action <ILEmitter, int> typeArgEmitter, Action <ILEmitter, int> /*!*/ argEmitter)
        {
            Debug.Assert(typeArgCount == 0 || typeArgEmitter != null);

            // type args:
            if (typeArgCount > 0)
            {
                scriptContextPlace.EmitLoad(il);
                il.Emit(OpCodes.Ldfld, Fields.ScriptContext_Stack);

                il.EmitOverloadedArgs(Types.DTypeDesc[0], typeArgCount, Methods.PhpStack.AddTypeFrame.ExplicitOverloads, typeArgEmitter);
            }

            // args:
            scriptContextPlace.EmitLoad(il);
            il.Emit(OpCodes.Ldfld, Fields.ScriptContext_Stack);

            il.EmitOverloadedArgs(Types.Object[0], argCount, Methods.PhpStack.AddFrame.ExplicitOverloads, argEmitter);

            il.Emit(OpCodes.Call, Methods.PhpStack.AddFrame.Overload(argCount));

            // AddFrame adds empty type frame by default, so if there are no type parameters, we can skip AddTypeFrame call:
            if (typeArgCount > 0)
            {
                il.Emit(OpCodes.Call, Methods.PhpStack.AddTypeFrame.Overload(typeArgCount));
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Emits code that loads type descriptors for all generic arguments and a call to
        /// <see cref="Operators.MakeGenericTypeInstantiation"/>.
        /// </summary>
        internal void EmitMakeGenericInstantiation(CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags)
        {
            ILEmitter il = codeGenerator.IL;

            il.EmitOverloadedArgs(Types.DTypeDesc[0], genericParams.Count, Methods.Operators.MakeGenericTypeInstantiation.ExplicitOverloads, delegate(ILEmitter eil, int i)
            {
                genericParams[i].EmitLoadTypeDesc(codeGenerator, flags);
            });

            if (genericParams.Count > 0)
            {
                il.Emit(OpCodes.Call, Methods.Operators.MakeGenericTypeInstantiation.Overload(genericParams.Count));
            }
        }
Esempio n. 3
0
            /// <summary>
            /// Emits code that loads type descriptors for all generic arguments and a call to
            /// <see cref="Operators.MakeGenericTypeInstantiation"/>.
            /// </summary>
            internal void EmitMakeGenericInstantiation(TypeRef node, CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags)
            {
                if (node.GenericParams == null || node.GenericParams.Count == 0)
                {
                    return;
                }

                ILEmitter il = codeGenerator.IL;

                il.EmitOverloadedArgs(Types.DTypeDesc[0], node.GenericParams.Count, Methods.Operators.MakeGenericTypeInstantiation.ExplicitOverloads, delegate(ILEmitter eil, int i)
                {
                    TypeRefHelper.EmitLoadTypeDesc(node.GenericParams[i], codeGenerator, flags);
                });

                if (node.GenericParams.Count > 0)
                {
                    il.Emit(OpCodes.Call, Methods.Operators.MakeGenericTypeInstantiation.Overload(node.GenericParams.Count));
                }
            }