public NodeValueProg(NodeVoidProg voidProg, NodeExpr expr)
: base((IToken)null)
{
_voidProg = voidProg;
_expr = expr;
}
public abstract Task <NodeExpr> Eval(NodeExpr e, CancellationToken t, IVars v = null);
public abstract Task <bool> PrimeP(NodeExpr e, EAlgorithmPrimeP a, CancellationToken t);
public NodeIndex(NodeExpr target, Token spDot, NodeId index)
{
this.target = target;
this.spDot = spDot;
this.index = index;
}
public void Set(string n, NodeExpr e)
{
mVars.Set(n, e);
}
public NodeLet(Spanned<string> spName, Spanned<TyRef> spTy, NodeExpr value)
{
this.spName = spName;
this.spTy = spTy;
this.value = value;
}
public IfBlock(NodeExpr condition, List<Node> body)
{
this.condition = condition;
this.body = body;
}
public NodeEnclosed(Token lparen, Token rparen, NodeExpr expr)
{
this.lparen = lparen;
this.rparen = rparen;
this.expr = expr;
}
public NodeSuffix(NodeExpr target, Token op)
{
this.target = target;
this.op = op;
}
public NodeInfix(NodeExpr left, NodeExpr right, Token op)
{
this.left = left;
this.right = right;
this.op = op;
}
public NodeRet(Token ret, NodeExpr value)
{
this.ret = ret;
this.value = value;
}
private NodeExpr ParseInfix(NodeExpr left, bool isEnclosed)
{
if (HasCurrent && CheckOp() && Current.span.start.line == left.Span.start.line)
{
var op = Current;
Advance();
if (HasCurrent)
{
bool isOnSameLine = Current.span.start.line == op.span.start.line;
if (isOnSameLine || isEnclosed)
{
var right = ParsePrimaryExpr(isEnclosed);
right = ParseInfix(right, isEnclosed);
return new NodeInfix(left, right, op);
}
}
return new NodeSuffix(left, op);
}
return left;
}
private NodeExpr ParseInvoke(NodeExpr node, bool isEnclosed)
{
if (!HasCurrent)
return node;
// TODO(kai): this is ugly, please fix it. Also submit feature request?
NodeExpr expr;
if ((Current.span.start.line == node.Span.start.line || isEnclosed) &&
(expr = ParsePrimaryExpr(isEnclosed, false)) != null)
{
if (!(node is NodeId))
{
log.Error(node.Span, "Can only invoke functions.");
return null; // TODO(kai): Should I return null?
}
var name = (node as NodeId).Image.Spanned(node.Span);
List<NodeExpr> args = new List<NodeExpr>();
args.Add(expr);
while ((Current.span.start.line == node.Span.start.line || isEnclosed) &&
(expr = ParsePrimaryExpr(isEnclosed, false)) != null)
{
args.Add(expr);
}
return new NodeInvoke(name, args);
}
return node;
}
public NodeCCond(ITerminalNode cond, NodeExpr expr)
: base(cond, null)
{
_expr = expr;
}
