protected override object DoEvaluate(ScriptingContext context)
            {
                F.Expression resolved = Expression.Resolve(context);
                if (resolved == null)
                {
                    throw new ScriptingException(
                              "Cannot resolve expression `{0}'", Name);
                }

                return(resolved.Evaluate(context));
            }
            protected override bool DoAssign(ScriptingContext context, TargetObject obj)
            {
                F.Expression resolved = Expression.Resolve(context);
                if (resolved == null)
                {
                    throw new ScriptingException(
                              "Cannot resolve expression `{0}'", Name);
                }

                resolved.Assign(context, obj);
                return(true);
            }
        protected SourceLocation DoParseExpression(ScriptingContext context,
                                                   LocationType type, string arg)
        {
            F.Expression     expr  = context.ParseExpression(arg);
            MethodExpression mexpr = expr.ResolveMethod(context, type);

            if (mexpr != null)
            {
                return(mexpr.EvaluateSource(context));
            }
            else
            {
                return(context.FindMethod(arg));
            }
        }
        public string EvaluateExpression(ScriptingContext context, string text,
                                         DisplayFormat format)
        {
            F.Expression expression = context.ParseExpression(text);

            try {
                expression = expression.Resolve(context);
            } catch (ScriptingException ex) {
                throw new ScriptingException("Cannot resolve expression `{0}': {1}",
                                             text, ex.Message);
            } catch {
                throw new ScriptingException("Cannot resolve expression `{0}'.", text);
            }

            try {
                object retval = expression.Evaluate(context);
                return(context.FormatObject(retval, format));
            } catch (ScriptingException ex) {
                throw new ScriptingException("Cannot evaluate expression `{0}': {1}",
                                             text, ex.Message);
            } catch {
                throw new ScriptingException("Cannot evaluate expression `{0}'.", text);
            }
        }
 public ExpressionWrapper(ExpressionParser parser, F.Expression expr)
     : base(parser)
 {
     this.Expression = expr;
 }