public SourceUnit(PhpSourceFile /*!*/ sourceFile, Encoding /*!*/ encoding, ILineBreaks /*!*/ lineBreaks)
{
Debug.Assert(sourceFile != null && encoding != null);
Debug.Assert(lineBreaks != null);
this.sourceFile = sourceFile;
this.encoding = encoding;
this.innerLineBreaks = lineBreaks;
this.naming = new NamingContext(null, null);
}
public void RemoveFrame()
{
Top -= ArgCount;
TypesTop -= TypeArgCount;
ArgCount = 0;
TypeArgCount = 0;
Callback = false;
Variables = null;
NamingContext = null;
//LateStaticBindType = null;
}
internal void RestoreCallState(CallState old)
{
TypeArgCount = old.TypeCount;
ArgCount = old.ArgCount;
Callback = old.Callback;
CalleeName = old.CalleeName;
Variables = old.Variables;
NamingContext = old.NamingContext;
AllowProtectedCall = old.AllowProtectedCall;
LateStaticBindType = old.LateStaticBindType;
}
public CallState(int argCount, int typeCount, Dictionary <string, object> variables, NamingContext namingContext,
string calleeName, bool callback, bool allowProtectedCall, DTypeDesc lateStaticBindType)
{
this.ArgCount = argCount;
this.TypeCount = typeCount;
this.Variables = variables;
this.NamingContext = namingContext;
this.CalleeName = calleeName;
this.Callback = callback;
this.AllowProtectedCall = allowProtectedCall;
this.LateStaticBindType = lateStaticBindType;
}
public static bool Assert(
object assertion,
ScriptContext context,
Dictionary <string, object> definedVariables,
DObject self,
DTypeDesc includer,
string containingSourcePath,
int line,
int column,
int containerId,
NamingContext namingContext)
{
object result;
string code;
// skips asserts if not active:
if (!context.Config.Assertion.Active)
{
return(true);
}
if ((code = PhpVariable.AsString(assertion)) != null)
{
// disables error reporting if eval should be quite:
if (context.Config.Assertion.Quiet)
{
context.DisableErrorReporting();
}
SourceCodeDescriptor descriptor = new SourceCodeDescriptor(containingSourcePath, containerId, line, column);
// evaluates the expression:
result = EvalInternal("return ", code, ";", EvalKinds.Assert, context, definedVariables, self, includer, descriptor, false, namingContext);
// restores error reporting if eval have been quite:
if (context.Config.Assertion.Quiet)
{
context.EnableErrorReporting();
}
}
else
{
result = assertion;
}
// checks the result of assertion:
return(CheckAssertion(result, code, context, containingSourcePath, line, column, namingContext));
}
public static object Eval(
string code,
bool synthetic,
ScriptContext context,
Dictionary <string, object> definedVariables,
DObject self,
DTypeDesc referringType,
string callerRelativeSourcePath,
int line,
int column,
int containerId,
NamingContext namingContext)
{
EvalKinds kind = synthetic ? EvalKinds.SyntheticEval : EvalKinds.ExplicitEval;
return(EvalInternal("", code, "", kind, context, definedVariables, self, referringType,
new SourceCodeDescriptor(callerRelativeSourcePath, containerId, line, column), false, namingContext));
}
public int MakeArgsAware(int encodedFormalCount)
{
int param_count = encodedFormalCount & 0xffff;
PeekAllValues(param_count);
int encoded_args_count = TypeArgCount << 16 | ArgCount;
// store encoded formal param count on the top of the items stack:
if (Top + 1 > Items.Length)
{
ResizeItems(Top + 1);
}
Items[Top++] = encoded_args_count;
ArgCount = 0;
TypeArgCount = 0;
Callback = false;
Variables = null;
NamingContext = null;
return(encoded_args_count);
}
public static bool CheckAssertion(
object assertion,
string code,
ScriptContext context,
string callerRelativeSourcePath,
int line,
int column,
NamingContext namingContext)
{
// checks assertion:
if (assertion != null && !PhpComparer./*Default.*/ CompareEq(assertion, false))
{
return(true);
}
// calls user callback:
if (context.Config.Assertion.Callback != null)
{
ApplicationConfiguration app_config = Configuration.Application;
FullPath full_path = new FullPath(callerRelativeSourcePath, app_config.Compiler.SourceRoot);
context.Config.Assertion.Callback.Invoke(full_path.FullFileName, line, code);
}
// reports a warning if required:
if (context.Config.Assertion.ReportWarning)
{
PhpException.Throw(PhpError.Warning, CoreResources.GetString("assertion_failed", code));
}
// terminates script execution if required:
if (context.Config.Assertion.Terminate)
{
throw new ScriptDiedException(0);
}
// assertion failed:
return(false);
}
public static T Call <T>(this ScriptContext context, string /*!*/ functionName, NamingContext namingContext,
Dictionary <string, object> callerLocalVariables, params object[] arguments)
where T : class
{
PhpReference rf = context.Call(functionName, namingContext, callerLocalVariables, arguments);
if (rf.Value == null)
{
return(null);
}
else
{
return(DuckTyping.Instance.ImplementDuckType <T>(rf.Value));
}
}
/// <summary>
/// Creates new object with given class name, naming context and arguments and then wraps it into
/// a duck type specified in generic type arguments.
/// </summary>
/// <typeparam name="T">Duck type interface to be used for wrapping.</typeparam>
/// <param name="className">Class name which will be used for new object creation.</param>
/// <param name="namingContext">Naming context.</param>
/// <param name="ctorArguments">Constructor arguments to be used.</param>
/// <returns>Dynamic object wrapped into static wrapper.</returns>
public static T NewObject <T>(this ScriptContext context, string /*!*/ className, NamingContext namingContext, params object[] ctorArguments)
{
//create new argument array and dig wrapped values out of it
object[] newCtorArgs = new object[ctorArguments.Length];
for (int i = 0; i < newCtorArgs.Length; i++)
{
IDuckType duck = ctorArguments[i] as IDuckType;
if (duck != null)
{
newCtorArgs[i] = duck.OriginalObject;
}
else
{
newCtorArgs[i] = ctorArguments[i];
}
}
object o = context.NewObject(className, namingContext, newCtorArgs);
return(DuckTyping.Instance.ImplementDuckType <T>(o));
}
/// <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>
/// Implements PHP <c>eval</c> construct with given code prefix and suffix.
/// A result of concatanation prefix + code + suffix is compiled.
/// Prefix should contain no new line characters.
/// </summary>
internal static object EvalInternal(
string prefix,
string code,
string suffix,
EvalKinds kind,
ScriptContext /*!*/ scriptContext,
Dictionary <string, object> localVariables,
DObject self,
DTypeDesc referringType,
SourceCodeDescriptor descriptor,
bool entireFile,
NamingContext namingContext)
{
Debug.Assert(prefix != null && suffix != null);
// composes code to be compiled:
code = String.Concat(prefix, code, suffix);
TransientAssemblyBuilder assembly_builder = scriptContext.ApplicationContext.TransientAssemblyBuilder;
// looks up the cache:
TransientModule module = assembly_builder.TransientAssembly.GetModule(scriptContext, referringType, code, descriptor);
if (module == null)
{
// double checked lock,
// if module != null, it is definitely completed
// since module is added into TransientAssembly at the end
// of assembly_builder.Build
lock (assembly_builder.TransientAssembly)
{
// lookup again, since it could be added into TransientAssembly while lock
module = assembly_builder.TransientAssembly.GetModule(scriptContext, referringType, code, descriptor);
if (module == null)
{
if (kind == EvalKinds.SyntheticEval)
{
Debug.WriteLine("SYN EVAL", "Eval cache missed: '{0}'", code.Substring(0, Math.Max(code.IndexOf('{'), 0)).TrimEnd());
}
else
{
Debug.WriteLine("EVAL", "Eval cache missed: '{0}'({1},{2})", descriptor.ContainingSourcePath, descriptor.Line, descriptor.Column);
}
CompilerConfiguration config = new CompilerConfiguration(Configuration.Application);
CompilationContext context = new CompilationContext(scriptContext.ApplicationContext, null, config,
new EvalErrorSink(-prefix.Length, config.Compiler.DisabledWarnings, config.Compiler.DisabledWarningNumbers),
scriptContext.WorkingDirectory);
TransientCompilationUnit unit = assembly_builder.Build(code, descriptor, kind, context,
scriptContext, referringType, namingContext, entireFile);
// compilation failed:
if (unit == null)
{
return(false);
}
module = unit.TransientModule;
}
}
}
// activates unconditionally declared types, functions and constants:
module.TransientCompilationUnit.Declare(scriptContext);
return(module.Main(scriptContext, localVariables, self, referringType, true));
}
