public IodineModule (string name)
: base (ModuleTypeDef)
{
Name = name;
Initializer = new IodineMethod (this, "__init__", false, 0, 0);
Attributes ["__init__"] = Initializer;
Attributes ["__name__"] = new IodineString (name);
}
public IodineHostEntry (IPHostEntry host)
: base (HostEntryTypeDef)
{
this.Entry = host;
IodineObject[] addresses = new IodineObject[Entry.AddressList.Length];
int i = 0;
foreach (IPAddress ip in Entry.AddressList) {
addresses [i++] = new IodineString (ip.ToString ());
}
SetAttribute ("addressList", new IodineTuple (addresses));
}
private IodineObject Popen(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString command = args [0] as IodineString;
IodineString mode = args [1] as IodineString;
if (command == null || mode == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
bool read = false;
bool write = false;
foreach (char c in mode.Value)
{
switch (c)
{
case 'r':
read = true;
break;
case 'w':
write = true;
break;
}
}
bool isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT ||
Environment.OSVersion.Platform == PlatformID.Win32S ||
Environment.OSVersion.Platform == PlatformID.Win32Windows ||
Environment.OSVersion.Platform == PlatformID.WinCE ||
Environment.OSVersion.Platform == PlatformID.Xbox;
if (isWindows)
{
return(new IodineSubprocess(Popen_Win32(command.Value, read, write), read, write));
}
else
{
Process proc = Popen_Unix(command.Value, read, write);
proc.Start();
return(new IodineSubprocess(proc, read, write));
}
}
public override IodineObject Invoke(VirtualMachine vm, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
}
if (args [0].HasAttribute("_toStr"))
{
IodineString ret = args [0].GetAttribute("_toStr").Invoke(vm, new IodineObject[] { })
as IodineString;
return(ret);
}
return(new IodineString(args [0].ToString()));
}
private IodineObject spawn(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
}
IodineString str = args [0] as IodineString;
string cmdArgs = "";
bool wait = true;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
if (args.Length >= 2)
{
IodineString cmdArgsObj = args [1] as IodineString;
if (cmdArgsObj == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
cmdArgs = cmdArgsObj.Value;
}
if (args.Length >= 3)
{
IodineBool waitObj = args [2] as IodineBool;
if (waitObj == null)
{
vm.RaiseException(new IodineTypeException("Bool"));
return(null);
}
wait = waitObj.Value;
}
ProcessStartInfo info = new ProcessStartInfo(str.Value, cmdArgs);
info.UseShellExecute = false;
Process proc = Process.Start(info);
if (wait)
{
proc.WaitForExit();
}
return(new IodineInteger(proc.ExitCode));
}
private IodineObject IsSymbol(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineString thisObj = self as IodineString;
bool result = thisObj.Value.Length == 0 ? false : true;
for (int i = 0; i < thisObj.Value.Length; i++)
{
if (!char.IsSymbol(thisObj.Value [i]))
{
return(IodineBool.False);
}
}
return(IodineBool.Create(result));
}
private IodineObject LoadModule(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(IodineNull.Instance);
}
IodineString source = args [0] as IodineString;
try {
return(vm.LoadModule(source.ToString()));
} catch (ModuleNotFoundException ex) {
vm.RaiseException(new IodineModuleNotFoundException(ex.Name));
return(null);
}
}
public IodineSyntaxException(ErrorLog errorLog)
: base(TypeDefinition, "Syntax error")
{
Base = new IodineException();
IodineObject[] errors = new IodineObject[errorLog.ErrorCount];
int i = 0;
foreach (Error error in errorLog.Errors)
{
SourceLocation loc = error.Location;
string text = String.Format("{0} ({1}:{2}) error: {3}", Path.GetFileName(loc.File),
loc.Line, loc.Column, error.Text);
errors [i++] = new IodineString(text);
}
SetAttribute("errors", new IodineTuple(errors));
}
private IodineObject getSize(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString format = args [0] as IodineString;
int ret = 0;
int i = 0;
while (i < format.Value.Length)
{
int arg = 1;
if (i < format.Value.Length && char.IsDigit(format.Value [i]))
{
StringBuilder accum = new StringBuilder();
do
{
accum.Append(format.Value [i++]);
} while (i < format.Value.Length && char.IsDigit(format.Value [i]));
arg = Int32.Parse(accum.ToString());
}
if (i < format.Value.Length)
{
char specifier = format.Value [i++];
if (i < format.Value.Length && char.IsDigit(format.Value [i]))
{
StringBuilder accum = new StringBuilder();
do
{
accum.Append(format.Value [i++]);
} while (i < format.Value.Length && char.IsDigit(format.Value [i]));
arg = Int32.Parse(accum.ToString());
}
if (specifier == 'x')
{
ret += arg;
}
else
{
ret += getSize(specifier, arg);
}
}
}
return(new IodineInteger(ret));
}
private IodineObject isMatch(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString expr = args [0] as IodineString;
if (expr == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(IodineBool.Create(Value.IsMatch(expr.ToString())));
}
private IodineObject compile(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString expr = args [0] as IodineString;
if (expr == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(new IodineRegex(new Regex(expr.ToString())));
}
private IodineObject replace(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString arg1 = args [0] as IodineString;
IodineString arg2 = args [1] as IodineString;
if (arg1 == null || arg2 == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(new IodineString(Value.Replace(arg1.Value, arg2.Value)));
}
private IodineObject ord(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString str = args [0] as IodineString;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(new IodineInteger((int)str.Value [0]));
}
private IodineObject Compile(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(IodineNull.Instance);
}
IodineString source = args [0] as IodineString;
SourceUnit unit = SourceUnit.CreateFromSource(source.Value);
try {
return(unit.Compile(vm.Context));
} catch (SyntaxException ex) {
vm.RaiseException(new IodineSyntaxException(ex.ErrorLog));
return(IodineNull.Instance);
}
}
public IodineMethod(
IodineModule module,
IodineString name,
CodeObject bytecode,
IodineTuple parameters,
MethodFlags flags,
IodineObject[] defaultValues,
int defaultStart = 0
)
: base(MethodTypeDef)
{
Module = module;
Bytecode = bytecode;
ParameterCount = Parameters.Count;
Variadic = (flags & MethodFlags.AcceptsVarArgs) != 0;
AcceptsKeywordArgs = (flags & MethodFlags.AcceptsKwargs) != 0;
HasDefaultValues = (flags & MethodFlags.HasDefaultParameters) != 0;
DefaultValuesStartIndex = defaultStart;
DefaultValues = defaultValues;
SetParameters(Parameters, parameters);
Name = name.ToString();
SetAttribute("__doc__", IodineString.Empty);
SetAttribute("__invoke__", new BuiltinMethodCallback(invoke, this));
if (AcceptsKeywordArgs)
{
var lastParameter = Parameters.Last() as IodineNamedParameter;
KwargsParameter = lastParameter.Name;
if (Variadic)
{
var secondToLastParameter = Parameters [Parameters.Count - 2] as
IodineNamedParameter;
VarargsParameter = secondToLastParameter.Name;
}
}
else if (Variadic)
{
var lastParameter = Parameters.Last() as IodineNamedParameter;
VarargsParameter = lastParameter.Name;
}
}
private IodineObject hasAttribute(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineObject o1 = args [0];
IodineString str = args [1] as IodineString;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(IodineBool.Create(o1.HasAttribute(str.Value)));
}
public override IodineObject Invoke(VirtualMachine vm, IodineObject[] args)
{
if (args.Length == 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString name = args [0] as IodineString;
if (name == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
IodineTypeDefinition baseType = IodineObject.ObjectTypeDef;
if (args.Length > 1)
{
baseType = args [1] as IodineTypeDefinition;
if (baseType == null)
{
vm.RaiseException(new IodineTypeException("TypeDef"));
return(null);
}
}
IodineTypeDefinition clazz = new IodineTypeDefinition(name.Value);
clazz.Base = baseType;
if (args.Length > 2)
{
IodineDictionary map = args [2] as IodineDictionary;
foreach (IodineObject key in map.Keys)
{
clazz.SetAttribute(key.ToString(), map.Get(key));
}
}
return(clazz);
}
private IodineObject setAttribute(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 3)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineObject o1 = args [0];
IodineString str = args [1] as IodineString;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
o1.SetAttribute(str.Value, args [2]);
return(null);
}
private IodineObject isMatch(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 1)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString data = args [0] as IodineString;
IodineString pattern = args [1] as IodineString;
if (pattern == null || data == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(IodineBool.Create(Regex.IsMatch(data.ToString(), pattern.ToString())));
}
private IodineObject IsFile(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString path = args [0] as IodineString;
if (path == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(IodineBool.Create(File.Exists(path.Value)));
}
private IodineObject SetEnv(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
}
IodineString str = args [0] as IodineString;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
Environment.SetEnvironmentVariable(str.Value, args [1].ToString(), EnvironmentVariableTarget.User);
return(null);
}
private IodineObject replace(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString input = args [0] as IodineString;
IodineString val = args [0] as IodineString;
if (input == null || val == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
Value.Replace(args [0].ToString(), args [1].ToString());
return(null);
}
private IodineObject setCwd(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString cwd = args [0] as IodineString;
if (cwd == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
Environment.CurrentDirectory = args [0].ToString();
return(null);
}
public IodineModule(string name, string location = null)
: base(ModuleTypeDef)
{
if (name == "__init__")
{
/*
* The name __init__ is reserved for packages
*/
Name = Path.GetFileName(Path.GetDirectoryName(location));
}
else
{
Name = name;
}
Location = location;
SetAttribute("__doc__", IodineString.Empty);
Attributes ["__name__"] = new IodineString(Name);
}
static IodineObject Captures(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
var match = self as IodineMatch;
if (match == null)
{
vm.RaiseException(new IodineFunctionInvocationException());
return(null);
}
var strObjects = new IodineString [match.Value.Captures.Count];
for (int i = 0; i < match.Value.Captures.Count; i++)
{
strObjects [i] = new IodineString(match.Value.Captures [i].Value);
}
return(new IodineTuple(strObjects));
}
private IodineObject getEnv(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
}
IodineString str = args [0] as IodineString;
if (str == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
if (Environment.GetEnvironmentVariable(str.Value) != null)
{
return(new IodineString(Environment.GetEnvironmentVariable(str.Value)));
}
return(null);
}
private IodineObject Join(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineString thisObj = self as IodineString;
StringBuilder accum = new StringBuilder();
IodineObject collection = args [0].GetIterator(vm);
collection.IterReset(vm);
string last = "";
string sep = "";
while (collection.IterMoveNext(vm))
{
IodineObject o = collection.IterGetCurrent(vm);
accum.AppendFormat("{0}{1}", last, sep);
last = o.ToString(vm).ToString();
sep = thisObj.Value;
}
accum.Append(last);
return(new IodineString(accum.ToString()));
}
private IodineObject indexOf(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString ch = args [0] as IodineString;
char val;
if (ch == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
val = ch.Value [0];
return(new IodineInteger(Value.IndexOf(val)));
}
private IodineObject System(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString command = args [0] as IodineString;
if (command == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
bool isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT ||
Environment.OSVersion.Platform == PlatformID.Win32S ||
Environment.OSVersion.Platform == PlatformID.Win32Windows ||
Environment.OSVersion.Platform == PlatformID.WinCE ||
Environment.OSVersion.Platform == PlatformID.Xbox;
Process proc = null;
if (isWindows)
{
proc = Popen_Win32(command.Value, false, false);
}
else
{
proc = Popen_Unix(command.Value, false, false);
}
proc.Start();
proc.WaitForExit();
return(new IodineInteger(proc.ExitCode));
}
private IodineObject Substring(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineString thisObj = self as IodineString;
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
int start = 0;
int len = 0;
IodineInteger startObj = args [0] as IodineInteger;
if (startObj == null)
{
vm.RaiseException(new IodineTypeException("Int"));
return(null);
}
start = (int)startObj.Value;
if (args.Length == 1)
{
len = thisObj.Value.Length;
}
else
{
IodineInteger endObj = args [1] as IodineInteger;
if (endObj == null)
{
vm.RaiseException(new IodineTypeException("Int"));
return(null);
}
len = (int)endObj.Value;
}
if (start < thisObj.Value.Length && len <= thisObj.Value.Length)
{
return(new IodineString(thisObj.Value.Substring(start, len - start)));
}
vm.RaiseException(new IodineIndexException());
return(null);
}
private IodineObject on(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString e = args [0] as IodineString;
if (e == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
if (!listeners.ContainsKey(e.Value))
{
listeners.Add(e.Value, new List <IodineObject> ());
}
listeners [e.Value].Add(args [1]);
return(null);
}
private IodineObject Copytree(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 2)
{
vm.RaiseException(new IodineArgumentException(2));
return(null);
}
IodineString src = args [0] as IodineString;
IodineString dest = args [1] as IodineString;
if (dest == null || src == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
CopyDir(src.Value, dest.Value, true);
return(null);
}
public override void Accept (UseStatement useStmt)
{
string import = !useStmt.Relative ? useStmt.Module : Path.Combine (
Path.GetDirectoryName (useStmt.Location.File),
useStmt.Module);
/*
* Implementation detail: The use statement in all reality is simply an
* alias for the function require (); Here we translate the use statement
* into a call to the require function
*/
if (useStmt.Wildcard) {
module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst,
module.DefineConstant (new IodineString (import)));
module.Initializer.EmitInstruction (useStmt.Location, Opcode.BuildTuple, 0);
module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadGlobal,
module.DefineConstant (new IodineName ("require")));
module.Initializer.EmitInstruction (useStmt.Location, Opcode.Invoke, 2);
module.Initializer.EmitInstruction (useStmt.Location, Opcode.Pop);
} else {
IodineObject[] items = new IodineObject [useStmt.Imports.Count];
module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst,
module.DefineConstant (new IodineString (import)));
if (items.Length > 0) {
for (int i = 0; i < items.Length; i++) {
items [i] = new IodineString (useStmt.Imports [i]);
module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadConst,
module.DefineConstant (new IodineString (useStmt.Imports [i])));
}
module.Initializer.EmitInstruction (useStmt.Location, Opcode.BuildTuple, items.Length);
}
module.Initializer.EmitInstruction (useStmt.Location, Opcode.LoadGlobal,
module.DefineConstant (new IodineName ("require")));
module.Initializer.EmitInstruction (useStmt.Location, Opcode.Invoke,
items.Length == 0 ? 1 : 2);
module.Initializer.EmitInstruction (useStmt.Location, Opcode.Pop);
}
}
public static IodineOptions Parse (string[] args)
{
IodineOptions ret = new IodineOptions ();
int i;
for (i = 0; i < args.Length; i++) {
if (args [i].StartsWith ("-")) {
ret.Options.Add (args [i].Substring (1));
} else {
ret.FileName = args [i++];
if (!File.Exists (ret.FileName)) {
Panic ("Could not find file {0}!", ret.FileName);
}
break;
}
}
IodineObject[] arguments = new IodineObject [args.Length - i];
int start = i;
for (; i < args.Length; i++) {
arguments [i - start] = new IodineString (args [i]);
}
ret.IodineArguments = new IodineList (arguments);
return ret;
}
public bool TryToConvertFromPrimative(object obj, out IodineObject result)
{
result = new IodineString (obj.ToString ());
return true;
}
public static IodineOptions Parse(string[] args)
{
IodineOptions ret = new IodineOptions ();
int i;
for (i = 0; i < args.Length; i++) {
if (args [i].StartsWith ("-")) {
switch (args [i]) {
case "version":
case "v":
ret.ShowVersion = true;
break;
default:
Panic ("Unknown command line argument '{0}'", args [i]);
break;
}
} else {
ret.FileName = args [i++];
if (!System.IO.File.Exists (ret.FileName)) {
Panic ("Could not find file {0}!", ret.FileName);
}
break;
}
}
IodineObject[] arguments = new IodineObject [args.Length - i];
int start = i;
for (; i < args.Length; i++) {
arguments [i - start] = new IodineString (args [i]);
}
ret.Arguments = new IodineList (arguments);
return ret;
}
public IodineTypeDefinition(string name)
: base(TypeDefTypeDef)
{
Name = name;
attributes ["__name__"] = new IodineString (name);
}
public IodineSyntaxException(ErrorLog errorLog)
: base(TypeDefinition, "Syntax error")
{
Base = new IodineException ();
IodineObject[] errors = new IodineObject[errorLog.ErrorCount];
int i = 0;
foreach (Error error in errorLog.Errors) {
Location loc = error.Location;
string text = String.Format ("{0} ({1}:{2}) error: {3}", Path.GetFileName (loc.File),
loc.Line, loc.Column, error.Text);
errors [i++] = new IodineString (text);
}
SetAttribute ("errors", new IodineTuple (errors));
}
public void Accept(UseStatement useStmt)
{
module.Imports.Add (useStmt.Module);
string import = !useStmt.Relative ? useStmt.Module : Path.Combine (
Path.GetDirectoryName (useStmt.Location.File),
useStmt.Module);
if (useStmt.Wildcard) {
module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant (
new IodineString (import)));
module.Initializer.EmitInstruction (Opcode.BuildTuple, 0);
module.Initializer.EmitInstruction (Opcode.LoadGlobal, module.DefineConstant (
new IodineName ("require")));
module.Initializer.EmitInstruction (Opcode.Invoke, 2);
module.Initializer.EmitInstruction (Opcode.Pop);
} else {
IodineObject[] items = new IodineObject [useStmt.Imports.Count];
module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant (
new IodineString (import)));
if (items.Length > 0) {
for (int i = 0; i < items.Length; i++) {
items [i] = new IodineString (useStmt.Imports [i]);
module.Initializer.EmitInstruction (Opcode.LoadConst, module.DefineConstant (
new IodineString (useStmt.Imports [i])));
}
module.Initializer.EmitInstruction (Opcode.BuildTuple, items.Length);
}
module.Initializer.EmitInstruction (Opcode.LoadGlobal, module.DefineConstant (
new IodineName ("require")));
module.Initializer.EmitInstruction (Opcode.Invoke, items.Length == 0 ? 1 : 2);
module.Initializer.EmitInstruction (Opcode.Pop);
}
}
