public ConditionalExpression(TokenPosition position, Expression condition, Expression trueValue, Expression falseValue)
     : base(position)
 {
     _condition = condition;
     _trueValue = trueValue;
     _falseValue = falseValue;
 }

        public static TokenPosition[] GetPositionsFromString(string s, TokenPosition? basePosition)
        {
            TokenPosition[] positions = new TokenPosition[s.Length];

            int currentLine = 1;
            int currentColumn = 1;

            for (int textIndex = 0; textIndex < s.Length; textIndex++)
            {
                char c = s[textIndex];

                positions[textIndex].Line = currentLine;
                positions[textIndex].Column = currentColumn;

                if (basePosition != null)
                    positions[textIndex].ChangeBase(basePosition.Value);

                if (c == '\n')
                {
                    currentLine++;
                    currentColumn = 1;
                }
                else if (c != '\r')
                    currentColumn++;
            }

            return positions;
        }

        public void ChangeBase(TokenPosition basePosition)
        {
            if (Line <= 1)
                Column = basePosition.Column + Column - 1;

            Line = basePosition.Line + Line - 1;
        }

 /// <summary>
 /// Create a field expression.
 /// </summary>
 /// <param name="position"></param>
 /// <param name="target"></param>
 /// <param name="member"></param>
 /// <param name="generics">An optional collection of genericTypes</param>
 public FieldExpression(TokenPosition position, Expression target, string member, Type[] genericTypes = null)
     : base(position)
 {
     _target = target;
     _member = member;
     _genericTypes = genericTypes;
 }

 public FunctionCallToken(string text, TokenEvaluator evaluator, TokenPosition position) : base(text)
 {
     Precedence = 20;
     TokenType = TokenType.FunctionCall;
     Evaluator = evaluator;
     TokenPosition = position;
 }

        public TokenPosition(TokenPosition parent, TokenPosition current) : this()
        {
            Line = parent.Line + current.Line - 1;

            Column = current.Column;

            if (current.Line <= 1)
                Column = parent.Column + current.Column - 1;
        }

        public ValueExpression(TokenPosition position, object value, Type type)
            : base(position)
        {
            Value = value;
            Type = type;

            if (Type == typeof(object) && Value != null)
                Type = Value.GetType();
        }

        public TokenPosition(TokenPosition parent, TokenPosition current)
        {
            _line = parent.Line + current.Line - 1;

            _column = current.Column;

            if (current.Line <= 1)
                _column = parent.Column + current.Column - 1;
        }

        public static Expression DotOperator(string token, TokenPosition position, Expression[] terms)
        {
            VariableExpression varExpression = terms[1] as VariableExpression;

            if (varExpression == null)
                throw new UnknownPropertyException("Unkown member " + terms[1], terms[1]);

            return new FieldExpression(position, terms[0], varExpression.VarName);
        }

        public static Expression IsAsOperator(string token, TokenPosition position, Expression[] terms)
        {
            if (token == "as")
                return new AsExpression(position, terms[0], terms[1]);

            if (token == "is")
                return new IsExpression(position, terms[0], terms[1]);

            return null;
        }

        private static char UnEscape(string s, TokenPosition position)
        {
            if (s.Length == 1)
                return s[0];

            if (s.Length == 2)
            {
                switch (s[1])
                {
                    case '\\':
                    case '\"':
                    case '\'':
                        return s[1];
                    case '0':
                        return (char)0;
                    case 'a':
                        return '\a';
                    case 'b':
                        return '\b';
                    case 'f':
                        return '\f';
                    case 'n':
                        return '\n';
                    case 'r':
                        return '\r';
                    case 't':
                        return '\t';
                    case 'v':
                        return '\v';
                    default:
                        throw new UnknownTokenException(position,s);
                }
            }
            else
            {
                return (char)Convert.ToUInt16(s.Substring(2), 16);
            }
        }

 public ReturnExpression(TokenPosition tokenPosition, Expression expression) : base(tokenPosition, expression)
 {
 }

 public UnknownTokenException(TokenPosition position, string token)
     : base(position,token)
 {
 }

 public AddExpression(TokenPosition position, Expression left, Expression right) : base(position, "+", left, right) { }

 public ConstructorExpression(TokenPosition position, VariableExpression className, Expression[] parameters)
     : base(position)
 {
     _className = className;
     _parameters = parameters;
 }

 public IfExpression(TokenPosition position, Expression condition)
     : base(position)
 {
     Condition = condition;
 }

 public MultiplyExpression(TokenPosition position, Expression left, Expression right)
     : base(position, "*", left, right)
 {
 }

        public static Expression InOperator(string token, TokenPosition position, Expression[] terms)
        {
            VariableExpression varExpression = terms[0] as VariableExpression;

            return new InExpression(position, varExpression, terms[1]);
        }

 public BinaryArithmicExpression(TokenPosition position, string op, Expression left, Expression right)
     : base(position, left, right)
 {
     _operator = op;
 }

 public static Expression Ternary(string token, TokenPosition position, Expression[] terms)
 {
     return new ConditionalExpression(position, terms[0], terms[1], terms[2]);
 }