public static Expression VarName(string token, TokenPosition position, Expression[] terms)
{
return(new VariableExpression(position, token));
}
public static OrElseExpression OrElse(TokenPosition position, Expression left, Expression right)
{
return(new OrElseExpression(position, left, right));
}
public static AddExpression Add(TokenPosition position, Expression left, Expression right)
{
return(new AddExpression(position, left, right));
}
public static ValueExpression <T> Value <T>(TokenPosition position, T value)
{
return(new ValueExpression <T>(position, value));
}
public static BinaryArithmicExpression Op(TokenPosition position, string op, Expression left, Expression right)
{
return(new BinaryArithmicExpression(position, op, left, right));
}
public NegationExpression(TokenPosition position, Expression value) : base(position)
{
_value = value;
}
public UnknownTokenException(TokenPosition position, string token) : base(position, token)
{
}
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 NumericRange(string token, TokenPosition position, Expression[] terms)
{
return(new RangeExpression(position, terms[0], terms[1]));
}
public static Expression Assignment(string token, TokenPosition position, Expression[] terms)
{
return(new AssignmentExpression(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 Operator(string token, TokenPosition position, Expression[] terms)
{
return(Exp.Op(position, token, terms[0], terms[1]));
}
public static Expression DefaultValueOperator(string token, TokenPosition position, Expression[] terms)
{
return(new DefaultValueExpression(position, terms[0], terms[1]));
}
public static Expression Coalesce(string token, TokenPosition position, Expression[] terms)
{
return(new CoalesceExpression(position, terms[0], terms[1]));
}
public UnaryMinusExpression(TokenPosition position, Expression value) : base(position)
{
_value = value;
}
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 TextNode(TokenPosition position, string text)
{
Text = text;
Position = position;
}
public static Expression Ternary(string token, TokenPosition position, Expression[] terms)
{
return(new ConditionalExpression(position, terms[0], terms[1], terms[2]));
}
public IsExpression(TokenPosition position, Expression objectExpression, Expression typeExpression) : base(position)
{
_objectExpression = objectExpression;
_typeExpression = typeExpression;
}
public ConditionalExpression(TokenPosition position, Expression condition, Expression trueValue, Expression falseValue) : base(position)
{
_condition = condition;
_trueValue = trueValue;
_falseValue = falseValue;
}
public static DivideExpression Divide(TokenPosition position, Expression left, Expression right)
{
return(new DivideExpression(position, left, right));
}
public SubtractExpression(TokenPosition position, Expression left, Expression right) : base(position, "-", left, right)
{
}
public static ValueExpression Value(TokenPosition position, object value, Type type)
{
return(new ValueExpression(position, value, type));
}
public RangeExpression(TokenPosition tokenPosition, Expression from, Expression to) : base(tokenPosition)
{
_from = from;
_to = to;
}
public static AndAlsoExpression AndAlso(TokenPosition position, Expression left, Expression right)
{
return(new AndAlsoExpression(position, left, right));
}
public AddExpression(TokenPosition position, Expression left, Expression right) : base(position, "+", left, right)
{
}
protected Expression(TokenPosition tokenPosition)
{
TokenPosition = tokenPosition;
}
public TypeCastExpression(TokenPosition position, VariableExpression typeExpression, Expression targetExpression) : base(position)
{
_typeExpression = typeExpression;
_targetExpression = targetExpression;
}
public static SubtractExpression Subtract(TokenPosition position, Expression left, Expression right)
{
return(new SubtractExpression(position, left, right));
}
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));
}
}
}
