public LocalFuncExpr(Position position, IEnumerable <string> paramNames, FuncType type, IUnboundExpr body)
{
Position = position;
ParamNames.AddRange(paramNames);
Type = type;
Body = body;
}
public IUnboundExpr AcceptTransformer(IUnboundExprTransformer transformer)
{
Target = Target.AcceptTransformer(transformer);
Value = Value.AcceptTransformer(transformer);
return(transformer.Transform(this));
}
// <-- MATCH FlowExpr LINE? (CASE CaseExpr THEN Block)+ END
// | FlowExpr
private IUnboundExpr MatchExpr()
{
Position position;
if (ConsumeIf(TokenType.Match, out position))
{
IUnboundExpr matchExpr = FlowExpr();
ConsumeIf(TokenType.Line);
var cases = new List <MatchCase>();
Position casePosition;
while (ConsumeIf(TokenType.Case, out casePosition))
{
IPattern caseExpr = CaseExpr();
Consume(TokenType.Then);
IUnboundExpr bodyExpr = CaseBlock();
cases.Add(new MatchCase(casePosition, caseExpr, bodyExpr));
// optional line after case
ConsumeIf(TokenType.Line);
}
Consume(TokenType.End);
return(new MatchExpr(position, matchExpr, cases));
}
else
{
return(FlowExpr());
}
}
public IUnboundExpr Process(string name, IUnboundExpr arg)
{
var tuple = arg as TupleExpr;
if (tuple == null)
{
return(null);
}
if (tuple.Fields.Count != 2)
{
return(null);
}
if (name == "&")
{
// a & b -> if a then b else false
return(new IfExpr(arg.Position, tuple.Fields[0], tuple.Fields[1], new BoolExpr(Position.None, false)));
}
else if (name == "|")
{
// a | b -> if a then true else b
return(new IfExpr(arg.Position, tuple.Fields[0], new BoolExpr(Position.None, true), tuple.Fields[1]));
}
return(null);
}
public Expr(IUnboundExpr unbound)
{
if (unbound == null)
{
throw new ArgumentNullException("unbound");
}
Unbound = unbound;
}
public LetExpr(Position position, IEnumerable <string> names, IUnboundExpr condition,
IUnboundExpr thenBody, IUnboundExpr elseBody)
{
Position = position;
Names = new List <string>(names);
Condition = condition;
ThenBody = thenBody;
ElseBody = elseBody;
}
public IUnboundExpr Process(string name, IUnboundExpr arg)
{
string macro = name + " Expression";
if (mScript.HasFunction(macro))
{
var argument = ToValue(arg);
var result = mScript.Run(macro, argument);
return ToExpr(result);
}
return null;
}
public IUnboundExpr Process(string name, IUnboundExpr arg)
{
string macro = name + " Expression";
if (mScript.HasFunction(macro))
{
var argument = ToValue(arg);
var result = mScript.Run(macro, argument);
return(ToExpr(result));
}
return(null);
}
protected IUnboundExpr OneOrMoreLeft(TokenType separatorType, Func <IUnboundExpr> parseFunc, Func <IUnboundExpr, Token, IUnboundExpr, IUnboundExpr> combineFunc)
{
IUnboundExpr left = parseFunc();
while (CurrentIs(separatorType))
{
Token separator = Consume(separatorType);
IUnboundExpr right = parseFunc();
left = combineFunc(left, separator, right);
}
return(left);
}
private Define Define()
{
var names = new List <string>();
var position = CurrentPosition;
do
{
names.Add(Consume(TokenType.Name).StringValue);
}while (ConsumeIf(TokenType.Comma));
Consume(TokenType.LeftArrow);
IUnboundExpr body = Block();
return(new Define(position, names, body));
}
// <-- Expression LINE? | LINE (Expression LINE)+ <terminator>
/// <summary>
/// Parses a block terminated by "end" or a continue terminator. Used for blocks
/// that may end or be followed by something else (such as an "else" clause).
/// </summary>
/// <param name="continueTerminator"></param>
private IUnboundExpr InnerBlock(TokenType continueTerminator)
{
if (ConsumeIf(TokenType.Line))
{
var expressions = new List <IUnboundExpr>();
bool inBlock = true;
while (inBlock)
{
expressions.Add(Expression());
Consume(TokenType.Line);
if (CurrentIs(continueTerminator)) // don't consume
{
inBlock = false;
}
else if (ConsumeIf(TokenType.End))
{
inBlock = false;
}
}
return(new BlockExpr(expressions));
}
else
{
IUnboundExpr expr = Expression();
if (CurrentIs(TokenType.Else))
{
// don't consume
}
else if (CurrentIs(TokenType.Line, TokenType.Else))
{
// just consume the line
Consume(TokenType.Line);
}
// for inner blocks, allow a line at the end. this is for cases like:
// if foo then bar
// else bang
//
// only do this if there is an "else" after the line so that we don't
// eat the line after an "if/then"
return(expr);
}
}
public Function(Position position, string name, FuncType type, IEnumerable<string> paramNames, IUnboundExpr body,
IEnumerable<IBoundDecl> typeArgs, bool hasInferrableTypeArguments)
: base(position, name, typeArgs)
{
if (position == null) throw new ArgumentNullException("position");
if (type == null) throw new ArgumentNullException("type");
if (paramNames != null)
{
ParamNames.AddRange(paramNames);
}
Body = new Expr(body);
Type = type;
HasInferrableTypeArguments = hasInferrableTypeArguments;
}
public IUnboundExpr Process(string name, IUnboundExpr arg)
{
var tuple = arg as TupleExpr;
if (tuple == null) return null;
if (tuple.Fields.Count != 2) return null;
if (name == "&")
{
// a & b -> if a then b else false
return new IfExpr(arg.Position, tuple.Fields[0], tuple.Fields[1], new BoolExpr(Position.None, false));
}
else if (name == "|")
{
// a | b -> if a then true else b
return new IfExpr(arg.Position, tuple.Fields[0], new BoolExpr(Position.None, true), tuple.Fields[1]);
}
return null;
}
// <-- RecordExpr (ASSIGN (DOT | OPERATOR | e) Block)?
private IUnboundExpr AssignExpr()
{
IUnboundExpr expr = RecordExpr();
Position position;
if (ConsumeIf(TokenType.LeftArrow, out position))
{
bool isDot = false;
string opName = String.Empty;
if (ConsumeIf(TokenType.Dot))
{
isDot = true;
}
else if (CurrentIs(TokenType.Operator))
{
Token op = Consume(TokenType.Operator);
opName = op.StringValue;
}
IUnboundExpr value = Block();
mC.SetPosition(position);
if (isDot)
{
expr = mC.Assign(expr, mC.Call(value, expr));
}
else if (!String.IsNullOrEmpty(opName))
{
expr = mC.Assign(expr, mC.Op(expr, opName, value));
}
else
{
expr = mC.Assign(expr, value);
}
}
return(expr);
}
public IUnboundExpr Def(string name, IUnboundExpr value)
{
return(new DefineExpr(mPosition, name, value, false));
}
private Value ToValue(IUnboundExpr expr)
{
//### bob: implement me!
return(new Value(true));
}
public Function(Position position, string name, FuncType type, IEnumerable<string> paramNames, IUnboundExpr body)
: this(position, name, type, paramNames, body, null, false)
{
}
public Function(Position position, string name, FuncType type, IEnumerable <string> paramNames, IUnboundExpr body)
: this(position, name, type, paramNames, body, null, false)
{
}
public IUnboundExpr AcceptTransformer(IUnboundExprTransformer transformer)
{
Body = Body.AcceptTransformer(transformer);
return(transformer.Transform(this));
}
public IUnboundExpr Op(IUnboundExpr left, string op, IUnboundExpr right)
{
return Call(op, Tuple(left, right));
}
public IUnboundExpr Def(IList<string> names, IUnboundExpr value)
{
return new DefineExpr(mPosition, names, value, false);
}
public IUnboundExpr Assign(IUnboundExpr target, IUnboundExpr value)
{
return(new AssignExpr(mPosition, target, value));
}
private Value ToValue(IUnboundExpr expr)
{
//### bob: implement me!
return new Value(true);
}
public IUnboundExpr Call(string name, IUnboundExpr arg)
{
return(new CallExpr(new NameExpr(mPosition, name), arg));
}
public IUnboundExpr While(IUnboundExpr condition, IUnboundExpr body)
{
return(new WhileExpr(mPosition, condition, body));
}
public IUnboundExpr Op(IUnboundExpr left, string op, IUnboundExpr right)
{
return(Call(op, Tuple(left, right)));
}
public IUnboundExpr If(IUnboundExpr condition, IUnboundExpr thenBody, IUnboundExpr elseBody)
{
return(new IfExpr(mPosition, condition, thenBody, elseBody));
}
public IUnboundExpr Def(IList <string> names, IUnboundExpr value)
{
return(new DefineExpr(mPosition, names, value, false));
}
public IUnboundExpr Call(IUnboundExpr target, IUnboundExpr arg)
{
return new CallExpr(target, arg);
}
public IUnboundExpr Def(string name, IUnboundExpr value)
{
return new DefineExpr(mPosition, name, value, false);
}
public DefineExpr(Position position, IEnumerable <string> names, IUnboundExpr value, bool isMutable)
: this(isMutable, new Define[] { new Define(position, names, value) })
{
}
public IUnboundExpr If(IUnboundExpr condition, IUnboundExpr thenBody, IUnboundExpr elseBody)
{
return new IfExpr(mPosition, condition, thenBody, elseBody);
}
public Define(Position position, IEnumerable <string> names, IUnboundExpr value)
{
Position = position;
Names = new List <string>(names);
Value = value;
}
public MatchExpr(Position position, IUnboundExpr value, IList <MatchCase> cases)
{
Position = position;
Value = value;
Cases = cases;
}
/// <summary>
/// Instantiates a new instance of AssignExpr.
/// </summary>
/// <param name="position">Where the expression occurs in the source file.</param>
/// <param name="target">The target of the assignment.</param>
/// <param name="value">The value being assigned.</param>
public AssignExpr(Position position, IUnboundExpr target, IUnboundExpr value)
{
Position = position;
Target = target;
Value = value;
}
public LoopClause(Position position, string name, IUnboundExpr expression)
{
Position = position;
Name = name;
Expression = expression;
}
public MatchCase(Position position, IPattern caseExpr, IUnboundExpr body)
{
Position = position;
Pattern = caseExpr;
Body = body;
}
public Function(Position position, string name, FuncType type, IEnumerable <string> paramNames, IUnboundExpr body,
IEnumerable <IBoundDecl> typeArgs, bool hasInferrableTypeArguments)
: base(position, name, typeArgs)
{
if (position == null)
{
throw new ArgumentNullException("position");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (paramNames != null)
{
ParamNames.AddRange(paramNames);
}
Body = new Expr(body);
Type = type;
HasInferrableTypeArguments = hasInferrableTypeArguments;
}
public IUnboundExpr While(IUnboundExpr condition, IUnboundExpr body)
{
return new WhileExpr(mPosition, condition, body);
}
public IUnboundExpr Assign(IUnboundExpr target, IUnboundExpr value)
{
return new AssignExpr(mPosition, target, value);
}
public IUnboundExpr Call(string name, IUnboundExpr arg)
{
return new CallExpr(new NameExpr(mPosition, name), arg);
}
public DefineExpr(Position position, string name, IUnboundExpr value, bool isMutable)
: this(isMutable, new Define[] { new Define(position, new string[] { name }, value) })
{
}
public IUnboundExpr Call(IUnboundExpr target, IUnboundExpr arg)
{
return(new CallExpr(target, arg));
}
