internal override void EmitLoadTypeDesc(CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags) { // disallow generic parameters on generic type which already has generic arguments: codeGenerator.EmitLoadTypeDescOperator(null, classNameVar, flags | ((genericParams.Count > 0) ? ResolveTypeFlags.SkipGenericNameParsing : 0)); EmitMakeGenericInstantiation(codeGenerator, flags); }
internal override void EmitLoadTypeDesc(CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags) { ILEmitter il = codeGenerator.IL; Debug.Assert(resolvedType != null); // disallow generic parameters on generic type which already has generic arguments: resolvedType.EmitLoadTypeDesc(codeGenerator, flags | ((genericParams.Count > 0) ? ResolveTypeFlags.SkipGenericNameParsing : 0)); // constructed type already emited its generic parameters: if (!(resolvedType is ConstructedType)) { EmitMakeGenericInstantiation(codeGenerator, flags); } }
/// <summary> /// Calls the method referred by <paramref name="methodName"/> from the user defined /// object <paramref name="classNameOrObject"/> with parameters <paramref name="args"/>. /// </summary> /// <param name="caller">DTypeDesc of the caller's class context. Can be UnknownTypeDesc.</param> /// <param name="methodName">The name of the method.</param> /// <param name="classNameOrObject">An instance to invoke the method on or a class name.</param> /// <param name="args">Parameters to invoke the method with.</param> /// <returns>The method's return value (always dereferenced).</returns> internal static object CallUserMethodInternal(DTypeDesc caller, string methodName, object classNameOrObject, ICollection args) { PhpException.Throw(PhpError.Notice, LibResources.GetString("call_user_method_deprecated")); object ret_val = false; DObject obj; string class_name; ScriptContext context = ScriptContext.CurrentContext; //DTypeDesc classContext = PhpStackTrace.GetClassContext(); // TODO: GetClassContext only if needed by context.ResolveType if (caller != null && caller.IsUnknown) { caller = PhpStackTrace.GetClassContext(); } if ((obj = classNameOrObject as DObject) != null) { // push arguments on stack context.Stack.AddFrame(args); ret_val = obj.InvokeMethod(methodName, caller, context); } else if ((class_name = PhpVariable.AsString(classNameOrObject)) != null) { // push arguments on stack context.Stack.AddFrame(args); ResolveTypeFlags flags = ResolveTypeFlags.UseAutoload | ResolveTypeFlags.ThrowErrors; DTypeDesc type = PHP.Core.Convert.ObjectToTypeDesc(class_name, flags, caller, context, null, null); ret_val = Operators.InvokeStaticMethod(type, methodName, null, caller, context); } else { PhpException.InvalidArgument("classNameOrObject", LibResources.GetString("arg:not_object_or_class_name")); } return(PhpVariable.Dereference(ret_val)); }
private void EmitLoadTypeDesc(string typeFullName, TypeRef typeNameRef, DType type, ResolveTypeFlags flags) { DebugHelper.AssertNonNull(1, typeFullName, typeNameRef, type); if (typeFullName != null) EmitLoadTypeDescOperator(typeFullName, null, flags); else if (typeNameRef != null) typeNameRef.EmitLoadTypeDesc(this, flags); else type.EmitLoadTypeDesc(this, flags); }
/// <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)); }
internal abstract void EmitLoadTypeDesc(CodeGenerator/*!*/ codeGenerator, ResolveTypeFlags flags);
internal override void EmitLoadTypeDesc(CodeGenerator/*!*/ codeGenerator, ResolveTypeFlags flags) { // disallow generic parameters on generic type which already has generic arguments: codeGenerator.EmitLoadTypeDescOperator(null, classNameVar, flags | ((genericParams.Count > 0) ? ResolveTypeFlags.SkipGenericNameParsing : 0)); EmitMakeGenericInstantiation(codeGenerator, flags); }
internal override void EmitLoadTypeDesc(CodeGenerator/*!*/ codeGenerator, ResolveTypeFlags flags) { ILEmitter il = codeGenerator.IL; Debug.Assert(resolvedType != null); // disallow generic parameters on generic type which already has generic arguments: resolvedType.EmitLoadTypeDesc(codeGenerator, flags | ((genericParams.Count > 0) ? ResolveTypeFlags.SkipGenericNameParsing : 0)); // constructed type already emited its generic parameters: if (!(resolvedType is ConstructedType)) EmitMakeGenericInstantiation(codeGenerator, flags); }
internal override void EmitLoadTypeDesc(CodeGenerator/*!*/ codeGenerator, ResolveTypeFlags flags) { type.EmitLoadTypeDesc(codeGenerator, ResolveTypeFlags.SkipGenericNameParsing); }
/// <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)); } }
internal override void EmitLoadTypeDesc(CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags) { type.EmitLoadTypeDesc(codeGenerator, ResolveTypeFlags.SkipGenericNameParsing); }
/// <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)); } }
internal abstract void EmitLoadTypeDesc(CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags);
void ITypeRefCompiler.EmitLoadTypeDesc(TypeRef node, CodeGenerator codeGenerator, ResolveTypeFlags flags) { this.EmitLoadTypeDesc((T)node, codeGenerator, flags); }
internal void EmitLoadTypeDescOperator(string typeFullName, Expression typeNameExpr, ResolveTypeFlags flags) { Debug.Assert(typeFullName != null ^ typeNameExpr != null); // LOAD Convert.ObjectToTypeDesc(<name>, <use autoload>, <context type desc>, <script context>, <naming context>/*, <locals>*/); EmitName(typeFullName, typeNameExpr, false); il.LdcI4((int)flags); EmitLoadClassContext(); EmitLoadScriptContext(); EmitLoadNamingContext(); EmitLoadGenericArgsArray(); il.Emit(OpCodes.Call, (typeFullName != null) ? Methods.Convert.StringToTypeDesc : Methods.Convert.ObjectToTypeDesc); }
/// <summary> /// Attempts to bind this callback to its target. /// </summary> /// <param name="quiet"><B>true</B> of no errors should be thrown, <B>false</B> otherwise.</param> /// <param name="nameContext">Current <see cref="NamingContext"/> for function and class name resolution.</param> /// <param name="caller">Current class context or a <see cref="UnknownTypeDesc"/> if the class context /// should be determined ad-hoc.</param> /// <returns><B>True</B> if the callback was successfully bound, <B>false</B> if an error occured.</returns> public bool Bind(bool quiet, DTypeDesc caller, NamingContext nameContext) { if (IsInvalid) { return(false); } switch (state) { case State.UnboundFunction: { if (context == null) { context = ScriptContext.CurrentContext; } routineDesc = context.ResolveFunction(targetName, nameContext, quiet); if (routineDesc == null) { return(false); } state = State.Bound; return(true); } case State.UnboundStaticMethod: { if (context == null) { context = ScriptContext.CurrentContext; } if (caller != null && caller.IsUnknown) { callingContext = PhpStackTrace.GetClassContext(); } else { callingContext = caller; } // try to find the CLR method // find the class according to className ResolveTypeFlags flags = ResolveTypeFlags.UseAutoload; if (!quiet) { flags |= ResolveTypeFlags.ThrowErrors; } DTypeDesc type = context.ResolveType(className, nameContext, callingContext, null, flags); if (type == null) { return(false); } // find the method bool is_caller_method; lateStaticBindType = type; routineDesc = Operators.GetStaticMethodDesc(type, targetName, ref instance, callingContext, context, quiet, false, out is_caller_method); if (routineDesc == null) { return(false); } if (instance != null) { dummyInstance = true; } state = is_caller_method ? State.BoundToCaller : State.Bound; return(true); } case State.UnboundInstanceMethod: { if (caller != null && caller.IsUnknown) { callingContext = PhpStackTrace.GetClassContext(); } else { callingContext = caller; } // ask the instance for a handle to the method bool is_caller_method; routineDesc = instance.GetMethodDesc(targetName, callingContext, quiet, out is_caller_method); if (routineDesc == null) { return(false); } state = (is_caller_method ? State.BoundToCaller : State.Bound); return(true); } } return(true); }
/// <summary> /// Loads <see cref="DTypeDesc"/> of runtime type of current method. /// </summary> /// <param name="flags">Ignored.</param> internal void EmitLoadStaticTypeDesc(ResolveTypeFlags flags) { // if we have a type place, use it: if (this.LateStaticBindTypePlace != null) { this.LateStaticBindTypePlace.EmitLoad(this.il); } else { // not handled yet throw new NotImplementedException(); } }
public static void EmitLoadTypeDesc(this TypeRef /*!*/ node, CodeGenerator /*!*/ codeGenerator, ResolveTypeFlags flags) { var nodecompiler = node.NodeCompiler <ITypeRefCompiler>(); nodecompiler.EmitLoadTypeDesc(node, codeGenerator, flags); }