public void Define(string name, object value)
{
if (name.StartsWith("$"))
{
throw ErrorFactory.CreateInvalidProgramError(
"Global variables must not be declared with var");
}
if (members.ContainsKey(name))
{
throw ErrorFactory.CreateAlreadyDefinedError(name);
}
this[name] = value;
}
public override object Walk(EqualityExpression node)
{
var lv = node.LeftExpression.Accept(this);
var rv = node.RightExpression.Accept(this);
switch (node.Operator)
{
case TokenType.Equal:
return(OpEqual(lv, rv));
case TokenType.NotEqual:
return(OpNotEqual(lv, rv));
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid equality operator");
}
}
public override object Walk(AdditiveExpression node)
{
var lv = node.LeftExpression.Accept(this);
var rv = node.RightExpression.Accept(this);
switch (node.Operator)
{
case TokenType.Plus:
return(OpAdd(lv, rv));
case TokenType.Minus:
return(OpMinus(lv, rv));
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid additive operator");
}
}
public override object Walk(RelationalExpression node)
{
var lv = node.LeftExpression.Accept(this);
switch (node.Operator)
{
case TokenType.LessThan:
return(OpLessThan(lv, node.RightExpression.Accept(this)));
case TokenType.LessThanOrEqual:
return(OpLessThanOrEqual(lv, node.RightExpression.Accept(this)));
case TokenType.GreaterThan:
return(OpGreaterThan(lv, node.RightExpression.Accept(this)));
case TokenType.GreaterThanOrEqual:
return(OpGreaterThanOrEqual(lv, node.RightExpression.Accept(this)));
case TokenType.Is:
if (lv == null)
{
return(new BikeBoolean(false));
}
var targetValue = node.RightExpression.Accept(this);
if (targetValue is BikeObject)
{
if (!(lv is BikeObject))
{
return(new BikeBoolean(false));
}
return(((BikeObject)targetValue).IsPrototypeOf((BikeObject)lv));
}
if (targetValue is Type)
{
return(new BikeBoolean(Is(lv, (Type)targetValue)));
}
throw ErrorFactory.CreateTypeError("The right expression must be a Bike.Object or System.Type");
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid relational operator");
}
}
public override object Walk(MultiplicativeExpression node)
{
var lv = node.LeftExpression.Accept(this);
var rv = node.RightExpression.Accept(this);
switch (node.Operator)
{
case TokenType.Multiply:
return(OpMultiply(lv, rv));
case TokenType.Divide:
return(OpDivide(lv, rv));
case TokenType.Modulus:
return(Modulus(lv, rv));
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid multiplicative operator");
}
}
public override object Walk(PrimitiveLiteral node)
{
switch (node.Type)
{
case TokenType.String:
return(new BikeString(node.Value));
case TokenType.Number:
return(new BikeNumber(decimal.Parse(node.Value)));
case TokenType.True:
return(new BikeBoolean(true));
case TokenType.False:
return(new BikeBoolean(false));
case TokenType.Null:
return(null);
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid primitive literal");
}
}
public override object Walk(UnaryExpression node)
{
var value = node.Expression.Accept(this);
if (node.Postfix != TokenType.None)
{
switch (node.Postfix)
{
case TokenType.DoublePlus:
{
var id = node.Expression.As <Identifier>("Identifier").Value;
Context.CurrentFrame.Assign(id, OpDoublePlus(value));
break;
}
case TokenType.DoubleMinus:
{
var id = node.Expression.As <Identifier>("Identifier").Value;
Context.CurrentFrame.Assign(id, OpDoubleMinus(value));
break;
}
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid unary postfix");
}
}
if (node.Prefix != TokenType.None)
{
switch (node.Prefix)
{
case TokenType.DoublePlus:
{
var id = node.Expression.As <Identifier>("Identifier").Value;
value = OpDoublePlus(value);
Context.CurrentFrame.Assign(id, value);
break;
}
case TokenType.DoubleMinus:
{
var id = node.Expression.As <Identifier>("Identifier").Value;
value = OpDoubleMinus(value);
Context.CurrentFrame.Assign(id, value);
break;
}
case TokenType.Plus:
value = OpPlus(value);
break;
case TokenType.Minus:
value = OpMinus(value);
break;
case TokenType.Not:
value = OpNot(value);
break;
default:
throw ErrorFactory.CreateInvalidProgramError("Invalid unary prefix");
}
}
return(value);
}
private object AssignSwitch(string @operator, object target, Node suffix,
Func <object> lvThunk, Func <object> rvThunk,
bool staticDotNetAssign = false)
{
switch (@operator)
{
case "=":
{
return(PerformAssign(target, suffix, rvThunk(), staticDotNetAssign));
}
case "*=":
{
var result = OpMultiply(lvThunk(), rvThunk());
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "/=":
{
var result = OpDivide(lvThunk(), rvThunk());
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "%=":
{
var result = Modulus(lvThunk(), rvThunk());
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "+=":
{
var rv = rvThunk();
if (rv is BikeFunction)
{
var fieldName = suffix.SuffixValue(this);
AddHandler(target, fieldName, (BikeFunction)rv, this, staticDotNetAssign);
var eventInfo = staticDotNetAssign
? ((Type)target).GetEvent(fieldName)
: target.GetType().GetEvent(fieldName);
// if delegate, return its value; if event, return null
return(eventInfo != null ? null : lvThunk());
}
var result = OpAdd(lvThunk(), rv);
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "-=":
{
var result = OpMinus(lvThunk(), rvThunk());
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "||=":
{
var result = OpOr(lvThunk(), rvThunk);
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
case "&&=":
{
var result = OpAnd(lvThunk(), rvThunk);
return(PerformAssign(target, suffix, result, staticDotNetAssign));
}
default:
throw ErrorFactory.CreateInvalidProgramError(string.Format("Invalid operator {0}", @operator));
}
}