public void Done(RCClosure closure, RCLong fibers)
{
if (fibers.Count == 1)
{
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
bool val;
lock (fiber._fiberLock)
{
val = fiber._fibers.Count == fiber._fiberResults.Count;
}
Yield(closure, new RCBoolean(val));
}
else if (fibers.Count == 2)
{
bool val;
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
lock (fiber._fiberLock)
{
val = fiber._fiberResults.ContainsKey(fibers[1]);
}
Yield(closure, new RCBoolean(val));
}
else
{
throw new Exception();
}
}
public ReadSpec GetReadSpec(RCSymbol symbol, RCLong starts, bool force, bool fill)
{
ReadSpec result = new ReadSpec(this, 0, force, fill);
for (int i = 0; i < symbol.Count; ++i)
{
result.Add(symbol[i], (int)starts[i], int.MaxValue);
}
return(result);
}
public void EvalKill(RCRunner runner, RCClosure closure, RCLong right)
{
try
{
runner.Kill(closure, right);
}
catch (Exception)
{
throw;
}
runner.Yield(closure, right);
}
public long GetLong(long i)
{
RCLong val = (RCLong)Get(i);
if (val == null)
{
throw new Exception(string.Format("No value at index {0} within block (count:{1})",
i,
Count));
}
return(val[0]);
}
public long GetLong(string name)
{
RCLong val = (RCLong)Get(name);
if (val == null)
{
throw new Exception("Required value " + name + " not found in block");
}
else
{
return(val[0]);
}
}
public long GetLong(string name, long def)
{
RCLong val = (RCLong)Get(name);
if (val == null)
{
return(def);
}
else
{
return(val[0]);
}
}
public void Kill(RCClosure closure, RCLong fibers)
{
if (fibers.Count == 1)
{
Kill(fibers[0], -1, new Exception("fiber killed"), 2);
}
else if (fibers.Count == 2)
{
Kill(fibers[0], fibers[1], new Exception("fiber killed"), 2);
}
else
{
throw new Exception();
}
}
public ReadSpec(ReadCounter counter,
RCSymbol left,
RCLong right,
int defaultLimit,
bool
ignoreDispatchedRows,
bool force,
bool fill,
bool showDeleted)
{
_counter = counter;
ShowDeleted = showDeleted;
_ignoreDispatchedRows = ignoreDispatchedRows;
_force = force;
_fill = fill;
if (right.Count == 1)
{
// It's the start point.
_forward = defaultLimit >= 0;
_unlimited = defaultLimit == 0;
_symbolLimit = Math.Abs(_unlimited ? int.MaxValue : defaultLimit);
left = _counter.ConcreteSymbols(left, showDeleted);
for (int i = 0; i < left.Count; ++i)
{
Add(left[i], (int)right[0], _symbolLimit);
}
}
else if (right.Count == 2)
{
// It's the start point and the limit.
_forward = right[1] >= 0;
_unlimited = right[1] == 0;
_symbolLimit = Math.Abs(_unlimited ? int.MaxValue : (int)right[1]);
left = _counter.ConcreteSymbols(left, showDeleted);
for (int i = 0; i < left.Count; ++i)
{
Add(left[i], (int)right[0], _symbolLimit);
}
}
else
{
// Who knows what this should do.
// Maybe let you give different counts for each symbol.
throw new ArgumentException("Read takes a maximum of two right arguments.");
}
}
public virtual void ContinueFiber(Object obj)
{
Timer timer = (Timer)obj;
RCLong fibers = (RCLong)_state.Other;
try
{
Fiber fiber;
lock (_state.Runner._botLock)
{
if (_state.Runner._reset != _resetCount)
{
return;
}
fiber = (Fiber)_state.Runner._bots[fibers[0]].GetModule(typeof(Fiber));
}
lock (fiber._fiberLock)
{
RCValue result = null;
if (!fiber._fiberResults.TryGetValue(fibers[1], out result))
{
Exception ex = new Exception("Timed out waiting for fiber " + fibers[1]);
_state.Runner.Kill(fibers[0], fibers[1], ex, 2);
}
}
}
catch (ThreadAbortException)
{
// This often happens as the runtime is shutting down,
// because this code runs on a thread pool thread.
}
catch (Exception ex)
{
_state.Runner.Report(_state.Closure, ex);
}
finally
{
timer.Dispose();
}
}
public virtual void ContinueBot(Object obj)
{
Timer timer = (Timer)obj;
RCLong fibers = (RCLong)_state.Other;
try
{
lock (_state.Runner._botLock)
{
if (_state.Runner._reset != _resetCount)
{
return;
}
Queue <RCClosure> waiters;
// Since the bot results are not stored anywhere, we time out if there are
// waiters but what if there are multiple waiters? This seems like an issue.
if (_state.Runner._botWaiters.TryGetValue(fibers[0], out waiters))
{
Exception ex = new Exception("Timed out waiting for bot " + fibers[0]);
_state.Runner.Kill(fibers[0], -1, ex, 2);
}
}
}
catch (ThreadAbortException)
{
// This often happens as the runtime is shutting down,
// because this code runs on a thread pool thread.
}
catch (Exception ex)
{
_state.Runner.Report(_state.Closure, ex);
}
finally
{
timer.Dispose();
}
}
public void Wait(RCClosure closure, RCLong timeout, RCLong fibers)
{
// At some point I want this to work for multiple fibers,
// but the current version will only wait on a single fiber.
if (fibers.Count == 1)
{
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
RCValue result = null;
lock (fiber._fiberLock)
{
if (fiber._fiberResults.Count == fiber._fibers.Count)
{
fiber._fiberResults.TryGetValue(0, out result);
}
}
if (result == null)
{
lock (_botLock)
{
Queue <RCClosure> waiters;
if (_botWaiters.TryGetValue(fibers[0], out waiters))
{
waiters.Enqueue(closure);
}
else
{
waiters = new Queue <RCClosure> ();
waiters.Enqueue(closure);
_botWaiters.Add(fibers[0], waiters);
}
RCAsyncState state = new RCAsyncState(this, closure, fibers);
Wakeup wakeup = new Wakeup(state, _reset);
Timer timer = new Timer(wakeup.ContinueBot);
timer.Change(timeout[0], Timeout.Infinite);
}
}
else
{
SafeYieldFromWait(closure, result);
}
}
else if (fibers.Count == 2)
{
RCValue result = null;
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
lock (fiber._fiberLock)
{
if (!fiber._fiberResults.TryGetValue(fibers[1], out result))
{
Queue <RCClosure> waiters;
if (fiber._fiberWaiters.TryGetValue(fibers[1], out waiters))
{
waiters.Enqueue(closure);
}
else
{
waiters = new Queue <RCClosure> ();
waiters.Enqueue(closure);
fiber._fiberWaiters.Add(fibers[1], waiters);
}
RCAsyncState state = new RCAsyncState(this, closure, fibers);
Wakeup wakeup = new Wakeup(state, _reset);
Timer timer = new Timer(wakeup.ContinueFiber);
timer.Change(timeout[0], Timeout.Infinite);
}
}
if (result != null)
{
SafeYieldFromWait(closure, result);
}
}
else
{
throw new Exception();
}
}
public void Wait(RCClosure closure, RCLong fibers)
{
// At some point I want this to work for multiple fibers,
// but the current version will only wait on a single fiber.
if (fibers.Count == 1)
{
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
RCValue result = null;
lock (fiber._fiberLock)
{
if (fiber._fiberResults.Count == fiber._fibers.Count)
{
fiber._fiberResults.TryGetValue(0, out result);
}
}
if (result == null)
{
lock (_botLock)
{
Queue <RCClosure> waiters;
if (_botWaiters.TryGetValue(fibers[0], out waiters))
{
waiters.Enqueue(closure);
}
else
{
waiters = new Queue <RCClosure> ();
waiters.Enqueue(closure);
_botWaiters.Add(fibers[0], waiters);
}
}
}
else
{
SafeYieldFromWait(closure, result);
}
}
else if (fibers.Count == 2)
{
RCValue result = null;
Fiber fiber;
lock (_botLock)
{
fiber = (Fiber)_bots[fibers[0]].GetModule(typeof(Fiber));
}
lock (fiber._fiberLock)
{
if (!fiber._fiberResults.TryGetValue(fibers[1], out result))
{
Queue <RCClosure> waiters;
if (fiber._fiberWaiters.TryGetValue(fibers[1], out waiters))
{
waiters.Enqueue(closure);
}
else
{
waiters = new Queue <RCClosure> ();
waiters.Enqueue(closure);
fiber._fiberWaiters.Add(fibers[1], waiters);
}
}
}
if (result != null)
{
SafeYieldFromWait(closure, result);
}
}
else
{
throw new Exception();
}
}
public void EvalEval(RCRunner runner, RCClosure closure, RCBlock left, RCLong right)
{
runner.Yield(closure, right);
}
public void EvalWait(RCRunner runner, RCClosure closure, RCLong right)
{
runner.Wait(closure, right);
}
public void EvalWatch(RCRunner runner, RCClosure closure, RCLong right)
{
runner.Watch(closure, right[0]);
}
/*
* protected Type InferType(string[] name, string original)
* {
* //Let's try to figure it out!
* RCValue target = null;
*
* //Try the block under construction.
* if (_block != null)
* {
* target = _block.Get(name);
* }
*
* //Try to find it higher up the stack.
* if (target == null)
* {
* RCBlock[] parents = _blocks.ToArray();
* //When you ToArray the stack items come out in the same order
* //you would have taken them off the stack.
* for (int i = 0; i < parents.Length; ++i)
* {
* //There will be null blocks on the stack.
* if (parents[i] != null)
* {
* target = parents[i].Get(name);
* if (target != null) break;
* }
* }
* }
*
* if (target == null)
* {
* throw new Exception("Unable to infer type for reference " + original + ".");
* }
* else return target.Yields;
* }
*/
protected RCVectorBase MakeVector(RCArray <RCToken> vector)
{
RCVectorBase result = null;
if (vector[0].Text[0] == '~')
{
switch (vector[0].Text[1])
{
case 'x': return(RCByte.Empty);
case 'b': return(RCBoolean.Empty);
case 'l': return(RCLong.Empty);
case 'd': return(RCDouble.Empty);
case 'm': return(RCDecimal.Empty);
case 's': return(RCString.Empty);
case 'y': return(RCSymbol.Empty);
case 't': return(RCTime.Empty);
case 'n': return(RCIncr.Empty);
default: throw new Exception("Unrecognized type code: " + vector[0].Text[1]);
}
}
if (vector[0].Type == RCTokenType.Symbol)
{
RCArray <RCSymbolScalar> list = new RCArray <RCSymbolScalar> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseSymbol(_lexer));
}
result = new RCSymbol(list);
}
else if (vector[0].Type == RCTokenType.String)
{
RCArray <string> list = new RCArray <string> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseString(_lexer));
}
result = new RCString(list);
}
else if (vector[0].Type == RCTokenType.Boolean)
{
RCArray <bool> list = new RCArray <bool> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseBoolean(_lexer));
}
result = new RCBoolean(list);
}
else if (vector[0].Type == RCTokenType.Incr)
{
RCArray <RCIncrScalar> list = new RCArray <RCIncrScalar> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseIncr(_lexer));
}
result = new RCIncr(list);
}
else if (vector[0].Type == RCTokenType.Literal)
{
char type = vector[0].Text[1];
switch (type)
{
case 'x':
RCArray <byte> list = new RCArray <byte> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseByte(_lexer));
}
result = new RCByte(list);
break;
default: throw new Exception("Unknown type specifier:" + type);
}
}
else if (vector[0].Type == RCTokenType.Time)
{
RCArray <RCTimeScalar> list = new RCArray <RCTimeScalar> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseTime(_lexer));
}
result = new RCTime(list);
}
else if (vector[0].Type == RCTokenType.Number)
{
// have a look at the last character in the last token
// if there is a type specifier there we will use it to
// create the appropriate type of vector.
RCToken last = vector[vector.Count - 1];
char type = last.Text[last.Text.Length - 1];
if (type == 'l')
{
RCArray <long> list = new RCArray <long> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseLong(_lexer));
}
result = new RCLong(list);
}
if (type == 'd')
{
RCArray <double> list = new RCArray <double> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseDouble(_lexer));
}
result = new RCDouble(list);
}
else if (type == 'm')
{
RCArray <decimal> list = new RCArray <decimal> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseDecimal(_lexer));
}
result = new RCDecimal(list);
}
else // default to double
{
if (vector[0].Text.IndexOf('.') > -1 || vector[0].Text == "NaN")
{
RCArray <double> list = new RCArray <double> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseDouble(_lexer));
}
result = new RCDouble(list);
}
else
{
RCArray <long> list = new RCArray <long> (vector.Count);
for (int i = 0; i < vector.Count; ++i)
{
list.Write(vector[i].ParseLong(_lexer));
}
result = new RCLong(list);
}
}
}
return(result);
}
public void EvalDone(RCRunner runner, RCClosure closure, RCLong right)
{
runner.Done(closure, right);
}
public override RCValue BinaryParse(RCActivator activator, RCArray <byte> array, ref int start)
{
start += sizeof(int);
RCArray <string> tlnames = Binary.ReadVectorString(array, ref start);
RCArray <long> G = null;
RCArray <long> E = null;
RCArray <RCTimeScalar> T = null;
RCArray <RCSymbolScalar> S = null;
for (int i = 0; i < tlnames.Count; ++i)
{
char name = tlnames[i][0];
switch (name)
{
case 'G': G = Binary.ReadVector <long> (array, ref start, sizeof(long)); break;
case 'E': E = Binary.ReadVector <long> (array, ref start, sizeof(long)); break;
case 'T': T = Binary.ReadVectorTime(array, ref start); break;
case 'S': S = Binary.ReadVectorSymbol(array, ref start); break;
default: throw new Exception("Unknown timeline column: " + tlnames[i]);
}
}
Timeline timeline = new Timeline(G, E, T, S);
RCArray <string> names = Binary.ReadVectorString(array, ref start);
RCArray <ColumnBase> columns = new RCArray <ColumnBase> (names.Count);
for (int i = 0; i < names.Count; ++i)
{
char type = (char)array[start];
start += sizeof(byte);
RCArray <int> index = RCLong.ReadVector4(array, ref start);
switch (type)
{
case 'x':
RCArray <byte> datax = Binary.ReadVector <byte> (array, ref start, sizeof(byte));
columns.Write(new RCCube.ColumnOfByte(timeline, index, datax));
break;
case 'd':
RCArray <double> datad = Binary.ReadVector <double> (array, ref start, sizeof(double));
columns.Write(new RCCube.ColumnOfDouble(timeline, index, datad));
break;
case 'l':
RCArray <long> datal = Binary.ReadVector <long> (array, ref start, sizeof(long));
columns.Write(new RCCube.ColumnOfLong(timeline, index, datal));
break;
case 'm':
RCArray <decimal> datam = Binary.ReadVectorDecimal(array, ref start);
columns.Write(new RCCube.ColumnOfDecimal(timeline, index, datam));
break;
case 'n':
RCArray <RCIncrScalar> datan = Binary.ReadVectorIncr(array, ref start);
columns.Write(new RCCube.ColumnOfIncr(timeline, index, datan));
break;
case 'b':
RCArray <bool> datab = Binary.ReadVector <bool> (array, ref start, sizeof(bool));
columns.Write(new RCCube.ColumnOfBool(timeline, index, datab));
break;
case 's':
RCArray <string> datas = Binary.ReadVectorString(array, ref start);
columns.Write(new RCCube.ColumnOfString(timeline, index, datas));
break;
case 'y':
RCArray <RCSymbolScalar> datay = Binary.ReadVectorSymbol(array, ref start);
columns.Write(new RCCube.ColumnOfSymbol(timeline, index, datay));
break;
default: throw new Exception("Cannot ReadVector with type " + type);
}
}
return(new RCCube(timeline, names, columns));
}
public void EvalFail(RCRunner runner, RCClosure closure, RCLong left, RCString right)
{
runner.Finish(closure, new RCException(closure, RCErrors.Custom, right[0]), left[0]);
}
