public override IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
IoCLRFunction method = self as IoCLRFunction;
IoCLRObject obj = target as IoCLRObject;
object result = null;
object[] parameters = new object[method.evaluatedParameters.Count];
for (int i = 0; i < method.evaluatedParameters.Count; i++)
{
IoObject ep = method.evaluatedParameters[i] as IoObject;
switch (ep.name)
{
case "Object": parameters[i] = ep; break;
case "Number":
{
IoNumber num = ep as IoNumber;
if (num.isInteger)
{
parameters[i] = num.longValue;
}
else
{
parameters[i] = num.doubleValue;
}
}
break;
case "Sequence": parameters[i] = (ep as IoSeq).value; break;
case "CLRObject": parameters[i] = (ep as IoCLRObject).clrInstance; break;
}
}
IoCLRObject clr = IoCLRObject.createObject(self.state);
try
{
if (method.methodInfo is ConstructorInfo)
{
ConstructorInfo ci = method.methodInfo as ConstructorInfo;
result = ci.Invoke(parameters);
}
else if (method.methodInfo is MethodInfo)
{
MethodInfo mi = method.methodInfo as MethodInfo;
result = mi.Invoke(obj.clrInstance, parameters);
}
clr.clrType = result != null ? result.GetType() : null;
clr.clrInstance = result;
}
catch (Exception e)
{
Console.WriteLine(e.Message.ToString());
clr.clrType = null;
clr.clrInstance = null;
}
return clr;
}
public IoCLRFunction getMethod(IoMessage message)
{
string methodName = message.messageName.value;
if (clrType == null) return null;
ConstructorInfo[] searchConstructors = null;
Type[] parameters = null;
ArrayList args = null;
MethodBase mb = null;
args = new ArrayList();
parameters = new Type[message.args.Count];
for (int i = 0; i < message.args.Count; i++)
{
IoObject o = message.localsValueArgAt(message, i);
args.Add(o);
Type t = null;
switch (o.name)
{
case "Number": t = typeof(double); break;
case "Object": t = typeof(object); break;
case "CLRObject": t = (o as IoCLRObject).clrType; break;
case "Sequence": t = typeof(string); break;
}
parameters[i] = t;
}
if (methodName.Equals("new"))
{
searchConstructors = this.clrType.GetConstructors();
if (searchConstructors.Length > 0)
mb = searchConstructors[0];
}
else
{
try
{
mb = this.clrType.GetMethod(methodName, parameters);
}
catch { }
}
IoCLRFunction clrFunction = IoCLRFunction.createObject(this.state);
clrFunction.methodInfo = mb;
clrFunction.parametersTypes = parameters;
clrFunction.evaluatedParameters = args;
return clrFunction;
}
public IoObject localsPerformOn(IoObject target, IoObject locals)
{
if (async)
{
IoContext ctx = new IoContext();
ctx.target = target;
ctx.locals = locals;
ctx.message = this;
IoState state = target.state;
IoObject future = IoObject.createObject(state);
IEnumerator <IoObject> e = IoMessage.asyncCall(ctx, future);
state.contextList.Add(e);
return(future);
}
IoObject result = target;
IoObject cachedTarget = target;
IoMessage msg = this;
do
{
if (msg.messageName.Equals(msg.state.semicolonSymbol))
{
target = cachedTarget;
}
else
{
result = msg.cachedResult;
if (result == null)
{
//if (target.tag.performFunc == null)
result = target.perform(target, locals, msg);
//else
// result = target.tag.performFunc(target, locals, msg);
}
if (result == null)
{
Console.WriteLine("Message chains intermediate mustn't be null");
}
target = result;
}
} while ((msg = msg.next) != null);
return(result);
}
public string descriptionToFollow(bool follow)
{
IoMessage m = this;
string s = "";
do
{
s += m.messageName;
if (m.args.Count > 0)
{
s += "(";
for (int i = 0; i < m.args.Count; i++)
{
IoMessage arg = m.args[i] as IoMessage;
s += arg.descriptionToFollow(true);
if (i != m.args.Count - 1)
{
s += ", ";
}
}
s += ")";
}
if (!follow)
{
return(s);
}
if (m.next != null && !m.messageName.value.Equals(";"))
{
s += " ";
}
if (m.messageName.value.Equals(";"))
{
s += "\n";
}
} while ((m = m.next) != null);
return(s);
}
public static IEnumerator <IoObject> asyncCall(IoContext ctx, IoObject future)
{
IoObject target = ctx.target;
IoObject locals = ctx.locals;
IoObject result = target;
IoObject cachedTarget = target;
IoMessage msg = ctx.message;
IoObject savedPrevResultAsYieldResult = null;
do
{
if (msg.messageName.Equals(msg.state.semicolonSymbol))
{
target = cachedTarget;
}
else
{
result = msg.cachedResult;
if (result == null)
{
if (msg.messageName.value.Equals("yield"))
{
yield return(result);
}
else
{
result = target.perform(target, locals, msg);
}
}
if (result == null)
{
result = savedPrevResultAsYieldResult;
}
target = result;
savedPrevResultAsYieldResult = result;
}
} while ((msg = msg.next) != null);
future.slots["future"] = result;
yield return(null);
//yield return result;
}
public static IoObject slotAsyncCall(IoObject target, IoObject locals, IoObject message)
{
IoMessage msg = message as IoMessage;
IoMessage aMessage = msg.rawArgAt(0);
IoObject context = target;
if (msg.args.Count >= 2)
{
context = msg.localsValueArgAt(locals, 1);
}
IoBlock o = target.rawGetSlot(aMessage.messageName) as IoBlock;
if (o != null)
{
IoMessage mmm = o.containedMessage;
mmm.async = true;
IoContext ctx = new IoContext();
ctx.target = context;
ctx.locals = target;
ctx.message = mmm;
mmm.async = true;
IoState state = target.state;
IoObject future = IoObject.createObject(state);
IEnumerator <IoObject> e = IoMessage.asyncCall(ctx, future);
state.contextList.Add(e);
return(future);
}
else
{
IoCFunction cf = target.rawGetSlot(aMessage.messageName) as IoCFunction;
if (cf != null)
{
cf.async = true;
return(cf.activate(target, locals, aMessage, null));
}
}
return(aMessage.localsPerformOn(target, locals));
}
public IoObject perform(IoObject target, IoObject locals, IoObject message)
{
IoMessage msg = message as IoMessage;
IoObject context = null;
IoObject slotValue = target.rawGetSlotContext(msg.messageName, out context);
if (slotValue == null)
{
slotValue = target.clrGetSlot(msg);
}
if (slotValue != null)
{
return(slotValue.activate(slotValue, target, locals, msg, context));
}
if (target.isLocals)
{
return(IoObject.slotLocalsForward(target, locals, message));
}
return(target.forward(target, locals, message));
}
// Published Slots
public new static IoObject slotMethod(IoObject target, IoObject locals, IoObject message)
{
IoState state = target.state;
IoBlock self = IoBlock.createObject(state);
IoMessage m = message as IoMessage;
int nargs = m.args.Count;
IoMessage lastArgAsMessage = (nargs > 0) ? m.rawArgAt(nargs - 1) : state.nilMessage;
int i;
self.containedMessage = lastArgAsMessage;
self.isActivatable = true;
for (i = 0; i < nargs - 1; i++)
{
IoMessage argMessage = m.rawArgAt(i);
IoSeq name = argMessage.messageName;
self.argNames.Add(name);
}
return(self);
}
public static IoObject slotSetNext(IoObject target, IoObject locals, IoObject message)
{
IoMessage self = target as IoMessage;
IoMessage msg = message as IoMessage;
IoObject m = msg.localsMessageArgAt(locals, 0) as IoObject;
IoMessage mmm = null;
if (m == target.state.ioNil)
{
mmm = null;
}
else if (m.name.Equals("Message"))
{
mmm = m as IoMessage;
}
else
{
Console.WriteLine("argument must be Message or Nil");
}
self.next = mmm;
return(self);
}
public static IoObject slotUpdateSlot(IoObject target, IoObject locals, IoObject message)
{
IoMessage m = message as IoMessage;
IoSeq slotName = m.localsSymbolArgAt(locals, 0);
IoObject slotValue = m.localsValueArgAt(locals, 1);
if (slotName == null)
{
return(target);
}
if (target.rawGetSlot(slotName) != null)
{
target.slots[slotName.ToString()] = slotValue;
}
else
{
Console.WriteLine("Slot {0} not found. Must define slot using := operator before updating.", slotName.value);
}
return(slotValue);
}
IoMessage newParse(IoState state, IoLexer lexer)
{
if (lexer.errorToken != null)
{
}
if (lexer.topType() == IoTokenType.TERMINATOR_TOKEN)
{
lexer.pop();
}
if (lexer.top() != null && lexer.top().isValidMessageName())
{
IoMessage self = newParseNextMessageChain(state, lexer);
if (lexer.topType() != IoTokenType.NO_TOKEN)
{
state.error(self, "compile error: %s", "unused tokens");
}
return(self);
}
return(newWithNameReturnsValue(state, IoSeq.createSymbolInMachine(state, "nil"), state.ioNil));
}
public override IoObject proto(IoState state)
{
IoMessage pro = new IoMessage();
pro.state = state;
// pro.tag.cloneFunc = new IoTagCloneFunc(this.clone);
//pro.tag.activateFunc = new IoTagActivateFunc(this.activate);
pro.createSlots();
pro.createProtos();
pro.uniqueId = 0;
pro.messageName = IoSeq.createSymbolInMachine(state, "anonymous");
pro.label = IoSeq.createSymbolInMachine(state, "unlabeled");
pro.args = new List <IoMessage>();
state.registerProtoWithFunc(name, new IoStateProto(name, pro, new IoStateProtoFunc(this.proto)));
pro.protos.Add(state.protoWithInitFunc("Object"));
IoCFunction[] methodTable = new IoCFunction[] {
new IoCFunction("name", new IoMethodFunc(IoMessage.slotName)),
new IoCFunction("setName", new IoMethodFunc(IoMessage.slotSetName)),
new IoCFunction("next", new IoMethodFunc(IoMessage.slotNext)),
new IoCFunction("setNext", new IoMethodFunc(IoMessage.slotSetNext)),
new IoCFunction("code", new IoMethodFunc(IoMessage.slotCode)),
new IoCFunction("arguments", new IoMethodFunc(IoMessage.slotArguments)),
new IoCFunction("appendArg", new IoMethodFunc(IoMessage.slotAppendArg)),
new IoCFunction("argAt", new IoMethodFunc(IoMessage.slotArgAt)),
new IoCFunction("argCount", new IoMethodFunc(IoMessage.slotArgCount)),
new IoCFunction("asString", new IoMethodFunc(IoMessage.slotCode)),
new IoCFunction("cachedResult", new IoMethodFunc(IoMessage.slotCachedResult)),
new IoCFunction("setCachedResult", new IoMethodFunc(IoMessage.slotSetCachedResult)),
new IoCFunction("removeCachedResult", new IoMethodFunc(IoMessage.slotRemoveCachedResult)),
new IoCFunction("hasCachedResult", new IoMethodFunc(IoMessage.slotHasCachedResult)),
};
pro.addTaglessMethodTable(state, methodTable);
return(pro);
}
public void error(IoMessage m, string s)
{
}
public override IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
IoCLRFunction method = self as IoCLRFunction;
IoCLRObject obj = target as IoCLRObject;
object result = null;
object[] parameters = new object[method.evaluatedParameters.Count];
for (int i = 0; i < method.evaluatedParameters.Count; i++)
{
IoObject ep = method.evaluatedParameters[i] as IoObject;
switch (ep.name)
{
case "Object": parameters[i] = ep; break;
case "Number":
{
IoNumber num = ep as IoNumber;
if (num.isInteger)
{
parameters[i] = num.longValue;
}
else
{
parameters[i] = num.doubleValue;
}
}
break;
case "Sequence": parameters[i] = (ep as IoSeq).value; break;
case "CLRObject": parameters[i] = (ep as IoCLRObject).clrInstance; break;
}
}
IoCLRObject clr = IoCLRObject.createObject(self.state);
try
{
if (method.methodInfo is ConstructorInfo)
{
ConstructorInfo ci = method.methodInfo as ConstructorInfo;
result = ci.Invoke(parameters);
}
else if (method.methodInfo is MethodInfo)
{
MethodInfo mi = method.methodInfo as MethodInfo;
result = mi.Invoke(obj.clrInstance, parameters);
}
clr.clrType = result != null?result.GetType() : null;
clr.clrInstance = result;
}
catch (Exception e)
{
Console.WriteLine(e.Message.ToString());
clr.clrType = null;
clr.clrInstance = null;
}
return(clr);
}
public static IoObject slotLoadAssembly(IoObject target, IoObject locals, IoObject message)
{
IoCLR self = target as IoCLR;
IoMessage m = message as IoMessage;
IoSeq assemblyName = m.localsSymbolArgAt(locals, 0);
IoCLRAssembly asm = null;
if (self.loadedAssemblies.ContainsKey(assemblyName.value))
{
asm = self.loadedAssemblies[assemblyName.value];
if (asm != null)
{
return(asm);
}
}
asm = IoCLRAssembly.createObject(target.state);
var name = new AssemblyName(assemblyName.value);
try
{
asm.assembly = Assembly.Load(name);
Console.WriteLine("载入{0} ....成功！", name.Name);
}
catch (FileNotFoundException ex)
{
Console.WriteLine("载入{0} ....失败！", name.Name);
}
if (asm.assembly == null)
{
return(self);
}
self.loadedAssemblies[assemblyName.value] = asm;
asm.assemblyTypes = asm.assembly.GetTypes();
asm.assemblyNamespaces = new Dictionary <string, Dictionary <string, Type> >();
foreach (Type t in asm.assemblyTypes)
{
string theNameSpace = t.FullName.LastIndexOf(".") == -1 ? "-" : t.FullName.Substring(0, t.FullName.LastIndexOf("."));
string theClass = t.FullName.LastIndexOf(".") == -1 ? t.FullName : t.FullName.Substring(t.FullName.LastIndexOf(".") + 1);
if (theClass.Equals("Form"))
{
//~//int i = 0;
}
if (asm.assemblyNamespaces.ContainsKey(theNameSpace))
{
Dictionary <string, Type> a = asm.assemblyNamespaces[theNameSpace];
a[theClass] = t;
}
else
{
Dictionary <string, Type> classes = new Dictionary <string, Type>();
classes[theClass] = t;
asm.assemblyNamespaces[theNameSpace] = classes;
}
}
return(asm);
}
public static IoObject slotHasCachedResult(IoObject target, IoObject locals, IoObject message)
{
IoMessage self = target as IoMessage;
return(self.cachedResult == null ? target.state.ioFalse : target.state.ioTrue);
}
public new static IoMessage createProto(IoState state)
{
IoMessage m = new IoMessage();
return(m.proto(state) as IoMessage);
}
public void error(IoMessage m, string s)
{
}
void addArg(IoMessage arg)
{
args.Add(arg);
}
public override IoObject proto(IoState state)
{
IoMessage pro = new IoMessage();
pro.state = state;
// pro.tag.cloneFunc = new IoTagCloneFunc(this.clone);
//pro.tag.activateFunc = new IoTagActivateFunc(this.activate);
pro.createSlots();
pro.createProtos();
pro.uniqueId = 0;
pro.messageName = IoSeq.createSymbolInMachine(state, "anonymous");
pro.label = IoSeq.createSymbolInMachine(state, "unlabeled");
pro.args = new IoObjectArrayList();
state.registerProtoWithFunc(name, new IoStateProto(name, pro, new IoStateProtoFunc(this.proto)));
pro.protos.Add(state.protoWithInitFunc("Object"));
IoCFunction[] methodTable = new IoCFunction[] {
new IoCFunction("name", new IoMethodFunc(IoMessage.slotName)),
new IoCFunction("setName", new IoMethodFunc(IoMessage.slotSetName)),
new IoCFunction("next", new IoMethodFunc(IoMessage.slotNext)),
new IoCFunction("setNext", new IoMethodFunc(IoMessage.slotSetNext)),
new IoCFunction("code", new IoMethodFunc(IoMessage.slotCode)),
new IoCFunction("arguments", new IoMethodFunc(IoMessage.slotArguments)),
new IoCFunction("appendArg", new IoMethodFunc(IoMessage.slotAppendArg)),
new IoCFunction("argAt", new IoMethodFunc(IoMessage.slotArgAt)),
new IoCFunction("argCount", new IoMethodFunc(IoMessage.slotArgCount)),
new IoCFunction("asString", new IoMethodFunc(IoMessage.slotCode)),
new IoCFunction("cachedResult", new IoMethodFunc(IoMessage.slotCachedResult)),
new IoCFunction("setCachedResult", new IoMethodFunc(IoMessage.slotSetCachedResult)),
new IoCFunction("removeCachedResult", new IoMethodFunc(IoMessage.slotRemoveCachedResult)),
new IoCFunction("hasCachedResult", new IoMethodFunc(IoMessage.slotHasCachedResult)),
};
pro.addTaglessMethodTable(state, methodTable);
return pro;
}
// Published Slots
public static IoObject slotName(IoObject target, IoObject locals, IoObject message)
{
IoMessage self = target as IoMessage;
return(self.messageName);
}
void addArg(IoMessage arg)
{
args.Add(arg);
}
void parseNext(IoLexer lexer)
{
IoMessage nextMessage = newParseNextMessageChain(this.state, lexer);
this.next = nextMessage;
}
public IoMessage rawArgAt(int p)
{
IoMessage argIsMessage = args[p] as IoMessage;
return(argIsMessage);
}
public void error(IoMessage self, string p, string p_3)
{
}
public override IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
return self;
}
IoMessage newFromTextLabelSymbol(IoState state, string code, IoSeq labelSymbol)
{
IoLexer lexer = new IoLexer();
IoMessage msg = new IoMessage();
msg = msg.clone(state) as IoMessage;
lexer.s = code;
lexer.lex();
msg = this.newParse(state, lexer);
msg.opShuffle();
msg.label = labelSymbol;
return msg;
}
void parseNext(IoLexer lexer)
{
IoMessage nextMessage = newParseNextMessageChain(this.state, lexer);
this.next = nextMessage;
}
public static new IoMessage createObject(IoState state)
{
IoMessage pro = new IoMessage();
return pro.clone(state) as IoMessage;
}
public static IoObject slotMessage(IoObject target, IoObject locals, IoObject message)
{
IoMessage m = message as IoMessage;
return(m.args.Count > 0 ? m.rawArgAt(0) : target.state.ioNil);
}
public static new IoMessage createProto(IoState state)
{
IoMessage m = new IoMessage();
return m.proto(state) as IoMessage;
}
public static IEnumerator <IoObject> slotAsyncWhile(IoObject target, IoObject locals, IoObject message, IoObject future)
{
IoMessage m = message as IoMessage;
IoObject result = target.state.ioNil;
IoObject cond = null;
while (true)
{
cond = m.localsValueArgAt(locals, 0);
//evaluateArgs(m, new EvaluateArgsEventArgs(0), out cond);
if (cond == target.state.ioFalse || cond == target.state.ioNil)
{
break;
}
//result = m.localsValueArgAt(locals, 1);
//evaluateArgs(m, new EvaluateArgsEventArgs(1), out result);
IoMessage msg = 1 < m.args.Count ? m.args[1] as IoMessage : null;
if (msg != null)
{
if (msg.cachedResult != null && msg.next == null)
{
result = msg.cachedResult;
yield return(result);
}
//result = localMessage.localsPerformOn(locals, locals);
result = target;
IoObject cachedTarget = target;
IoObject savedPrevResultAsYieldResult = null;
do
{
if (msg.messageName.Equals(msg.state.semicolonSymbol))
{
target = cachedTarget;
}
else
{
result = msg.cachedResult;
if (result == null)
{
if (msg.messageName.value.Equals("yield"))
{
yield return(result);
}
else
{
result = target.perform(target, locals, msg);
}
}
if (result == null)
{
target = cachedTarget;
//result = savedPrevResultAsYieldResult;
}
else
{
target = result;
}
savedPrevResultAsYieldResult = result;
}
} while ((msg = msg.next) != null);
future.slots["future"] = result;
yield return(null);
}
result = m.state.ioNil;
if (target.state.handleStatus() != 0)
{
goto done;
}
}
done:
yield return(null);
}
// Call Public Raw Methods
public override IoObject activate(IoObject sender, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
IoState state = sender.state;
IoBlock self = sender as IoBlock;
IoObjectArrayList argNames = self.argNames;
IoObject scope = self.scope;
IoObject blockLocals = state.localsProto.clone(state);
IoObject result = null;
IoObject callObject = null;
blockLocals.isLocals = true;
if (scope == null)
{
scope = target;
}
blockLocals.createSlots();
callObject = IoCall.with(state, locals, target, m, slotContext, self, null /*state.currentCoroutine*/);
IoSeqObjectHashtable bslots = blockLocals.slots;
bslots["call"] = callObject;
bslots["self"] = scope;
bslots["updateSlot"] = state.localsUpdateSlotCFunc;
if (argNames != null)
{
for (int i = 0; i < argNames.Count; i++)
{
IoSeq name = argNames[i] as IoSeq;
IoObject arg = m.localsValueArgAt(locals, i);
blockLocals.slots[name] = arg;
}
}
if (self.containedMessage != null)
{
result = self.containedMessage.localsPerformOn(blockLocals, blockLocals);
}
if (self.passStops == IoCallStatus.MESSAGE_STOP_STATUS_NORMAL)
{
}
return(result);
}
public virtual IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
return(self.isActivatable ? self.activate(self, target, locals, m) : self);
}
public IoObject onDoCStringWithLabel(IoObject target, string code, string label)
{
IoMessage msg = new IoMessage();
msg = msg.clone(this) as IoMessage;
msg = msg.newFromTextLabel(this, code, label);
return msg.localsPerformOn(target, target);
}
// Call Public Raw Methods
public override IoObject activate(IoObject sender, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
IoState state = sender.state;
IoBlock self = sender as IoBlock;
IoObjectArrayList argNames = self.argNames;
IoObject scope = self.scope;
IoObject blockLocals = state.localsProto.clone(state);
IoObject result = null;
IoObject callObject = null;
blockLocals.isLocals = true;
if (scope == null)
scope = target;
blockLocals.createSlots();
callObject = IoCall.with(state, locals, target, m, slotContext, self, null/*state.currentCoroutine*/);
IoSeqObjectHashtable bslots = blockLocals.slots;
bslots["call"] = callObject;
bslots["self"] = scope;
bslots["updateSlot"] = state.localsUpdateSlotCFunc;
if (argNames != null)
for (int i = 0; i < argNames.Count; i++)
{
IoSeq name = argNames[i] as IoSeq;
IoObject arg = m.localsValueArgAt(locals, i);
blockLocals.slots[name] = arg;
}
if (self.containedMessage != null)
{
result = self.containedMessage.localsPerformOn(blockLocals, blockLocals);
}
if (self.passStops == IoCallStatus.MESSAGE_STOP_STATUS_NORMAL)
{
}
return result;
}
public override IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
if (func == null) return self;
return func(target, locals, m);
}
public static IoObject slotCachedResult(IoObject target, IoObject locals, IoObject message)
{
IoMessage m = target as IoMessage;
return(m.cachedResult == null ? target.state.ioNil : m.cachedResult);
}
public IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m)
{
if (self.isActivatable)
{
IoObject context = null;
IoObject slotValue = self.rawGetSlotContext(self.state.activateMessage.messageName, out context);
if (slotValue != null)
{
// ?? мы шо в цикле ???
return activate(slotValue, target, locals, m, context);
}
return state.ioNil;
} else
return self;
}
public IoState()
{
objectProto = IoObject.createProto(this);
core = objectProto.clone(this);
lobby = objectProto.clone(this);
IoSeq seqProto = IoSeq.createProto(this);
setupSingletons();
setupSymbols();
objectProto.protoFinish(this);
IoMessage messageProto = IoMessage.createProto(this);
nilMessage = IoMessage.createObject(this) as IoMessage;
nilMessage.cachedResult = ioNil;
nilMessage.messageName = IOSYMBOL("nil");
IoMap mapProto = IoMap.createProto(this);
IoNumber numProto = IoNumber.createProto(this);
IoCFunction cfProto = IoCFunction.createProto(this);
IoBlock blockProto = IoBlock.createProto(this);
//IoCoroutine coroProto = IoCoroutine.createProto(this);
//mainCoroutine = coroProto;
//currentCoroutine = coroProto;
IoCall callProto = IoCall.createProto(this);
IoList listProto = IoList.createProto(this);
clrProto = IoCLR.createProto(this);
IoCLRAssembly asmProto = IoCLRAssembly.createProto(this);
IoCLRObject clrObjProto = IoCLRObject.createProto(this);
IoObject protos = objectProto.clone(this);
protos.slots["Core"] = core;
protos.slots["Addons"] = null;
lobby.slots["Lobby"] = lobby;
lobby.slots["Protos"] = protos;
core.slots["Object"] = objectProto;
core.slots["Map"] = mapProto;
// core.slots["Coroutine"] = coroProto;
core.slots["Message"] = messageProto;
core.slots["CFunction"] = cfProto;
core.slots["Number"] = numProto;
core.slots["Block"] = blockProto;
core.slots["Call"] = callProto;
core.slots["Locals"] = localsProto = objectProto.localsProto(this);
core.slots["List"] = listProto;
core.slots["Sequence"] = seqProto;
core.slots["CLR"] = clrProto;
core.slots["CLRAssembly"] = asmProto;
core.slots["CLRObject"] = clrObjProto;
objectProto.protos.Add(lobby);
lobby.protos.Add(protos);
protos.protos.Add(core);
localsUpdateSlotCFunc = new IoCFunction(this, "localsUpdate", IoObject.localsUpdateSlot);
initMessage = IoMessage.newWithName(this, IOSYMBOL("init"));
forwardMessage = IoMessage.newWithName(this, IOSYMBOL("forward"));
activateMessage = IoMessage.newWithName(this, IOSYMBOL("activate"));
selfMessage = IoMessage.newWithName(this, IOSYMBOL("self"));
opShuffleMessage = IoMessage.newWithName(this, IOSYMBOL("opShuffle"));
mainMessage = IoMessage.newWithName(this, IOSYMBOL("main"));
typeMessage = IoMessage.newWithName(this, IOSYMBOL("type"));
}
public IoObject clrGetSlot(IoMessage message)
{
IoObject v = null;
if (this is IoCLRObject)
{
v = (this as IoCLRObject).getMethod(message);
}
if (v == null)
v = this.state.clrProto.getType(this.state, message.messageName.value);
return v;
}
public static IoObject slotArgCount(IoObject target, IoObject locals, IoObject message)
{
IoMessage self = target as IoMessage;
return(IoNumber.newWithDouble(target.state, Convert.ToDouble(self.args.Count)));
}
// Object Public Raw Methods
public IoObject initClone(IoObject target, IoObject locals, IoMessage m, IoObject newObject)
{
IoObject context = null;
IoObject initSlot = target.rawGetSlotContext(target.state.initMessage.messageName, out context);
if (initSlot != null)
initSlot.activate(initSlot, newObject, locals, target.state.initMessage, context);
return newObject;
}
public IoState()
{
objectProto = IoObject.createProto(this);
core = objectProto.clone(this);
lobby = objectProto.clone(this);
IoSeq seqProto = IoSeq.createProto(this);
setupSingletons();
setupSymbols();
objectProto.protoFinish(this);
IoMessage messageProto = IoMessage.createProto(this);
nilMessage = IoMessage.createObject(this) as IoMessage;
nilMessage.cachedResult = ioNil;
nilMessage.messageName = IOSYMBOL("nil");
IoMap mapProto = IoMap.createProto(this);
IoNumber numProto = IoNumber.createProto(this);
IoCFunction cfProto = IoCFunction.createProto(this);
IoBlock blockProto = IoBlock.createProto(this);
//IoCoroutine coroProto = IoCoroutine.createProto(this);
//mainCoroutine = coroProto;
//currentCoroutine = coroProto;
IoCall callProto = IoCall.createProto(this);
IoList listProto = IoList.createProto(this);
clrProto = IoCLR.createProto(this);
IoCLRAssembly asmProto = IoCLRAssembly.createProto(this);
IoCLRObject clrObjProto = IoCLRObject.createProto(this);
IoObject protos = objectProto.clone(this);
protos.slots["Core"] = core;
protos.slots["Addons"] = null;
lobby.slots["Lobby"] = lobby;
lobby.slots["Protos"] = protos;
core.slots["Object"] = objectProto;
core.slots["Map"] = mapProto;
// core.slots["Coroutine"] = coroProto;
core.slots["Message"] = messageProto;
core.slots["CFunction"] = cfProto;
core.slots["Number"] = numProto;
core.slots["Block"] = blockProto;
core.slots["Call"] = callProto;
core.slots["Locals"] = localsProto = objectProto.localsProto(this);
core.slots["List"] = listProto;
core.slots["Sequence"] = seqProto;
core.slots["CLR"] = clrProto;
core.slots["CLRAssembly"] = asmProto;
core.slots["CLRObject"] = clrObjProto;
objectProto.protos.Add(lobby);
lobby.protos.Add(protos);
protos.protos.Add(core);
localsUpdateSlotCFunc = new IoCFunction(this, "localsUpdate", IoObject.localsUpdateSlot);
initMessage = IoMessage.newWithName(this, IOSYMBOL("init"));
forwardMessage = IoMessage.newWithName(this, IOSYMBOL("forward"));
activateMessage = IoMessage.newWithName(this, IOSYMBOL("activate"));
selfMessage = IoMessage.newWithName(this, IOSYMBOL("self"));
opShuffleMessage = IoMessage.newWithName(this, IOSYMBOL("opShuffle"));
mainMessage = IoMessage.newWithName(this, IOSYMBOL("main"));
typeMessage = IoMessage.newWithName(this, IOSYMBOL("type"));
}
public static IoObject slotEevalArg(IoObject target, IoObject locals, IoObject message)
{
IoMessage m = message as IoMessage;
return(m.localsValueArgAt(locals, 0));
}
public void error(IoMessage self, string p, string p_3)
{
}
public new static IoMessage createObject(IoState state)
{
IoMessage pro = new IoMessage();
return(pro.clone(state) as IoMessage);
}
public override IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
return(self);
}
public virtual IoObject activate(IoObject self, IoObject target, IoObject locals, IoMessage m, IoObject slotContext)
{
return self.isActivatable ? self.activate(self, target, locals, m) : self;
}
