protected internal override MAst Transform()
{
MAst test = Test.Transform();
MAst body = Body.Transform();
return(MAst.Loop(MAst.IfThenElse(test, body, MAst.Break(_breakLabel)), _breakLabel, _continueLabel));
}
protected internal override void CheckSemantics(AstHelper astHelper)
{
TypeName.CheckSemantics(astHelper);
Name.CheckSemantics(astHelper);
_parameter = MAst.Parameter(Type);
}
protected internal override MAst Transform()
{
MAst left = Left.Transform();
MAst right = Right.Transform();
switch (Operator)
{
case TigerOperator.Add:
return(MAst.Add(left, right));
case TigerOperator.Subtract:
return(MAst.Subtract(left, right));
case TigerOperator.Multiply:
return(MAst.Multiply(left, right));
case TigerOperator.Divide:
return(MAst.Divide(left, right));
case TigerOperator.Mod:
return(MAst.Modulo(left, right));
case TigerOperator.Power:
// todo handle doubles in operations
return
(MAst.Convert(
MAst.Power(MAst.Convert(left, typeof(double)), MAst.Convert(right, typeof(double))),
typeof(int)));
default:
throw new ArgumentOutOfRangeException();
}
}
protected internal override void CheckSemantics(AstHelper astHelper)
{
FunctionName.CheckSemantics(astHelper);
foreach (Expression expression in Parameters)
{
expression.CheckSemantics(astHelper);
}
Type[] parameterTypes = Parameters.Select(param => param.Type).ToArray();
if (!astHelper.Errors.Check(new FunctionNotDefinedError(FunctionName.Name, parameterTypes,
astHelper.Functions, Start)))
{
FunctionReference functionReference = astHelper.Functions[FunctionName.Name, parameterTypes];
_type = functionReference.ReturnType;
_pointer = functionReference.Function;
}
else
{
// if there is any error
_type = typeof(Null);
_pointer = MAst.Empty();
}
}
protected internal override MAst Transform()
{
return(_expecting.IsExpectingType
? _expecting.Type == typeof(bool)
? MAst.Constant(false, typeof(bool))
: MAst.Constant(null, _expecting.Type)
: MAst.Constant(null));
}
protected internal override MAst Transform()
{
ConstantExpression constant = MAst.Constant(_value, typeof(string));
return(Args.Count() == 0
? (MAst)constant
: MAst.Invoke(_stringFormatExpression,
constant,
MAst.NewArrayInit(typeof(object), from arg in Args select arg.Transform().Convert <object>())));
}
protected internal override MAst Transform()
{
IEnumerable <MAst> variableAssignments = from variableDeclarationExpression in VariableDeclarations
let variableAssign = variableDeclarationExpression.Transform()
select variableAssign;
IEnumerable <MAst> functionAssignments = from functionDefinitionExpression in FunctionDefinitions
let functionAssign = functionDefinitionExpression.Transform()
select functionAssign;
IEnumerable <MAst> letBody = functionAssignments.Union(variableAssignments).Union(new[] { Body.Transform() });
return(MAst.Block(_closure, letBody));
}
protected internal override void CheckSemantics(AstHelper astHelper)
{
base.CheckSemantics(astHelper);
_breakLabel = MAst.Label();
_continueLabel = MAst.Label();
Test.CheckSemantics(astHelper);
AstHelper child = astHelper.CreateChild(loop: true, breakLabel: _breakLabel, continueLabel: _continueLabel);
Body.CheckSemantics(child);
astHelper.Errors.Check(new WhileBodyReturnsValueError(Body.Type, Start));
}
protected internal override MAst Transform()
{
MAst target = Expression.Transform();
switch (Operator)
{
case TigerOperator.Not:
return(target.Not());
case TigerOperator.Negate:
return(MAst.Negate(target));
case TigerOperator.PreIncrementAssign:
return(MAst.PreIncrementAssign(target));
case TigerOperator.PreDecrementAssign:
return(MAst.PreDecrementAssign(target));
default:
throw new ArgumentOutOfRangeException();
}
}
protected internal override MAst Transform()
{
MAst left = Left.Transform();
MAst right = Right.Transform();
switch (Operator)
{
case TigerOperator.AndAlso:
return(MAst.AndAlso(left, right));
case TigerOperator.OrElse:
return(MAst.OrElse(left, right));
case TigerOperator.ExclusiveOr:
return(MAst.ExclusiveOr(left, right));
case TigerOperator.LessThan:
return(MAst.LessThan(left, right));
case TigerOperator.LessThanOrEqual:
return(MAst.LessThanOrEqual(left, right));
case TigerOperator.GreaterThan:
return(MAst.GreaterThan(left, right));
case TigerOperator.GreaterThanOrEqual:
return(MAst.GreaterThanOrEqual(left, right));
case TigerOperator.Equal:
return(MAst.Invoke(EqualsExpression, left.Convert <object>(), right.Convert <object>()));
case TigerOperator.NotEqual:
return(MAst.Invoke(NotEqualsExpression, left.Convert <object>(), right.Convert <object>()));
default:
throw new ArgumentOutOfRangeException();
}
}
protected internal override MAst Transform()
{
return(MAst.New(Constructor, from arg in Args select arg.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Assign(Left.Transform(), Right.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.IfThen(Test.Transform(), Then.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Call(Target.Transform(), _methodInfo, from arg in Args select arg.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.PropertyOrField(Target.Transform(), FieldName.Name));
}
protected internal override MAst Transform()
{
return(MAst.Block(from expression in Body.DefaultIfEmpty(new EmptyExpression())
select expression.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Invoke(_pointer.Function, from arg in Args select arg.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Return(_returnLabel, Value.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Convert(Expression.Transform(), Type));
}
protected internal override MAst Transform()
{
return(MAst.ArrayAccess(Target.Transform(), from index in Indexes
select index.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Default(Type));
}
protected internal override MAst Transform()
{
return(MAst.Condition(Test.Transform(), Then.Transform(), Else.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.NewArrayInit(InnerType, from initializer in Initializers select initializer.Transform()));
}
protected internal override MAst Transform()
{
return(MAst.Invoke(_pointer,
from parameter in Parameters
select parameter.Transform()));
}
