public static void Main(string[] args)
{
string current = System.Reflection.Assembly.GetExecutingAssembly().Location;
string iokeHome = new FileInfo(current).Directory.Parent.FullName;
string iokeLib = Path.Combine(iokeHome, "lib");
Runtime r = new Runtime(new FunctionalOperatorShufflerFactory());
r.Init();
IokeObject context = r.Ground;
Message mx = new Message(r, ".", null, true);
mx.Line = 0;
mx.Position = 0;
IokeObject message = r.CreateMessage(mx);
string cwd = null;
var scripts = new SaneList<string>();
var loadDirs = new SaneList<string>();
bool debug = false;
try {
int start = 0;
bool done = false;
bool readStdin = false;
bool printedSomething = false;
for(;!done && start<args.Length;start++) {
string arg = args[start];
if(arg.Length > 0) {
if(arg[0] != '-') {
done = true;
break;
} else {
if(arg.Equals("--")) {
done = true;
} else if(arg.Equals("-d")) {
debug = true;
r.Debug = true;
} else if(arg.StartsWith("-e")) {
if(arg.Length == 2) {
scripts.Add(args[++start]);
} else {
scripts.Add(arg.Substring(2));
}
} else if(arg.StartsWith("-I")) {
if(arg.Length == 2) {
loadDirs.Add(args[++start]);
} else {
loadDirs.Add(arg.Substring(2));
}
} else if(arg.Equals("-h") || arg.Equals("--help")) {
Console.Error.Write(HELP);
return;
} else if(arg.Equals("--version")) {
Console.Error.WriteLine(getVersion());
printedSomething = true;
} else if(arg.Equals("--copyright")) {
Console.Error.Write(COPYRIGHT);
printedSomething = true;
} else if(arg.Equals("-")) {
readStdin = true;
} else if(arg[1] == 'C') {
if(arg.Length == 2) {
cwd = args[++start];
} else {
cwd = arg.Substring(2);
}
} else {
IokeObject condition = IokeObject.As(IokeObject.GetCellChain(r.Condition,
message,
context,
"Error",
"CommandLine",
"DontUnderstandOption"), null).Mimic(message, context);
condition.SetCell("message", message);
condition.SetCell("context", context);
condition.SetCell("receiver", context);
condition.SetCell("option", r.NewText(arg));
r.ErrorCondition(condition);
}
}
}
}
if(cwd != null) {
r.CurrentWorkingDirectory = cwd;
}
((IokeSystem)IokeObject.dataOf(r.System)).CurrentProgram = "-e";
string lib = Environment.GetEnvironmentVariable("ioke.lib");
if(lib == null) {
lib = iokeLib;
}
((IokeSystem)IokeObject.dataOf(r.System)).AddLoadPath(lib + "/ioke");
((IokeSystem)IokeObject.dataOf(r.System)).AddLoadPath("lib/ioke");
foreach(string ss in loadDirs) {
((IokeSystem)IokeObject.dataOf(r.System)).AddLoadPath(ss);
}
foreach(string script in scripts) {
r.EvaluateStream("-e", new StringReader(script), message, context);
}
if(readStdin) {
((IokeSystem)IokeObject.dataOf(r.System)).CurrentProgram = "<stdin>";
r.EvaluateStream("<stdin>", Console.In, message, context);
}
if(args.Length > start) {
if(args.Length > (start+1)) {
for(int i=start+1,j=args.Length; i<j; i++) {
r.AddArgument(args[i]);
}
}
string file = args[start];
if(file.StartsWith("\"")) {
file = file.Substring(1, file.Length-1);
}
if(file.Length > 1 && file[file.Length-1] == '"') {
file = file.Substring(0, file.Length-1);
}
((IokeSystem)IokeObject.dataOf(r.System)).CurrentProgram = file;
r.EvaluateFile(file, message, context);
} else {
if(!readStdin && scripts.Count == 0 && !printedSomething) {
r.EvaluateString("use(\"builtin/iik\"). IIk mainLoop", message, context);
}
}
r.TearDown();
} catch(ControlFlow.Exit e) {
int exitVal = e.ExitValue;
try {
r.TearDown();
} catch(ControlFlow.Exit e2) {
exitVal = e2.ExitValue;
}
Environment.Exit(exitVal);
} catch(ControlFlow e) {
string name = e.GetType().FullName;
System.Console.Error.WriteLine("unexpected control flow: " + name.Substring(name.LastIndexOf(".") + 1).ToLower());
if(debug) {
System.Console.Error.WriteLine(e);
}
Environment.Exit(1);
}
}
public static void InitRuntime(IokeObject obj)
{
obj.Kind = "Runtime";
obj.RegisterMethod(obj.runtime.NewNativeMethod("returns the node id for the runtime it's called on",
new TypeCheckingNativeMethod.WithNoArguments("nodeId", obj,
(method, on, args, keywords, context, message) => {
Runtime r = (Runtime)IokeObject.dataOf(on);
return method.runtime.NewNumber(r.id);
})));
obj.RegisterMethod(obj.runtime.NewNativeMethod("creates a new runtime and returns that. be careful using this since it will result in some fairly strange behavior if used incorrectly. it will not copy the state of this runtime, but just create a new one from scratch.",
new TypeCheckingNativeMethod.WithNoArguments("create", obj,
(method, on, args, keywords, context, message) => {
Runtime r = new Runtime(method.runtime.Out, method.runtime.In, method.runtime.Error);
r.Init();
IokeObject o = method.runtime._Runtime.AllocateCopy(null, null);
o.MimicsWithoutCheck(method.runtime._Runtime);
o.Data = r;
return o;
})));
}
