public void EvalChart(RCRunner runner, RCClosure closure, RCSymbol right)
{
RCCube result = new RCCube(new RCArray <string> ("S"));
DoChart <RCSymbolScalar> (result, RCSymbolScalar.Empty, 0, 0, right);
runner.Yield(closure, result);
}
public void EvalTake(RCRunner runner, RCClosure closure, RCSymbol left, RCBlock right)
{
RCBot bot = runner.GetBot(closure.Bot);
Take module = (Take)bot.GetModule(typeof(Take));
module.DoTake(runner, closure, left, right);
}
public void EvalSwitch(RCRunner runner, RCClosure closure, RCSymbol left, RCBlock right)
{
Picker <RCSymbolScalar> picker = delegate(RCSymbolScalar val, out bool eval)
{
if (val.Length > 1)
{
throw new Exception(
"switch only supports block lookups using tuples of count 1. But this could change.");
}
RCBlock variable = right.GetName((string)val.Key);
RCValue code;
// This behavior is sketchy and should be reevaluated - this should be an
// exception
if (variable == null)
{
code = RCBlock.Empty;
eval = true;
}
else
{
code = variable.Value;
eval = !variable.Evaluator.Pass;
}
return(code);
};
DoSwitch <RCSymbolScalar> (runner, closure, left, right, picker);
}
protected virtual void WriteToFiles(RCRunner runner,
RCClosure closure,
RCSymbol symbol,
RCBlock data)
{
for (int i = 0; i < data.Count; ++i)
{
FileStream stream = null;
RCBlock column = data.GetName(i);
if (!_files.TryGetValue(column.Name, out stream))
{
string path = Path.Combine(_dir.Name, column.Name);
stream = new FileStream(path,
FileMode.CreateNew,
FileAccess.Write);
_files[column.Name] = stream;
}
RCArray <byte> array = new RCArray <byte> ();
column.Value.ToByte(array);
// throw new NotImplementedException ("This is where it's at baby, get er done.");
// RCAsyncState state = new RCAsyncState (runner, closure, stream);
// stream.BeginWrite (array, 0, array.Length, new AsyncCallback (EndWrite),
// state);
}
}
public void EvalGawk(RCRunner runner, RCClosure closure, RCSymbol symbol, RCLong right)
{
int limit = (int)right[0];
lock (_readWriteLock)
{
Section s = GetSection(symbol);
ReadSpec spec = s._counter.GetReadSpec(symbol, limit, false, true);
Satisfy canSatisfy = s._counter.CanSatisfy(spec);
RCCube result = s._blackboard.Read(spec, s._counter, true, s._blackboard.Count);
if ((spec.SymbolUnlimited && result.Count > 0) ||
(!spec.SymbolUnlimited && result.Count >= symbol.Count * Math.Abs(spec.SymbolLimit)))
{
if (canSatisfy != Satisfy.Yes)
{
throw new Exception();
}
runner.Yield(closure, result);
}
else
{
if (canSatisfy != Satisfy.No)
{
throw new Exception();
}
s._dispatchWaiters.Enqueue(symbol, closure);
}
}
}
public void Enqueue(RCSymbol symbol, RCClosure closure)
{
if (_symbolsByFiber.ContainsKey(closure.Fiber))
{
throw new Exception("Fiber " + closure.Fiber.ToString() +
" is already waiting, something is wrong.");
}
RCArray <RCSymbolScalar> stripped = new RCArray <RCSymbolScalar> (symbol.Count);
for (int i = 0; i < symbol.Count; ++i)
{
if (symbol[i].Key.Equals("*"))
{
stripped.Write(symbol[i].Previous);
}
else
{
stripped.Write(symbol[i]);
}
}
_symbolsByFiber.Add(closure.Fiber,
new HashSet <RCSymbolScalar> (stripped));
for (int i = 0; i < stripped.Count; ++i)
{
HashSet <long> fibers;
if (!_fibersBySymbol.TryGetValue(stripped[i], out fibers))
{
_fibersBySymbol[stripped[i]] = fibers = new HashSet <long> ();
}
fibers.Add(closure.Fiber);
}
_waitOrder.Enqueue(closure);
}
public void EvalPage(RCRunner runner, RCClosure closure, RCSymbol symbol, RCLong right)
{
int pageNumber = 0;
if (right.Count > 0)
{
pageNumber = (int)right[0];
}
int pageSize = int.MaxValue;
if (right.Count > 1)
{
pageSize = (int)right[1];
}
// Page lets you access the blackboard by page number and page size, rather than row
// numbers.
// Good for building tools for looking at blackboard contents.
lock (_readWriteLock)
{
Section s = GetSection(symbol);
int skipFirst = pageNumber * pageSize;
int stopAfter = pageSize;
ReadSpec spec = new ReadSpec(s._counter, symbol, skipFirst, stopAfter, false);
RCCube result = s._blackboard.Read(spec, s._counter, true, s._blackboard.Count);
runner.Yield(closure, result);
}
}
public void EvalPeek(RCRunner runner, RCClosure closure, RCSymbol left, RCLong right)
{
int limit = (int)right[0];
lock (_readWriteLock)
{
Section s = GetSection(left);
ReadSpec spec = s._counter.GetReadSpec(left, limit, false, true);
Satisfy canSatisfy = s._counter.CanSatisfy(spec);
RCCube result = s._blackboard.Read(spec, s._counter, true, s._blackboard.Count);
if ((spec.SymbolUnlimited && result.Count > 0) ||
(!spec.SymbolUnlimited && result.Count >= left.Count * Math.Abs(spec.SymbolLimit)))
{
// If dispatch would yield, return lines.
if (canSatisfy != Satisfy.Yes)
{
throw new Exception();
}
runner.Yield(closure, RCBoolean.True);
}
else
{
if (canSatisfy != Satisfy.No)
{
throw new Exception();
}
runner.Yield(closure, RCBoolean.False);
}
}
}
public void EvalListen(RCRunner runner, RCClosure closure, RCSymbol right)
{
if (right.Count != 1)
{
throw new Exception("listen takes exactly one protocol,port");
}
string protocol = (string)right[0].Part(0);
long port = (long)right[0].Part(1);
RCBot bot = runner.GetBot(closure.Bot);
long handle = bot.New();
Server server;
if (protocol.Equals("http"))
{
throw new NotImplementedException("http server not ready yet");
}
else if (protocol.Equals("tcp"))
{
server = new TcpServer(handle, port, new TcpProtocol());
}
else if (protocol.Equals("udp"))
{
throw new ArgumentException("No udp sockets yet");
}
else
{
throw new ArgumentException("Unknown protocol: " + protocol);
}
bot.Put(handle, server);
server.Listen(runner, closure);
}
public void EvalPartsAfter(RCRunner runner, RCClosure closure, RCSymbol left, RCLong right)
{
RCArray <RCSymbolScalar> result = new RCArray <RCSymbolScalar> (left.Count);
if (right.Count == 1)
{
for (int i = 0; i < left.Count; ++i)
{
result.Write(left[i].PartsAfter(right[0]));
}
}
else if (right.Count == left.Count)
{
for (int i = 0; i < left.Count; ++i)
{
result.Write(left[i].PartsAfter(right[i]));
}
}
else
{
throw new RCException(closure,
RCErrors.Count,
"partsBefore requires a single part index or an array having the same count as the left argument");
}
runner.Yield(closure, new RCSymbol(result));
}
public void EvalTrace(RCRunner runner, RCClosure closure, RCSymbol right)
{
try
{
// This read is different from all others in that it has force on and fill off.
// force causes duplicate values to be written.
// fill causes prior values to be filled into the results.
// This read gives you exactly what exists in the blackboard.
RCLong args = new RCLong(0, 0);
Section section = GetSection(right);
Read(runner,
closure,
right,
new ReadSpec(section._counter,
right,
args,
0,
false,
true,
false,
true));
}
catch (Exception)
{
throw;
}
}
public void EvalRename(RCRunner runner, RCClosure closure, RCSymbol left, RCBlock right)
{
if (left.Count != right.Count && left.Count != 1)
{
throw new Exception("left and right arguments must have the same length");
}
RCBlock result = RCBlock.Empty;
if (left.Count == 1)
{
for (int i = 0; i < right.Count; ++i)
{
RCBlock name = right.GetName(i);
string field = left[0].Part(0).ToString();
result = new RCBlock(result, field, name.Evaluator, name.Value);
}
}
else
{
for (int i = 0; i < left.Count; ++i)
{
RCBlock name = right.GetName(i);
string field = left[i].Part(0).ToString();
result = new RCBlock(result, field, name.Evaluator, name.Value);
}
}
runner.Yield(closure, result);
}
public void EvalForce(RCRunner runner, RCClosure closure, RCSymbol left, RCBlock right)
{
long line = Write(runner, left, right, true);
RCBlock logBlock = new RCBlock(right, "S", ":", left);
RCSystem.Log.Record(closure, "board", 0, "write", logBlock);
runner.Yield(closure, new RCLong(line));
}
public void EvalRmdir(RCRunner runner, RCClosure closure, RCSymbol right)
{
// All of this stuff HASTA HASTA HASTA be ASYNC!
string path = PathSymbolToLocalString(right[0]);
Directory.Delete(path);
runner.Yield(closure, right);
}
public void EvalDelete(RCRunner runner, RCClosure closure, RCSymbol right)
{
for (int i = 0; i < right.Count; ++i)
{
File.Delete(PathSymbolToLocalString(right[i]));
}
runner.Yield(closure, right);
}
public void EvalList(RCRunner runner, RCClosure closure, RCSymbol left, RCSymbol right)
{
HashSet <RCSymbolScalar> options = new HashSet <RCSymbolScalar> (left);
string target = (string)right[0].Part(0);
if (target == "" || target == "work")
{
BeginListFilesCube(runner,
closure,
new ListArgs(right[0],
options.Contains(all),
options.Contains(deep)));
}
else if (target == "home")
{
BeginListFilesCube(runner,
closure,
new ListArgs(right[0],
options.Contains(all),
options.Contains(deep)));
}
else if (target == "root")
{
BeginListFilesCube(runner,
closure,
new ListArgs(right[0],
options.Contains(all),
options.Contains(deep)));
}
else if (target == "fibers")
{
ListFibers(runner, closure);
}
else if (target == "vars")
{
ListVars(runner, closure);
}
else if (target == "urls")
{
ListUrls(runner, closure);
}
else if (target == "request")
{
ListRequest(runner, closure);
}
else if (target == "sockets")
{
ListSockets(runner, closure);
}
else if (target == "exec")
{
ListExec(runner, closure);
}
else
{
throw new Exception("Unknown target for list: " + target);
}
}
public void Deletem(RCRunner runner, RCClosure closure, RCSymbol key)
{
lock (_lock)
{
Dictionary <RCSymbolScalar, RCValue> store = GetSection(key);
store.Remove(key[0]);
}
runner.Yield(closure, new RCSymbol(key[0]));
}
public void Putm(RCRunner runner, RCClosure closure, RCSymbol key, object val)
{
lock (_lock)
{
Dictionary <RCSymbolScalar, RCValue> store = GetSection(key);
store[key[0]] = (RCValue)val;
}
runner.Yield(closure, key);
}
public void EvalSelect(RCRunner runner, RCClosure closure, RCSymbol left, RCCube right)
{
RCLong args = new RCLong(0, 0);
ReadCounter counter = new ReadCounter(right);
ReadSpec spec = new ReadSpec(counter, left, args, 0, false, false, true, false);
RCCube result = right.Read(spec, counter, true, right.Count);
runner.Yield(closure, result);
}
public void EvalInfo(RCRunner runner, RCClosure closure, RCSymbol right)
{
if (right.Count > 1)
{
throw new Exception(
"info can only provide one value at a time. info #help gives a list of valid values.");
}
Info(runner, closure, right[0].Part(0).ToString());
}
public void EvalCd(RCRunner runner, RCClosure closure, RCSymbol right)
{
if (right.Count > 1)
{
throw new Exception("cd can only change into one directory");
}
Environment.CurrentDirectory = Command.PathSymbolToLocalString(right[0]);
runner.Yield(closure, right);
}
public void EvalLoad(RCRunner runner, RCClosure closure, RCSymbol right)
{
// Need check for windows drive letter
string path = PathSymbolToLocalString(right[0]);
string code = File.ReadAllText(path, Encoding.UTF8);
code = code.Replace("\r", "");
runner.Yield(closure, new RCString(code));
}
public void EvalSymbolMonadicPlus(RCRunner runner, RCClosure closure, RCSymbol right)
{
RCSymbolScalar result = RCSymbolScalar.Empty;
for (int i = 0; i < right.Count; ++i)
{
result = ScalarMath.Plus(result, right[i]);
}
runner.Yield(closure, new RCSymbol(result));
}
public void EvalFile(RCRunner runner, RCClosure closure, RCSymbol right)
{
RCArray <bool> result = new RCArray <bool> (right.Count);
for (int i = 0; i < right.Count; ++i)
{
result.Write(File.Exists(PathSymbolToLocalString(right[i])));
}
runner.Yield(closure, new RCBoolean(result));
}
public void EvalPath(RCRunner runner, RCClosure closure, RCSymbol right)
{
RCArray <string> result = new RCArray <string> (right.Count);
for (int i = 0; i < right.Count; ++i)
{
result.Write(PathSymbolToLocalString(right[i]));
}
runner.Yield(closure, new RCString(result));
}
public void Read(RCRunner runner, RCClosure closure, RCSymbol symbol, ReadSpec spec)
{
lock (_readWriteLock)
{
// Make abstract symbols concrete
Section section = GetSection(symbol);
Satisfy canSatisfy = section._counter.CanSatisfy(spec);
RCCube result = section._blackboard.Read(spec,
section._counter,
true,
section._blackboard.Count);
if (spec.SymbolUnlimited)
{
if (result.Count > 0)
{
// Notice the canSatisfy constraints here are less strict.
// If the start point is greater than zero then we have to
// do the full read and then just see if there were enough
// rows to satisfy the constraints.
if (canSatisfy == Satisfy.No)
{
throw new Exception();
}
runner.Yield(closure, result);
}
else
{
if (canSatisfy == Satisfy.Yes)
{
throw new Exception();
}
section._readWaiters.Enqueue(symbol, closure);
}
}
else
{
if (result.Count >= symbol.Count * Math.Abs(spec.SymbolLimit))
{
if (canSatisfy == Satisfy.No)
{
throw new Exception();
}
runner.Yield(closure, result);
}
else
{
if (canSatisfy == Satisfy.Yes)
{
throw new Exception();
}
section._readWaiters.Enqueue(symbol, closure);
}
}
}
}
public void Clear(RCRunner runner, RCClosure closure, RCSymbol key)
{
lock (_lock)
{
for (int i = 0; i < key.Count; ++i)
{
_sections.Remove(key[i].Part(0));
}
}
runner.Yield(closure, key);
}
public void List(RCRunner runner, RCClosure closure, RCSymbol key)
{
RCSymbolScalar[] array;
lock (_lock)
{
Dictionary <RCSymbolScalar, RCValue> store = GetSection(key);
array = new RCSymbolScalar[store.Keys.Count];
store.Keys.CopyTo(array, 0);
}
runner.Yield(closure, new RCSymbol(array));
}
public static SortDirection ToDir(RCSymbol left)
{
if (left.Count != 1)
{
throw new Exception("left argument must be exactly one of #asc #desc #absasc #absdesc");
}
SortDirection result = (SortDirection)Enum.Parse(typeof(SortDirection),
(string)left[0].Part(0));
return(result);
}
public void ShowSpecialFolders(RCRunner runner, RCClosure closure, RCSymbol right)
{
foreach (Environment.SpecialFolder folder in Enum.GetValues(typeof(
Environment.SpecialFolder)))
{
Console.WriteLine(string.Format("{0}\t\t\t{1}",
folder.ToString(),
Environment.GetFolderPath(folder)));
}
runner.Yield(closure, right);
}
