public void Iterate(Lambda lambda)
{
using (var assistant = new ParameterAssistant(Arguments))
{
var block = lambda.Block;
if (block != null)
{
assistant.IteratorParameter(lambda.Parameters);
var count = 0;
if (start < stop)
{
for (var i = start; i <= stop && count++ < Runtime.MAX_LOOP; i += increment)
{
assistant.SetIteratorParameter(i);
var record = block.Evaluate().Text;
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return;
}
Runtime.State.Print(record);
}
}
else
{
for (var i = start; i >= stop && count++ < Runtime.MAX_LOOP; i -= increment)
{
assistant.SetIteratorParameter(i);
var record = block.Evaluate().Text;
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return;
}
Runtime.State.Print(record);
}
}
}
}
}
public Value For()
{
using (var assistant = new ParameterAssistant(Arguments))
{
var block = assistant.Block();
if (block != null)
{
assistant.IteratorParameter();
var count = 0;
if (start < stop)
{
for (var i = start; i <= stop && count++ < Runtime.MAX_LOOP; i += increment)
{
assistant.SetIteratorParameter(i);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return(null);
}
}
}
else
{
for (var i = start; i >= stop && count++ < Runtime.MAX_LOOP; i -= increment)
{
assistant.SetIteratorParameter(i);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return(null);
}
}
}
}
return(this);
}
}
public static Value Group(INSGenerator generator, Arguments arguments)
{
var count = arguments[0].Int;
if (count > 0)
{
var iterator = new NSIterator(generator);
var array = new Array();
iterator.Reset();
var value = iterator.Next();
for (var i = 0; i < MAX_ARRAY && !value.IsNil; i += count)
{
var subArray = new Array();
for (var j = 0; j < count && !value.IsNil; j++)
{
subArray.Add(value);
value = iterator.Next();
}
array.Add(value);
value = iterator.Next();
}
return(array);
}
using var assistant = new ParameterAssistant(arguments);
{
var block = assistant.Block();
if (block == null)
{
return(ToArray(generator));
}
var hash = new AutoHash <string, List <Value> >(_ => new List <Value>(), true);
assistant.IteratorParameter();
var iterator = new NSIterator(generator);
iterator.Reset();
foreach (var item in iterator)
{
assistant.SetIteratorParameter(item);
var key = block.Evaluate().Text;
hash[key].Add(item);
}
var array = new Array();
foreach (var(key, value1) in hash)
{
array[key] = new Array(value1);
}
return(array);
}
}
public Value Each()
{
using (var assistant = new ParameterAssistant(Arguments))
{
var block = assistant.Block();
if (block == null)
{
return(null);
}
RegionManager.Regions.Push("string-indexer");
var changes = new Hash <int, string>();
var indexes = getIndexes();
foreach (var index in indexes)
{
var correctedIndex = WrapIndex(index, text.Text.Length, true);
assistant.SetParameterValues(text.Text.Skip(index).Take(1), index.ToString(), correctedIndex);
var result = block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return(null);
}
if (result != null)
{
changes[correctedIndex] = result.Text;
}
}
Slicer slicer = text.Text;
foreach (var item in changes)
{
slicer[item.Key] = item.Value;
}
text.Text = slicer.ToString();
RegionManager.Regions.Pop("string-indexer");
return(null);
}
}
protected Value evaluateBlock()
{
Arguments.Parameters = parameters;
using var assistant = new ParameterAssistant(Arguments);
assistant.ReplacementParameters();
assistant.SetReplacement();
var value = block.Evaluate();
return(value);
}
public override Value Process(Array.IterItem item, int length)
{
signal = SignalType.None;
using (var assistant = new ParameterAssistant(parameterBlock))
{
var block = assistant.Block();
assistant.ArrayParameters();
assistant.SetParameterValues(item);
var value = block.Evaluate();
signal = Signal();
return(value);
}
}
public Value For()
{
using var assistant = new ParameterAssistant(Arguments);
var block = assistant.Block();
if (block != null)
{
assistant.LoopParameters();
Func <string, bool> func = _ => true;
if (filter.IsNotEmpty())
{
func = l => l.IndexOf(filter, StringComparison.Ordinal) > -1;
}
else if (lambda != null)
{
func = l => lambda.Evaluate(new Arguments(l)).IsTrue;
}
using var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
using var reader = new StreamReader(stream);
string line;
var index = 0;
while ((line = reader.ReadLine()) != null)
{
if (func(line))
{
assistant.SetLoopParameters(line, index++);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.Continuing:
continue;
case ParameterAssistant.SignalType.ReturningNull:
return(null);
}
}
}
return(null);
}
return(null);
}
static Value forLoop(Value value, Arguments arguments, out bool handled)
{
handled = false;
var array = value.YieldValue;
if (array == null)
{
return(value);
}
using (var assistant = new ParameterAssistant(arguments))
{
var block = assistant.Block();
if (block == null)
{
return(value);
}
Regions.Push("for");
foreach (var item in array)
{
assistant.SetParameterValues(item);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == Breaking)
{
break;
}
switch (signal)
{
case Continuing:
continue;
case ReturningNull:
return(null);
}
}
value.YieldValue = null;
Regions.Pop("for");
handled = true;
return(array);
}
}
static Value tap(Value value, Arguments arguments)
{
using (var assistant = new ParameterAssistant(arguments))
{
var block = assistant.Block();
if (block == null)
{
return(value);
}
assistant.IteratorParameter();
assistant.SetIteratorParameter(value);
block.Evaluate();
return(value);
}
}
public override Value Fill()
{
using var assistant = new ParameterAssistant(Arguments);
var block = assistant.Block();
Value value;
if (block != null)
{
assistant.ArrayParameters();
var index = 0;
foreach (var key in getIndicators())
{
assistant.SetParameterValues(array[key], key, index++);
value = block.Evaluate();
var signal = Signal();
if (signal == Breaking)
{
break;
}
switch (signal)
{
case Continuing:
continue;
case ReturningNull:
return(null);
}
if (value != null)
{
array[key] = value;
}
}
return(array);
}
value = Arguments[0];
foreach (var key in getIndicators())
{
array[key] = value.Clone();
}
return(array);
}
public Value DefaultTo()
{
var value = Arguments[0];
if (!value.IsEmpty)
{
return(value);
}
using (var assistant = new ParameterAssistant(Arguments))
{
var block = assistant.Block();
if (block == null)
{
return(NullValue);
}
return(block.Evaluate());
}
}
public Value Next()
{
if (current == null)
{
current = seed;
return(current);
}
using var whileAssistant = new ParameterAssistant(whileBlock, true);
using var incrementAssistant = new ParameterAssistant(increment, true);
var block = incrementAssistant.Block();
if (block == null)
{
return(Nil.NilValue);
}
incrementAssistant.IteratorParameter();
incrementAssistant.SetIteratorParameter(current);
current = block.Evaluate();
whileAssistant.IteratorParameter();
whileAssistant.SetIteratorParameter(current);
block = whileAssistant.Block();
if (block == null)
{
return(Nil.NilValue);
}
else if (block.Evaluate().IsTrue)
{
return(current);
}
else
{
return(Nil.NilValue);
}
}
public Value For()
{
using var assistant = new ParameterAssistant(Arguments);
var block = assistant.Block();
if (block != null)
{
assistant.LoopParameters();
if (filter.IsEmpty())
{
using var reader = new StringReader(text);
string line;
var index = 0;
while ((line = reader.ReadLine()) != null)
{
assistant.SetLoopParameters(line, index++);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.ReturningNull:
return(null);
case ParameterAssistant.SignalType.Continuing:
continue;
}
}
}
else
{
using var reader = new StringReader(text);
string line;
var index = 0;
while ((line = reader.ReadLine()) != null)
{
if (line.IndexOf(filter, StringComparison.Ordinal) > -1)
{
assistant.SetLoopParameters(line, index++);
block.Evaluate();
var signal = ParameterAssistant.Signal();
if (signal == ParameterAssistant.SignalType.Breaking)
{
break;
}
switch (signal)
{
case ParameterAssistant.SignalType.ReturningNull:
return(null);
case ParameterAssistant.SignalType.Continuing:
continue;
}
}
}
}
return(null);
}
return(null);
}
public static Value FoldL(INSGenerator generator, Arguments arguments)
{
var iterator = new NSIterator(generator);
using var assistant = new ParameterAssistant(arguments);
var block = assistant.Block();
if (block == null)
{
return(NilValue);
}
iterator.Reset();
assistant.TwoValueParameters();
var initialFromArguments = arguments[0];
var initialValue = initialFromArguments.IsEmpty ? iterator.Next() : initialFromArguments;
if (initialValue.IsNil)
{
return(initialValue);
}
var secondValue = iterator.Next();
if (secondValue.IsNil)
{
return(initialValue);
}
assistant.SetParameterValues(initialValue, secondValue);
var value = block.Evaluate();
var signal = Signal();
if (signal == Breaking)
{
return(value);
}
switch (signal)
{
case ReturningNull:
return(null);
case Continuing:
return(value);
}
var next = iterator.Next();
if (next.IsNil)
{
return(value);
}
for (var i = 0; i < MAX_LOOP; i++)
{
assistant.SetParameterValues(value, next);
value = block.Evaluate();
signal = Signal();
if (signal == Breaking)
{
break;
}
switch (signal)
{
case ReturningNull:
return(null);
case Continuing:
continue;
}
next = iterator.Next();
if (next.IsNil)
{
return(value);
}
}
return(value);
}
public override Value SelfMap()
{
using var assistant = new ParameterAssistant(Arguments);
var block = assistant.Block();
if (block == null)
{
return(this);
}
assistant.ArrayParameters();
var changes = new Array();
foreach (var key in getIndicators())
{
var value = array[key];
var index = array.GetIndex(key);
assistant.SetParameterValues(value, key, index);
value = block.Evaluate();
var signal = Signal();
if (signal == Breaking)
{
break;
}
switch (signal)
{
case Continuing:
continue;
case ReturningNull:
return(null);
}
if (value.Type == ValueType.Nil)
{
continue;
}
if (value is KeyedValue keyedValue)
{
changes[keyedValue.Key] = keyedValue.Value;
}
else
{
changes[key] = value;
}
}
if (changes.Length == 0)
{
return(this);
}
foreach (var item in changes)
{
array[item.Key] = item.Value;
}
return(this);
}
