public void ChangeBase(TokenPosition basePosition)
{
if (_line <= 1)
_column = basePosition.Column + _column - 1;
_line = basePosition.Line + _line - 1;
}
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 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 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 static Expression Number(string token, TokenPosition position, Expression[] terms)
{
string s = token;
Type type = null;
if (!char.IsDigit(s[s.Length - 1]))
{
string suffix = "" + char.ToUpper(s[s.Length - 1]);
s = s.Remove(s.Length - 1);
if (!char.IsDigit(s[s.Length - 1]))
{
suffix = char.ToUpper(s[s.Length - 1]) + suffix;
s = s.Remove(s.Length - 1);
}
switch (suffix)
{
case "M":
type = typeof(decimal);
break;
case "D":
type = typeof(double);
break;
case "F":
type = typeof(float);
break;
case "L":
type = typeof(long);
break;
case "U":
type = typeof(uint);
break;
case "LU":
case "UL":
type = typeof(ulong);
break;
}
}
if (type != null)
return new ValueExpression(position, Convert.ChangeType(s, type, _numberFormat), type);
if (s.LastIndexOf('.') >= 0)
{
return Exp.Value(position, Convert.ToDouble(s, _numberFormat));
}
else
{
long n = Convert.ToInt64(s);
if (n > Int32.MaxValue || n < Int32.MinValue)
return Exp.Value(position, n);
else
return Exp.Value(position, (int)n);
}
}
public CoalesceExpression(TokenPosition position, Expression value, Expression valueIfNull) : base(position)
{
_value = value;
_valueIfNull = valueIfNull;
}
public static ValueExpression Value(TokenPosition position, object value, Type type)
{
return(new ValueExpression(position, value, type));
}
public DefaultValueExpression(TokenPosition position, Expression value, Expression defaultValue)
: base(position)
{
_value = value;
_defaultValue = defaultValue;
}
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 Unary(string token, TokenPosition position, Expression[] terms)
{
if (token == "!")
return new NegationExpression(position, terms[0]);
if (token == "-")
return new UnaryMinusExpression(position, terms[0]);
if (token == "~")
return new BitwiseComplementExpression(position, terms[0]);
return null;
}
public TextNode(TokenPosition position, string text)
{
Text = text;
Position = position;
}
public RangeExpression(TokenPosition tokenPosition, Expression from, Expression to) : base(tokenPosition)
{
_from = from;
_to = to;
}
public AsExpression(TokenPosition position, Expression objectExpression, Expression typeExpression) : base(position)
{
_objectExpression = objectExpression;
_typeExpression = typeExpression;
}
public TypeCastExpression(TokenPosition position, VariableExpression typeExpression, Expression targetExpression) : base(position)
{
_typeExpression = typeExpression;
_targetExpression = targetExpression;
}
public TemplateRenderingException(string message, Exception innerException, TokenPosition tokenPosition) : base(message, innerException, tokenPosition)
{
}
public LexerException(string message, TokenPosition position, string token, Exception innerException) : base(message, innerException)
{
Position = position;
Token = token;
}
public LexerException(TokenPosition position, string token)
{
Position = position;
Token = token;
}
public static Expression Function(string token, TokenPosition position, Expression[] terms)
{
Expression[] parameters = new Expression[terms.Length - 1];
Array.Copy(terms, 1, parameters, 0, parameters.Length);
if (token == "[")
{
return new IndexExpression(position, terms[0], parameters);
}
else
{
return new CallExpression(position, terms[0], parameters);
}
}
public static Expression DefaultValueOperator(string token, TokenPosition position, Expression[] terms)
{
return new DefaultValueExpression(position, terms[0], terms[1]);
}
public UnaryMinusExpression(TokenPosition position, Expression value) : base(position)
{
_value = value;
}
public static Expression Assignment(string token, TokenPosition position, Expression[] terms)
{
return new AssignmentExpression(position, terms[0], terms[1]);
}
public static Expression TypeOf(string token, TokenPosition position, Expression[] terms)
{
return(new TypeOfExpression(position));
}
public static Expression NumericRange(string token, TokenPosition position, Expression[] terms)
{
return new RangeExpression(position, terms[0], terms[1]);
}
public static Expression CharLiteral(string token, TokenPosition position, Expression[] terms)
{
return(Exp.Value(position, UnEscape(token.Substring(1, token.Length - 2), position)));
}
public static BinaryArithmicExpression Op(TokenPosition position, string op, Expression left, Expression right)
{
return(new BinaryArithmicExpression(position, op, left, right));
}
public IsExpression(TokenPosition position, Expression objectExpression, Expression typeExpression) : base(position)
{
_objectExpression = objectExpression;
_typeExpression = typeExpression;
}
public LexerException(TokenPosition position, string token)
{
Position = position;
Token = token;
}
public static Expression TypeOf(string token, TokenPosition position, Expression[] terms)
{
return new TypeOfExpression(position);
}
public static Expression Number(string token, TokenPosition position, Expression[] terms)
{
string s = token;
Type type = null;
if (!char.IsDigit(s[s.Length - 1]))
{
string suffix = "" + char.ToUpper(s[s.Length - 1]);
s = s.Remove(s.Length - 1);
if (!char.IsDigit(s[s.Length - 1]))
{
suffix = char.ToUpper(s[s.Length - 1]) + suffix;
s = s.Remove(s.Length - 1);
}
switch (suffix)
{
case "M":
type = typeof(decimal);
break;
case "D":
type = typeof(double);
break;
case "F":
type = typeof(float);
break;
case "L":
type = typeof(long);
break;
case "U":
type = typeof(uint);
break;
case "LU":
case "UL":
type = typeof(ulong);
break;
}
}
if (type != null)
{
return(new ValueExpression(position, Convert.ChangeType(s, type, _numberFormat), type));
}
if (s.LastIndexOf('.') >= 0)
{
return(Exp.Value(position, Convert.ToDouble(s, _numberFormat)));
}
else
{
long n = Convert.ToInt64(s);
if (n > Int32.MaxValue || n < Int32.MinValue)
{
return(Exp.Value(position, n));
}
else
{
return(Exp.Value(position, (int)n));
}
}
}
public UnknownTokenException(TokenPosition position, string token) : base(position, token)
{
}
public static Expression VarName(string token, TokenPosition position, Expression[] terms)
{
return(new VariableExpression(position, token));
}
public static Expression Coalesce(string token, TokenPosition position, Expression[] terms)
{
return(new CoalesceExpression(position, terms[0], terms[1]));
}
public ConditionalExpression(TokenPosition position, Expression condition, Expression trueValue, Expression falseValue) : base(position)
{
_condition = condition;
_trueValue = trueValue;
_falseValue = falseValue;
}
public static Expression DefaultValueOperator(string token, TokenPosition position, Expression[] terms)
{
return(new DefaultValueExpression(position, terms[0], terms[1]));
}
public static Expression CharLiteral(string token, TokenPosition position, Expression[] terms)
{
return Exp.Value(position, UnEscape(token.Substring(1, token.Length - 2), position));
}
public static Expression Operator(string token, TokenPosition position, Expression[] terms)
{
return(Exp.Op(position, token, terms[0], terms[1]));
}
public static Expression VarName(string token, TokenPosition position, Expression[] terms)
{
return new VariableExpression(position, token);
}
public static Expression Assignment(string token, TokenPosition position, Expression[] terms)
{
return(new AssignmentExpression(position, terms[0], terms[1]));
}
public static Expression Coalesce(string token, TokenPosition position, Expression[] terms)
{
return new CoalesceExpression(position, terms[0], terms[1]);
}
public static Expression StringLiteral(string token, TokenPosition position, Expression[] terms)
{
string s = token.Substring(1, token.Length - 2);
if (s.IndexOf('\\') < 0)
{
return(Exp.Value(position, s));
}
string output = "";
bool inEscape = false;
string hexString = null;
for (int i = 0; i < s.Length; i++)
{
char c = s[i];
if (inEscape)
{
if (c == 'x')
{
hexString = "";
continue;
}
if (hexString == null && (c != 'x' || c != 'X'))
{
output += UnEscape("\\" + c, position);
inEscape = false;
continue;
}
if (hexString == null)
{
inEscape = false;
}
else
{
if (((char.ToLower(c) < 'a' || char.ToLower(c) > 'f') && (c < '0' || c > '9')) || hexString.Length == 4)
{
output += UnEscape("\\x" + hexString, position);
inEscape = false;
hexString = null;
}
else
{
hexString += c;
continue;
}
}
}
if (c != '\\')
{
output += c;
continue;
}
inEscape = true;
}
return(Exp.Value(position, output));
}
public static Expression ShortcutOperator(string token, TokenPosition position, Expression[] terms)
{
if (token == "&&")
return new AndAlsoExpression(position, terms[0], terms[1]);
if (token == "||")
return new OrElseExpression(position, terms[0], terms[1]);
return null;
}
public static Expression Constructor(string token, TokenPosition position, Expression[] terms)
{
string className = token.Substring(3).Trim();
return(new ConstructorExpression(position, new VariableExpression(position, className), terms));
}
public static Expression Operator(string token, TokenPosition position, Expression[] terms)
{
return Exp.Op(position, token, terms[0], terms[1]);
}
public static Expression NumericRange(string token, TokenPosition position, Expression[] terms)
{
return(new RangeExpression(position, terms[0], terms[1]));
}
public static Expression StringLiteral(string token, TokenPosition position, Expression[] terms)
{
string s = token.Substring(1, token.Length - 2);
if (s.IndexOf('\\') < 0)
return Exp.Value(position, s);
string output = "";
bool inEscape = false;
string hexString = null;
for (int i = 0; i < s.Length; i++)
{
char c = s[i];
if (inEscape)
{
if (c == 'x')
{
hexString = "";
continue;
}
if (hexString == null && (c != 'x' || c != 'X'))
{
output += UnEscape("\\" + c, position);
inEscape = false;
continue;
}
if (hexString == null)
{
inEscape = false;
}
else
{
if (((char.ToLower(c) < 'a' || char.ToLower(c) > 'f') && (c < '0' || c > '9')) || hexString.Length == 4)
{
output += UnEscape("\\x" + hexString, position);
inEscape = false;
hexString = null;
}
else
{
hexString += c;
continue;
}
}
}
if (c != '\\')
{
output += c;
continue;
}
inEscape = true;
}
return Exp.Value(position, output);
}
public static Expression TypeCast(string token, TokenPosition position, Expression[] terms)
{
return(new TypeCastExpression(position, new VariableExpression(position, token.Substring(1, token.Length - 2).Trim()), terms[0]));
}
public static Expression Constructor(string token, TokenPosition position, Expression[] terms)
{
string className = token.Substring(3).Trim();
return new ConstructorExpression(position, new VariableExpression(position, className), terms);
}
public static Expression Ternary(string token, TokenPosition position, Expression[] terms)
{
return(new ConditionalExpression(position, terms[0], terms[1], terms[2]));
}
public static Expression TypeCast(string token, TokenPosition position, Expression[] terms)
{
return new TypeCastExpression(position, new VariableExpression(position, token.Substring(1, token.Length - 2).Trim()), terms[0]);
}
public CallExpression(TokenPosition position, Expression methodExpression, Expression[] parameters) : base(position)
{
_methodExpression = methodExpression;
_parameters = parameters;
}
public static Expression Ternary(string token, TokenPosition position, Expression[] terms)
{
return new ConditionalExpression(position, terms[0], terms[1], terms[2]);
}
public ConstructorExpression(TokenPosition position, VariableExpression className, Expression[] parameters) : base(position)
{
_className = className;
_parameters = parameters;
}
public BinaryArithmicExpression(TokenPosition position, string op, Expression left, Expression right) : base(position, left, right)
{
_operator = op;
}
public NegationExpression(TokenPosition position, Expression value) : base(position)
{
_value = value;
}
public OrElseExpression(TokenPosition position, Expression left, Expression right) : base(position, left, right)
{
}
public MultiplyExpression(TokenPosition position, Expression left, Expression right) : base(position, "*", left, right)
{
}
public LexerException(string message, TokenPosition position, string token, Exception innerException) : base(message, innerException)
{
Position = position;
Token = token;
}
public static ValueExpression <T> Value <T>(TokenPosition position, T value)
{
return(new ValueExpression <T>(position, value));
}
