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