C# TemplateContext.Evaluate方法代码示例

        public override void Evaluate(TemplateContext context)
        {
            switch (Operator)
            {
                case ScriptUnaryOperator.Not:
                {
                    var value = context.Evaluate(Right);
                    context.Result = !ScriptValueConverter.ToBool(value);
                }
                    break;
                case ScriptUnaryOperator.Negate:
                case ScriptUnaryOperator.Plus:
                {
                    var value = context.Evaluate(Right);

                    bool negate = Operator == ScriptUnaryOperator.Negate;

                    var customType = value as IScriptCustomType;
                    if (customType != null)
                    {
                        context.Result = customType.EvaluateUnaryExpression(this);
                    }
                    else if (value != null)
                    {
                        if (value is int)
                        {
                            context.Result = negate ? -((int) value) : value;
                        }
                        else if (value is double)
                        {
                            context.Result = negate ? -((double) value) : value;
                        }
                        else if (value is float)
                        {
                            context.Result = negate ? -((float) value) : value;
                        }
                        else if (value is long)
                        {
                            context.Result = negate ? -((long) value) : value;
                        }
                        else
                        {
                            throw new ScriptRuntimeException(this.Span,
                                $"Unexpected value [{value} / Type: {value?.GetType()}]. Cannot negate(-)/positive(+) a non-numeric value");
                        }
                    }
                }
                    break;
                case ScriptUnaryOperator.FunctionAlias:
                    context.Result = context.Evaluate(Right, true);
                    break;

                case ScriptUnaryOperator.FunctionParametersExpand:
                    // Function parameters expand is done at the function level, so here, we simply return the actual list
                    Right?.Evaluate(context);
                    break;
                default:
                    throw new ScriptRuntimeException(Span, $"Operator [{Operator}] is not supported");
            }
        }

        public void TestFrontMatter()
        {
            var options = new ParserOptions() {Mode = ScriptMode.FrontMatter};
            var template = ParseTemplate(@"{{ 
variable = 1
name = 'yes'
}}
This is after the frontmatter: {{ name }}
{{
variable + 1
}}", options);

            // Make sure that we have a front matter
            Assert.NotNull(template.Page.FrontMatter);

            var context = new TemplateContext();

            // Evaluate front-matter
            var frontResult = context.Evaluate(template.Page.FrontMatter);
            Assert.Null(frontResult);
            
            // Evaluate page-content
            context.Evaluate(template.Page);
            var pageResult = context.Output.ToString();
            Assert.AreEqual(@"This is after the frontmatter: yes
2", pageResult);
        }

        public override void Evaluate(TemplateContext context)
        {
            // unit test: 230-capture-statement.txt
            context.PushOutput();
            {
                context.Evaluate(Body);
            }
            var result = context.PopOutput();

            context.SetValue(Target, result);
        }

 public override void Evaluate(TemplateContext context)
 {
     var conditionValue = ScriptValueConverter.ToBool(context.Evaluate(Condition));
     if (conditionValue)
     {
         Then?.Evaluate(context);
     }
     else
     {
         base.Evaluate(context);
     }
 }

        public override void Evaluate(TemplateContext context)
        {
            // Call evaluate on the target, but don't automatically call the function as if it was a parameterless call.
            var targetFunction = context.Evaluate(Target, true);

            // Throw an exception if the target function is null
            if (targetFunction == null)
            {
                throw new ScriptRuntimeException(Target.Span, $"The target function [{Target}] is null");
            }

            context.Result = Call(context, this, targetFunction, Arguments);
        }

        public override void Evaluate(TemplateContext context)
        {
            // Check that the Target is actually a function
            var functionCall = Target as ScriptFunctionCall;
            if (functionCall == null)
            {
                var parameterLessFunction = context.Evaluate(Target, true);
                if (!(parameterLessFunction is IScriptCustomFunction))
                {
                    var targetPrettyname = ScriptSyntaxAttribute.Get(Target);
                    throw new ScriptRuntimeException(Target.Span, $"Expecting a direct function instead of the expression [{Target}/{targetPrettyname.Name}]");
                }

                context.BlockDelegates.Push(Body);
                context.Result = ScriptFunctionCall.Call(context, this, parameterLessFunction);
            }
            else
            {
                context.BlockDelegates.Push(Body);
                context.Result = context.Evaluate(functionCall);
            }
        }

        public override void Evaluate(TemplateContext context)
        {
            var scriptObject = new ScriptObject();
            foreach (var member in Members)
            {
                var variable = member.Key as ScriptVariable;
                var literal = member.Key as ScriptLiteral;

                var name = variable?.Name ?? literal?.Value?.ToString();
                scriptObject.SetValue(name, context.Evaluate(member.Value), false);
            }
            context.Result = scriptObject;
        }

        protected override void EvaluateImpl(TemplateContext context)
        {
            var loopIterator = context.Evaluate(Iterator);
            var iterator = loopIterator as IEnumerable;
            if (iterator != null)
            {
                var index = -1;
                object previousValue = null;
                bool escape = false;

                foreach (var value in iterator)
                {
                    if (!context.StepLoop())
                    {
                        return;
                    }

                    // We update on next run on previous value (in order to handle last)
                    if (index >= 0)
                    {
                        context.SetValue(ScriptVariable.LoopLast, false);
                        context.SetValue(Variable, previousValue);

                        if (!Loop(context, index))
                        {
                            escape = true;
                            break;
                        }
                    }

                    previousValue = value;
                    index++;
                }

                if (!escape && index >= 0 && context.StepLoop())
                {
                    context.SetValue(ScriptVariable.LoopLast, true);
                    context.SetValue(Variable, previousValue);
                    Loop(context, index);
                }
            }
            else if (loopIterator != null)
            {
                throw new ScriptRuntimeException(Iterator.Span, $"Unexpected type [{loopIterator.GetType()}] for iterator");
            }
        }

        protected override void EvaluateImpl(TemplateContext context)
        {
            var index = 0;
            while(context.StepLoop())
            {
                var conditionResult = ScriptValueConverter.ToBool(context.Evaluate(Condition));
                if (!conditionResult)
                {
                    break;
                }

                if (!Loop(context, index++))
                {
                    break;
                }
            };
        }

        public override void Evaluate(TemplateContext context)
        {
            var target = context.GetValue(Name);
            if (!(target is IScriptObject))
            {
                var targetName = target?.GetType().Name ?? "null";
                throw new ScriptRuntimeException(Name.Span, $"Invalid target property [{Name}] used for [with] statement. Must be a ScriptObject instead of [{targetName}]");
            }

            context.PushGlobal((IScriptObject)target);
            try
            {
                context.Evaluate(Body);
            }
            finally
            {
                context.PopGlobal();
            }
        }

        public static object Call(TemplateContext context, ScriptNode callerContext, object functionObject, List<ScriptExpression> arguments = null)
        {
            if (callerContext == null) throw new ArgumentNullException(nameof(callerContext));
            if (functionObject == null)
            {
                throw new ScriptRuntimeException(callerContext.Span, $"The target function [{callerContext}] is null");
            }
            var function = functionObject as ScriptFunction;
            var externFunction = functionObject as IScriptCustomFunction;

            if (function == null && externFunction == null)
            {
                throw new ScriptRuntimeException(callerContext.Span, $"Invalid object function [{functionObject?.GetType()}]");
            }

            ScriptBlockStatement blockDelegate = null;
            if (context.BlockDelegates.Count > 0)
            {
                blockDelegate = context.BlockDelegates.Pop();
            }

            var argumentValues = new ScriptArray();
            if (arguments != null)
            {
                foreach (var argument in arguments)
                {
                    var value = context.Evaluate(argument);

                    // Handle parameters expansion for a function call when the operator ^ is used
                    var unaryExpression = argument as ScriptUnaryExpression;
                    if (unaryExpression != null && unaryExpression.ExpandParameters(value, argumentValues))
                    {
                        continue;
                    }

                    argumentValues.Add(value);
                }
            }

            // Handle pipe arguments here
            if (context.PipeArguments.Count > 0)
            {
                var additionalArgument = context.PipeArguments.Pop();

                var value = context.Evaluate(additionalArgument);

                // Handle parameters expansion for a function call when the operator ~ is used
                var unaryExpression = additionalArgument as ScriptUnaryExpression;
                if (unaryExpression == null || !unaryExpression.ExpandParameters(value, argumentValues))
                {
                    argumentValues.Add(value);
                }
            }

            object result = null;
            context.EnterFunction(callerContext);
            try
            {
                if (externFunction != null)
                {
                    result = externFunction.Evaluate(context, callerContext, argumentValues, blockDelegate);
                }
                else
                {
                    context.SetValue(ScriptVariable.Arguments, argumentValues, true);

                    // Set the block delegate
                    if (blockDelegate != null)
                    {
                        context.SetValue(ScriptVariable.BlockDelegate, blockDelegate, true);
                    }
                    result = context.Evaluate(function.Body);
                }
            }
            finally
            {
                context.ExitFunction();
            }

            // Restore the flow state to none
            context.FlowState = ScriptFlowState.None;
            return result;
        }

 public override void Evaluate(TemplateContext context)
 {
     var valueObject = context.Evaluate(Value);
     context.SetValue(Target, valueObject);
     context.Result = valueObject;
 }

        public override void Evaluate(TemplateContext context)
        {
            var leftValueOriginal = context.Evaluate(Left);
            var leftValue = leftValueOriginal;
            var rightValueOriginal = context.Evaluate(Right);
            object rightValue = rightValueOriginal;

            if (Operator == ScriptBinaryOperator.EmptyCoalescing)
            {
                context.Result = leftValue ?? rightValue;
                return;
            }
            else if (Operator == ScriptBinaryOperator.And || Operator == ScriptBinaryOperator.Or)
            {
                var leftBoolValue = ScriptValueConverter.ToBool(leftValue);
                var rightBoolValue = ScriptValueConverter.ToBool(rightValue);
                if (Operator == ScriptBinaryOperator.And)
                {
                    context.Result = leftBoolValue && rightBoolValue;
                }
                else
                {
                    context.Result = leftBoolValue || rightBoolValue;
                }

                return;
            }
            else
            {
                switch (Operator)
                {
                    case ScriptBinaryOperator.ShiftLeft:
                    case ScriptBinaryOperator.ShiftRight:
                        if (leftValue is IList || rightValue is IList)
                        {
                            // Special path for IList to allow custom binary expression
                            context.Result = ScriptArray.CustomOperator.EvaluateBinaryExpression(this, leftValue,
                                rightValue);
                            return;
                        }
                        break;
                    case ScriptBinaryOperator.CompareEqual:
                    case ScriptBinaryOperator.CompareNotEqual:
                    case ScriptBinaryOperator.CompareGreater:
                    case ScriptBinaryOperator.CompareLess:
                    case ScriptBinaryOperator.CompareGreaterOrEqual:
                    case ScriptBinaryOperator.CompareLessOrEqual:
                    case ScriptBinaryOperator.Add:
                    case ScriptBinaryOperator.Substract:
                    case ScriptBinaryOperator.Multiply:
                    case ScriptBinaryOperator.Divide:
                    case ScriptBinaryOperator.DivideRound:
                    case ScriptBinaryOperator.Modulus:
                    case ScriptBinaryOperator.RangeInclude:
                    case ScriptBinaryOperator.RangeExclude:
                        var leftType = leftValue?.GetType();
                        var rightType = rightValue?.GetType();

                        if (leftValue is string || rightValue is string)
                        {
                            context.Result = CalculateToString(Operator, leftValue, rightValue);
                            {
                                // TODO: Log an error if CalculateToString return null?
                                //context.LogError(Span, $"Operation [{Operator}] on strings not supported");
                            }
                        }
                        else
                        {
                            context.Result = Calculate(Operator, leftValue, leftType, rightValue, rightType);
                        }
                        return;
                }
            }

            throw new ScriptRuntimeException(Span, $"Operator [{Operator.ToText()}] is not implemented for the left [{Left}] / right [{Right}]");
        }