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);
}
