internal override Evaluation Analyze(Analyzer /*!*/ analyzer, ExInfoFromParent info)
{
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsLocalsWorker);
body.Analyze(analyzer);
return(new Evaluation(this));
}
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsLocalsWorker);
body.Analyze(analyzer);
return new Evaluation(this);
}
public override Evaluation Analyze(AssertEx node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
// assertion:
if (analyzer.Context.Config.Compiler.Debug)
{
Evaluation code_evaluation = node.CodeEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo);
//Evaluation desc_evaluation = node.DescriptionEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo);
// string parameter is parsed and converted to an expression:
if (code_evaluation.HasValue)
{
_inlinedCode = Convert.ObjectToString(code_evaluation.Value);
if (!string.IsNullOrEmpty(_inlinedCode))
{
const string prefix = "return ";
// the position of the last character before the parsed string:
var statements = analyzer.BuildAst(node.CodeEx.Span.Start - prefix.Length + 1, String.Concat(prefix, _inlinedCode, ";"));
// code is unevaluable:
if (statements == null)
{
return(new Evaluation(node, true));
}
if (statements.Length > 1)
{
analyzer.ErrorSink.Add(Warnings.MultipleStatementsInAssertion, analyzer.SourceUnit, node.Span);
}
Debug.Assert(statements.Length > 0 && statements[0] is JumpStmt);
node.CodeEx = ((JumpStmt)statements[0]).Expression;
}
else
{
// empty assertion:
return(new Evaluation(node, true));
}
}
else
{
node.CodeEx = code_evaluation.Expression;
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsEval);
}
//
node.CodeEx = node.CodeEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
return(new Evaluation(node));
}
else
{
// replace with "true" value in release mode:
return(new Evaluation(node, true));
}
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer /*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
fileNameEx = fileNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsInclude);
analyzer.CurrentScope = this.scope;
return(new Evaluation(this));
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
fileNameEx = fileNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsInclude);
analyzer.CurrentScope = this.scope;
return new Evaluation(this);
}
public override Evaluation Analyze(EvalEx node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
node.Code = node.Code.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsEval);
return(new Evaluation(node));
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer /*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
// if the expression should be emitted:
if (characteristic == Characteristic.Dynamic || characteristic == Characteristic.StaticArgEvaluated)
{
fileNameEx = fileNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsInclude);
analyzer.CurrentScope = this.scope;
return(new Evaluation(this));
}
public override Evaluation Analyze(IncludingEx node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
// if the expression should be emitted:
if (characteristic == Characteristic.Dynamic || characteristic == Characteristic.StaticArgEvaluated)
{
node.Target = node.Target.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsInclude);
analyzer.CurrentScope = node.Scope;
return(new Evaluation(node));
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
// if the expression should be emitted:
if (characteristic == Characteristic.Dynamic || characteristic == Characteristic.StaticArgEvaluated)
{
fileNameEx = fileNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsInclude);
analyzer.CurrentScope = this.scope;
return new Evaluation(this);
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
base.Analyze(analyzer, info);
if (isMemberOf == null)
{
if (!(access == AccessType.Read
|| access == AccessType.Write
|| access == AccessType.ReadAndWrite
|| access == AccessType.None))
{
analyzer.CurrentVarTable.SetAllRef();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.IndirectLocalAccess);
}
varNameEx = varNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
return new Evaluation(this);
}
public override Evaluation Analyze(IndirectVarUse node, Analyzer analyzer, ExInfoFromParent info)
{
access = info.Access;
base.Analyze(node, analyzer, info);
if (node.IsMemberOf == null)
{
if (!(access == AccessType.Read ||
access == AccessType.Write ||
access == AccessType.ReadAndWrite ||
access == AccessType.None))
{
analyzer.CurrentVarTable.SetAllRef();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.IndirectLocalAccess);
}
node.varNameEx = node.VarNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
return(new Evaluation(node));
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer /*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
base.Analyze(analyzer, info);
if (isMemberOf == null)
{
if (!(access == AccessType.Read ||
access == AccessType.Write ||
access == AccessType.ReadAndWrite ||
access == AccessType.None))
{
analyzer.CurrentVarTable.SetAllRef();
}
analyzer.AddCurrentRoutineProperty(RoutineProperties.IndirectLocalAccess);
}
varNameEx = varNameEx.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
return(new Evaluation(this));
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
base.Analyze(analyzer, info);
nameExpr = nameExpr.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
callSignature.Analyze(analyzer, UnknownSignature.Default, info, false);
// function call:
if (isMemberOf == null)
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsIndirectFcnCall);
return new Evaluation(this);
}
/// <summary>
/// Analyze the method call (isMemberOf != null).
/// </summary>
/// <param name="analyzer"></param>
/// <param name="info"></param>
/// <returns></returns>
private Evaluation AnalyzeMethodCall(Analyzer/*!*/ analyzer, ref ExInfoFromParent info)
{
Debug.Assert(isMemberOf != null);
// $this->
DirectVarUse memberDirectVarUse = isMemberOf as DirectVarUse;
if (memberDirectVarUse != null && memberDirectVarUse.IsMemberOf == null && // isMemberOf is single variable
memberDirectVarUse.VarName.IsThisVariableName && // isMemberOf if $this
analyzer.CurrentType != null) // called in class context of known type
{
// $this->{qualifiedName}(callSignature)
bool runtimeVisibilityCheck, isCallMethod;
routine = analyzer.ResolveMethod(
analyzer.CurrentType,//typeof(this)
qualifiedName.Name,//.Namespace?
Position,
analyzer.CurrentType, analyzer.CurrentRoutine, false,
out runtimeVisibilityCheck, out isCallMethod);
Debug.Assert(runtimeVisibilityCheck == false); // can only be set to true if CurrentType or CurrentRoutine are null
if (!routine.IsUnknown)
{
// check __call
if (isCallMethod)
{
// TODO: generic args
var arg1 = new StringLiteral(this.Position, qualifiedName.Name.Value);
var arg2 = this.callSignature.BuildPhpArray();
this.callSignature = new CallSignature(
new List<ActualParam>(2) {
new ActualParam(arg1.Position, arg1, false),
new ActualParam(arg2.Position, arg2, false)
},
new List<TypeRef>());
}
// resolve overload if applicable:
RoutineSignature signature;
overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature);
Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload");
// analyze parameters:
callSignature.Analyze(analyzer, signature, info, false);
// get properties:
analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements());
return new Evaluation(this);
}
}
// by default, fall back to dynamic method invocation
routine = null;
callSignature.Analyze(analyzer, UnknownSignature.Default, info, false);
return new Evaluation(this);
}
/// <summary>
/// Analyze the function call (isMemberOf == null).
/// </summary>
/// <param name="analyzer"></param>
/// <param name="info"></param>
/// <returns></returns>
/// <remarks>This code fragment is separated to save the stack when too long Expression chain is being compiled.</remarks>
private Evaluation AnalyzeFunctionCall(Analyzer/*!*/ analyzer, ref ExInfoFromParent info)
{
Debug.Assert(isMemberOf == null);
// resolve name:
routine = analyzer.ResolveFunctionName(qualifiedName, position);
if (routine.IsUnknown)
{
// note: we've to try following at run time, there can be dynamically added namespaced function matching qualifiedName
// try fallback
if (this.fallbackQualifiedName.HasValue)
{
var fallbackroutine = analyzer.ResolveFunctionName(this.fallbackQualifiedName.Value, position);
if (fallbackroutine != null && !fallbackroutine.IsUnknown)
{
if (fallbackroutine is PhpLibraryFunction) // we are calling library function directly
routine = fallbackroutine;
}
}
if (routine.IsUnknown) // still unknown ?
Statistics.AST.AddUnknownFunctionCall(qualifiedName);
}
// resolve overload if applicable:
RoutineSignature signature;
overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature);
Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload");
if (routine is PhpLibraryFunction)
{
var opts = ((PhpLibraryFunction)routine).Options;
// warning if not supported function call is detected
if ((opts & FunctionImplOptions.NotSupported) != 0)
analyzer.ErrorSink.Add(Warnings.NotSupportedFunctionCalled, analyzer.SourceUnit, Position, QualifiedName.ToString());
// warning if function requiring locals is detected (performance critical)
if ((opts & FunctionImplOptions.NeedsVariables) != 0 && !analyzer.CurrentScope.IsGlobal)
analyzer.ErrorSink.Add(Warnings.UnoptimizedLocalsInFunction, analyzer.SourceUnit, Position, QualifiedName.ToString());
}
// analyze parameters:
callSignature.Analyze(analyzer, signature, info, false);
// get properties:
analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements());
// replaces the node if its value can be determined at compile-time:
object value;
return TryEvaluate(analyzer, out value) ?
new Evaluation(this, value) :
new Evaluation(this);
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer /*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
// assertion:
if (kind == EvalKinds.Assert)
{
if (analyzer.Context.Config.Compiler.Debug)
{
Evaluation code_evaluation = code.Analyze(analyzer, ExInfoFromParent.DefaultExInfo);
// string parameter is parsed and converted to an expression:
if (code_evaluation.HasValue)
{
inlinedCode = Convert.ObjectToString(code_evaluation.Value);
if (inlinedCode != "")
{
const string prefix = "return ";
// position setup:
Position pos = Position.Initial;
// the position of the last character before the parsed string:
pos.FirstLine = code.Position.FirstLine;
pos.FirstOffset = code.Position.FirstOffset - prefix.Length + 1;
pos.FirstColumn = code.Position.FirstColumn - prefix.Length + 1;
List <Statement> statements = analyzer.BuildAst(pos, String.Concat(prefix, inlinedCode, ";"));
// code is unevaluable:
if (statements == null)
{
return(new Evaluation(this, true));
}
if (statements.Count > 1)
{
analyzer.ErrorSink.Add(Warnings.MultipleStatementsInAssertion, analyzer.SourceUnit, position);
}
Debug.Assert(statements.Count > 0 && statements[0] is JumpStmt);
this.code = ((JumpStmt)statements[0]).Expression;
}
else
{
// empty assertion:
return(new Evaluation(this, true));
}
}
else
{
code = code_evaluation.Expression;
}
}
else
{
// replace with "true" value in release mode:
return(new Evaluation(this, true));
}
}
// it is not necessary to analyze an argument nor set the declaring function's contains-eval property
// in the case of synthetic eval:
if (kind != EvalKinds.SyntheticEval)
{
code = code.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsEval);
}
return(new Evaluation(this));
}
private bool AnalyzeMethodCallOnKnownType(Analyzer/*!*/ analyzer, ref ExInfoFromParent info, DType type)
{
if (type == null || type.IsUnknown)
return false;
bool runtimeVisibilityCheck, isCallMethod;
routine = analyzer.ResolveMethod(
type, qualifiedName.Name,
Position,
analyzer.CurrentType, analyzer.CurrentRoutine, false,
out runtimeVisibilityCheck, out isCallMethod);
if (routine.IsUnknown)
return false;
Debug.Assert(runtimeVisibilityCheck == false); // can only be set to true if CurrentType or CurrentRoutine are null
// check __call
if (isCallMethod)
{
// TODO: generic args
var arg1 = new StringLiteral(this.Position, qualifiedName.Name.Value);
var arg2 = this.callSignature.BuildPhpArray();
this.callSignature = new CallSignature(
new List<ActualParam>(2) {
new ActualParam(arg1.Position, arg1, false),
new ActualParam(arg2.Position, arg2, false)
},
new List<TypeRef>());
}
// resolve overload if applicable:
RoutineSignature signature;
overloadIndex = routine.ResolveOverload(analyzer, callSignature, position, out signature);
Debug.Assert(overloadIndex != DRoutine.InvalidOverloadIndex, "A function should have at least one overload");
// analyze parameters:
callSignature.Analyze(analyzer, signature, info, false);
// get properties:
analyzer.AddCurrentRoutineProperty(routine.GetCallerRequirements());
return true;
}
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Expression.Analyze"]/*'/>
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
// assertion:
if (kind == EvalKinds.Assert)
{
if (analyzer.Context.Config.Compiler.Debug)
{
Evaluation code_evaluation = code.Analyze(analyzer, ExInfoFromParent.DefaultExInfo);
// string parameter is parsed and converted to an expression:
if (code_evaluation.HasValue)
{
inlinedCode = Convert.ObjectToString(code_evaluation.Value);
if (inlinedCode != "")
{
const string prefix = "return ";
// position setup:
Position pos = Position.Initial;
// the position of the last character before the parsed string:
pos.FirstLine = code.Position.FirstLine;
pos.FirstOffset = code.Position.FirstOffset - prefix.Length + 1;
pos.FirstColumn = code.Position.FirstColumn - prefix.Length + 1;
List<Statement> statements = analyzer.BuildAst(pos, String.Concat(prefix, inlinedCode, ";"));
// code is unevaluable:
if (statements == null)
return new Evaluation(this, true);
if (statements.Count > 1)
analyzer.ErrorSink.Add(Warnings.MultipleStatementsInAssertion, analyzer.SourceUnit, position);
Debug.Assert(statements.Count > 0 && statements[0] is JumpStmt);
this.code = ((JumpStmt)statements[0]).Expression;
}
else
{
// empty assertion:
return new Evaluation(this, true);
}
}
else
{
code = code_evaluation.Expression;
}
}
else
{
// replace with "true" value in release mode:
return new Evaluation(this, true);
}
}
// it is not necessary to analyze an argument nor set the declaring function's contains-eval property
// in the case of synthetic eval:
if (kind != EvalKinds.SyntheticEval)
{
code = code.Analyze(analyzer, ExInfoFromParent.DefaultExInfo).Literalize();
analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsEval);
}
return new Evaluation(this);
}
