public virtual RCOperator AsOperator(RCActivator activator, RCValue left, RCValue right)
{
RCOperator result = new RCInlineOperator(this);
result.Init("", left, right);
return(result);
}
public static RCOperator ReadOperator(RCActivator activator, RCArray <byte> data, ref int start)
{
int count = BitConverter.ToInt32(data._source, start);
start += sizeof(int);
RCValue left = null;
RCValue right = null;
string name = null;
if (count == 2)
{
name = Binary.ReadScalarString(data, ref start);
right = Binary.DoParse(activator, data, ref start);
}
else if (count == 3)
{
left = Binary.DoParse(activator, data, ref start);
name = Binary.ReadScalarString(data, ref start);
right = Binary.DoParse(activator, data, ref start);
}
else
{
throw new Exception("count of an operator must always be 2 or 3.");
}
return(activator.New(name, left, right));
}
static RCSystem()
{
Args = RCLArgv.Instance;
// Setup the logger first in case the Activator throws an exception
Log = new RCLogger(Args.NoKeys, Args.Show, Args.Hide);
Log.SetVerbosity(Args.OutputEnum);
Activator = RCActivator.CreateDefault();
}
public RCLParser(RCActivator activator)
{
if (activator == null)
{
throw new ArgumentNullException("activator");
}
_activator = activator;
_lefts.Push(new Stack <RCValue> ());
_operators.Push(new Stack <RCValue> ());
_lexer = _o2Lexer;
}
public static RCReference ReadReference(RCActivator activator,
RCArray <byte> array,
ref int
start)
{
int count = BitConverter.ToInt32(array._source, start);
start += sizeof(int);
string[] parts = new string[count];
for (int i = 0; i < count; ++i)
{
parts[i] = ReadScalarString(array, ref start);
}
return(new RCReference(parts));
}
public static RCBlock ReadBlock(RCActivator activator, RCArray <byte> data, ref int start)
{
int count = BitConverter.ToInt32(data._source, start);
start += sizeof(int);
RCBlock result = null;
for (int i = 0; i < count; ++i)
{
string name = Binary.ReadScalarString(data, ref start);
string evaluator = Binary.ReadScalarString(data, ref start);
RCValue val = Binary.DoParse(activator, data, ref start);
result = new RCBlock(result, name, evaluator, val);
}
return(result);
}
public static RCValue DoParse(RCActivator activator, RCArray <byte> array, ref int start)
{
// The type of the data to be parsed.
char type = (char)array[start];
start += 1;
switch (type)
{
case 'x': return(new RCByte(ReadVector <byte> (array, ref start, sizeof(byte))));
case 'l': return(new RCLong(ReadVector <long> (array, ref start, sizeof(long))));
case 'd': return(new RCDouble(ReadVector <double> (array, ref start, sizeof(double))));
case 'b': return(new RCBoolean(ReadVector <bool> (array, ref start, sizeof(bool))));
case 'm': return(new RCDecimal(ReadVectorDecimal(array, ref start)));
case 's': return(new RCString(ReadVectorString(array, ref start)));
case 'y': return(new RCSymbol(ReadVectorSymbol(array, ref start)));
case 't': return(new RCTime(ReadVectorTime(array, ref start)));
case 'n': return(new RCIncr(ReadVectorIncr(array, ref start)));
case 'r': return(ReadReference(activator, array, ref start));
case 'o': return(ReadOperator(activator, array, ref start));
case 'k': return(ReadBlock(activator, array, ref start));
// Again need some kind of "parser extension" or "operator extension" framework
// to get this to work, but I want to keep the implementation with RCCube.
// case 'u': return RCCube.ReadCube (activator, array, ref start);
// default : throw new Exception ("Unsupported type code:" + type);
default: return(activator.ExtensionFor(type).BinaryParse(activator, array, ref start));
}
}
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 abstract RCValue BinaryParse(RCActivator activator,
RCArray <byte> data,
ref int
start);
public override RCOperator AsOperator(RCActivator activator, RCValue left, RCValue right)
{
return(activator.New(Name, left, right));
}
