/// <summary>
/// Evaluates a token, possibly requesting the previous and next values.
/// Returns a value.
/// </summary>
/// <param name="token">token representing a function or variable</param>
/// <param name="scope">used to request functions, variables, and delimiters if there's no scope attached to the node</param>
/// <param name="nodes">used to request previous and next nodes</param>
internal static Value Do(DelimiterNode node, IScope scope, INodeRequestor nodes, ILineRequestor requestor)
{
if (node.Value != null)
{ // node has already been evaluated
return node.Value;
}
else if (node.Token != null)
{ // function/variable or built-in
Token token = node.Token;
Value value = scope.GetValue(token);
if (value is ValueFunction && nodes != null)
{
ValueFunction function = value as ValueFunction;
// get previous & next nodes if needed
DelimiterNode previous = (function.ConsumesPrevious ? nodes.GetPrevious() : null);
DelimiterNode next = (function.ConsumesNext ? nodes.GetNext() : null);
scope.FunctionName = token.Value;
// evaluate
try
{
return function.Eval(previous, next, scope, scope, nodes, requestor);
}
catch (Loki3Exception e)
{ // this function is the correct context if there isn't already one there
if (!e.Errors.ContainsKey(Loki3Exception.keyFunction))
e.AddFunction(token.Value);
if (!e.Errors.ContainsKey(Loki3Exception.keyScope))
e.AddScope(scope);
throw e;
}
}
else if (value != null)
{
return value;
}
else
{
return EvalBuiltin.Do(token);
}
}
else if (node.List != null)
{ // delimited list of nodes
Value value = null;
DelimiterList list = node.List;
IScope listScope = (list.Scope != null ? list.Scope : scope);
DelimiterType type = list.Delimiter.DelimiterType;
// get contents as a Value
switch (type)
{
case DelimiterType.AsString:
value = new ValueString(list.Original);
break;
case DelimiterType.AsValue:
value = EvalList.Do(list.Nodes, listScope);
break;
case DelimiterType.AsArray:
List<Value> values = new List<Value>(list.Nodes.Count);
foreach (DelimiterNode subnode in list.Nodes)
{ // note: 'nodes' is null so functions don't get evaled
Value subvalue = Do(subnode, listScope, null, requestor);
values.Add(subvalue);
}
value = new ValueArray(values);
break;
case DelimiterType.AsEvaledArray:
value = EvalList.DoEvaledArray(list.Nodes, listScope);
break;
case DelimiterType.AsRaw:
value = new ValueRaw(list, listScope);
break;
case DelimiterType.AsArrayOfRaw:
List<Value> rawvalues = new List<Value>(list.Nodes.Count);
foreach (DelimiterNode subnode in list.Nodes)
rawvalues.Add(new ValueRaw(subnode, listScope));
value = new ValueArray(rawvalues);
break;
}
// run contents through a function if specified
ValueFunction function = list.Delimiter.Function;
if (function == null)
return value;
DelimiterNode next = new DelimiterNodeValue(value);
return function.Eval(null, next, scope, scope, nodes, requestor);
}
return new ValueNil();
}
/// <summary>Evaluate this node, possibly consuming adjacent nodes</summary>
internal void Eval(IScope scope, INodeRequestor nodes, ILineRequestor requestor)
{
if (m_state != NodeState.Node && m_state != NodeState.Function)
return;
// get new value
if (m_state == NodeState.Node)
{ // hasn't been evaled at all
m_value = EvalNode.Do(m_node, scope, nodes, requestor);
}
else if (m_state == NodeState.Function)
{ // previously resolved to a function
DelimiterNode previous = (m_func.ConsumesPrevious ? previous = nodes.GetPrevious() : null);
DelimiterNode next = (m_func.ConsumesNext ? next = nodes.GetNext() : null);
if ((m_func.ConsumesPrevious || m_func.ConsumesNext) && (previous == null && next == null))
{ // no prev/next parameters passed, perhaps it can use body?
if (m_func.RequiresBody() && requestor != null)
{ // tack on body if present
m_value = EvalList.DoAddBody(m_func, scope, requestor);
}
else
{ // function can't be evaled further
m_state = NodeState.Value;
return;
}
}
else
{
if (!m_func.ConsumesPrevious && !m_func.ConsumesNext && !m_func.RequiresBody() && !m_func.ForceEval)
{ // function can't be evaled further
m_state = NodeState.Value;
return;
}
m_value = m_func.Eval(previous, next, scope, scope, nodes, requestor);
}
}
if (m_value == null)
{ // e.g. because node was a comment
m_state = NodeState.Empty;
return;
}
// store new info about this node
m_node = new DelimiterNodeValue(m_value);
m_order = (int)m_value.Order;
if (m_value.Type == ValueType.Function)
{
m_state = NodeState.Function;
m_func = m_value as ValueFunction;
}
else
{
m_state = NodeState.Value;
}
}
