C# Analyzer.AddCurrentRoutineProperty方法代码示例

		internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
		{
			analyzer.AddCurrentRoutineProperty(RoutineProperties.ContainsLocalsWorker);
			body.Analyze(analyzer);

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

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

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

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