private IodineObject unzip (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
var archiveName = args [0] as IodineString;
var targetDir = args [1] as IodineString;
ZipFile.ExtractToDirectory (archiveName.Value, targetDir.Value);
return null;
}
public override IodineObject Invoke (VirtualMachine vm, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
}
if (args [0] is IodineFloat) {
IodineFloat fp = args [0] as IodineFloat;
return new IodineInteger ((long)fp.Value);
}
long value;
NumberStyles style = NumberStyles.AllowLeadingSign;
if (args.Length > 1) {
IodineInteger basen = args [1] as IodineInteger;
switch (basen.Value) {
case 16:
style = NumberStyles.HexNumber;
break;
}
}
if (!Int64.TryParse (args [0].ToString (), style, null, out value)) {
vm.RaiseException (new IodineTypeCastException ("Int"));
return null;
} else {
return new IodineInteger (value);
}
}
private IodineObject sha1 (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
return null;
}
byte[] bytes = new byte[]{};
byte[] hash = null;
SHA1Managed hashstring = new SHA1Managed();
if (args[0] is IodineString) {
bytes = System.Text.Encoding.UTF8.GetBytes (args[0].ToString ());
hash = hashstring.ComputeHash(bytes);
} else if (args[0] is IodineByteArray) {
bytes = ((IodineByteArray)args[0]).Array;
hash = hashstring.ComputeHash(bytes);
} else if (args[0] is IodineStream) {
hash = hashstring.ComputeHash(((IodineStream)args[0]).File);
} else {
vm.RaiseException (new IodineTypeException ("Str"));
return null;
}
return new IodineByteArray (hash);
}
private IodineObject listDirectories (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
return null;
}
if (!(args [0] is IodineString)) {
vm.RaiseException (new IodineTypeException ("Str"));
return null;
}
if (!Directory.Exists (args [0].ToString ())) {
vm.RaiseException (new IodineIOException ("Directory '" + args [0].ToString () +
"' does not exist!"));
return null;
}
IodineList ret = new IodineList (new IodineObject[]{ });
foreach (string dir in Directory.GetDirectories (args[0].ToString ())) {
ret.Add (new IodineString (dir));
}
return ret;
}
private IodineObject push (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
foreach (IodineObject obj in args) {
Stack.Push (obj);
}
return null;
}
public IodineProperty(IodineObject getter, IodineObject setter, IodineObject self)
: base(TypeDefinition)
{
Setter = setter;
Getter = getter;
this.self = self;
}
public override IodineObject Invoke (VirtualMachine vm, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
}
return new IodineBytes (args [0].ToString ());
}
public override IodineObject Invoke (VirtualMachine vm, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
}
return IodineBool.Create (Boolean.Parse (args [0].ToString ()));
}
private IodineObject write (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (Closed) {
vm.RaiseException (new IodineIOException ("Stream has been closed!"));
return null;
}
if (!CanWrite) {
vm.RaiseException (new IodineIOException ("Can not write to stream!"));
return null;
}
foreach (IodineObject obj in args) {
if (obj is IodineString) {
write (obj.ToString ());
} else if (obj is IodineBytes) {
IodineBytes arr = obj as IodineBytes;
File.Write (arr.Value, 0, arr.Value.Length);
} else if (obj is IodineInteger) {
IodineInteger intVal = obj as IodineInteger;
write ((byte)intVal.Value);
} else if (obj is IodineByteArray) {
IodineByteArray arr = obj as IodineByteArray;
File.Write (arr.Array, 0, arr.Array.Length);
} else {
vm.RaiseException (new IodineTypeException (""));
}
}
return null;
}
private IodineObject randInt (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0) {
return new IodineInteger (rgn.Next (Int32.MinValue, Int32.MaxValue));
} else {
int start = 0;
int end = 0;
if (args.Length <= 1) {
IodineInteger integer = args [0] as IodineInteger;
if (integer == null) {
vm.RaiseException (new IodineTypeException ("Int"));
return null;
}
end = (int)integer.Value;
} else {
IodineInteger startInteger = args [0] as IodineInteger;
IodineInteger endInteger = args [1] as IodineInteger;
if (startInteger == null || endInteger == null) {
vm.RaiseException (new IodineTypeException ("Int"));
return null;
}
start = (int)startInteger.Value;
end = (int)endInteger.Value;
}
return new IodineInteger (rgn.Next (start, end));
}
}
private IodineObject pow (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 1) {
vm.RaiseException (new IodineArgumentException (2));
return null;
}
double a1 = 0;
double a2 = 0;
if (args [0] is IodineInteger) {
a1 = (double)((IodineInteger)args [0]).Value;
} else if (args [0] is IodineFloat) {
a1 = ((IodineFloat)args [0]).Value;
} else {
vm.RaiseException (new IodineTypeException ("Float"));
return null;
}
if (args [1] is IodineInteger) {
a2 = (double)((IodineInteger)args [1]).Value;
} else if (args [1] is IodineFloat) {
a2 = ((IodineFloat)args [1]).Value;
} else {
vm.RaiseException (new IodineTypeException ("Float"));
return null;
}
return new IodineFloat (Math.Pow (a1, a2));
}
private IodineObject append (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
foreach (IodineObject obj in args) {
buffer.Append (obj.ToString (vm));
}
return null;
}
public override void SetAttribute (VirtualMachine vm, string name, IodineObject value)
{
if (!initializerInvoked) {
initializerInvoked = true;
Initializer.Invoke (vm, new IodineObject[] { });
}
base.SetAttribute (vm, name, value);
}
public override IodineObject Invoke (VirtualMachine vm, IodineObject[] args)
{
if (args.Length >= 1) {
IodineList inputList = args [0] as IodineList;
return new IodineTuple (inputList.Objects.ToArray ());
}
return null;
}
public IodineGenerator(StackFrame parentFrame, IodineInstanceMethodWrapper baseMethod,
IodineObject[] args)
: base(TypeDef)
{
arguments = args;
self = baseMethod.Self;
this.baseMethod = baseMethod.Method;
}
public IodineObject BindAttributes(IodineObject obj)
{
foreach (KeyValuePair<string, IodineObject> kv in attributes) {
if (!obj.HasAttribute (kv.Key))
obj.SetAttribute (kv.Key, kv.Value);
}
return obj;
}
private IodineObject getProcList(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineList list = new IodineList (new IodineObject[] { });
foreach (Process proc in Process.GetProcesses ()) {
list.Add (new IodineProc (proc));
}
return list;
}
public override IodineObject GetIndex (VirtualMachine vm, IodineObject key)
{
IodineInteger index = key as IodineInteger;
if (index.Value < Objects.Length)
return Objects [(int)index.Value];
vm.RaiseException (new IodineIndexException ());
return null;
}
public override bool IterMoveNext(VirtualMachine vm)
{
if (stackFrame.AbortExecution) {
return false;
}
value = vm.InvokeMethod (baseMethod, stackFrame, self, arguments);
return stackFrame.Yielded;
}
private IodineObject getValue (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
string name = args [0].ToString ();
IodineObject ioval = null;
object val = Key.GetValue (name);
//IodineTypeConverter.Instance.ConvertFromPrimative (val, out ioval);
return ioval;
}
public IodineObject executeSql(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
var db = (IodineMySQLConnection)self;
var statement = (IodineString)args [0];
MySqlCommand cmd = new MySqlCommand (statement.Value, db.Connection);
cmd.ExecuteNonQuery ();
cmd.Dispose ();
return null;
}
public StackFrame (IodineMethod method, StackFrame parent, IodineObject self, int localCount)
{
LocalCount = localCount;
locals = new IodineObject[localCount];
parentLocals = locals;
Method = method;
Self = self;
Parent = parent;
}
public StackFrame (IodineMethod method, StackFrame parent, IodineObject self, int localCount,
IodineObject[] locals) : this (method, parent, self, localCount)
{
parentLocals = locals;
this.locals = new IodineObject[localCount];
for (int i = 0; i < localCount; i++) {
this.locals [i] = locals [i];
}
}
private IodineObject sleep(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0) {
vm.RaiseException (new IodineArgumentException (1));
}
IodineInteger time = args [0] as IodineInteger;
System.Threading.Thread.Sleep ((int)time.Value);
return null;
}
public override IodineObject Equals(VirtualMachine vm, IodineObject right)
{
IodineBool boolVal = right as IodineBool;
if (boolVal == null) {
vm.RaiseException ("Right hand side expected to be Bool!");
return null;
}
return IodineBool.Create (boolVal.Value == Value);
}
private static IEnumerator internalChain(VirtualMachine vm, IodineObject[] args)
{
foreach (IodineObject obj in args) {
obj.IterReset (vm);
while (obj.IterMoveNext (vm)) {
yield return obj.IterGetCurrent (vm);
}
}
}
public bool TryToConvertFromPrimative(object obj, out IodineObject result)
{
if (obj is IConvertible) {
result = new IodineInteger (Convert.ToInt64 (obj));
return true;
}
result = null;
return false;
}
private MySqlCommand prepareCmd(ref MySqlCommand cmd, IodineObject[] args)
{
cmd.Prepare ();
for (int i = 1; i < args.Length; i++) {
IodineMySQLParameter arg = (IodineMySQLParameter)args [i];
cmd.Parameters.Add (new MySqlParameter(arg.ParameterName, arg.Value.ToString()));
}
return cmd;
}
public override IodineObject ConvertFrom(TypeRegistry registry, object obj)
{
object[] arr = (object[])obj;
IodineObject[] iodineObjects = new IodineObject[arr.Length];
for (int i = 0; i < arr.Length; i++) {
iodineObjects [i] = registry.ConvertToIodineObject (arr [i]);
}
return new IodineList (iodineObjects);
}
private IodineObject setValue (VirtualMachine vm, IodineObject self, IodineObject[] args)
{
string name = args [0].ToString ();
IodineObject ioval = args [1];
object val = null;
//IodineTypeConverter.Instance.ConvertToPrimative (ioval, out val);
Key.SetValue (name, val);
return null;
}
public StackFrame(
VirtualMachine vm,
IodineModule module,
IodineMethod method,
IodineObject [] arguments,
StackFrame parent,
IodineObject self,
AttributeDictionary locals) : this(vm, module, method, arguments, parent, self)
{
this.locals = locals;
}
public override IodineObject Mul(VirtualMachine vm, IodineObject right)
{
long longVal;
if (!MarshalUtil.MarshalAsInt64(right, out longVal))
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
}
return(new IodineInteger(Value * longVal));
}
public override bool Equals(IodineObject obj)
{
IodineInteger intVal = obj as IodineInteger;
if (intVal != null)
{
return(intVal.Value == Value);
}
return(false);
}
public override IodineObject ClosedRange(VirtualMachine vm, IodineObject right)
{
IodineInteger intVal = right as IodineInteger;
if (intVal == null)
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
return(null);
}
return(new IodineRange(Value, intVal.Value + 1, 1));
}
/// <summary>
/// Multiplication operator (*)
/// </summary>
public virtual IodineObject Mul(VirtualMachine vm, IodineObject right)
{
if (Attributes.ContainsKey("__mul__"))
{
return(GetAttribute(vm, "__mul__").Invoke(vm, new IodineObject[] { right }));
}
vm.RaiseException(new IodineNotSupportedException(
"The requested binary operator has not been implemented")
);
return(null);
}
public override IodineObject BindAttributes(IodineObject obj)
{
obj.SetAttribute("write", new BuiltinMethodCallback(Write, obj));
obj.SetAttribute("writeln", new BuiltinMethodCallback(Writeln, obj));
obj.SetAttribute("read", new BuiltinMethodCallback(Read, obj));
obj.SetAttribute("readln", new BuiltinMethodCallback(Readln, obj));
obj.SetAttribute("kill", new BuiltinMethodCallback(Kill, obj));
obj.SetAttribute("empty", new BuiltinMethodCallback(Empty, obj));
obj.SetAttribute("alive", new BuiltinMethodCallback(Alive, obj));
return(base.BindAttributes(obj));
}
public override IodineObject RightShift(VirtualMachine vm, IodineObject right)
{
IodineInteger intVal = right as IodineInteger;
if (intVal == null)
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
return(null);
}
return(new IodineInteger(Value >> (int)intVal.Value));
}
public virtual IodineObject BindAttributes(IodineObject obj)
{
foreach (KeyValuePair <string, IodineObject> kv in Attributes)
{
if (!obj.HasAttribute(kv.Key))
{
obj.SetAttribute(kv.Key, kv.Value);
}
}
return(obj);
}
public override bool Equals(IodineObject obj)
{
BigInteger intVal;
if (ConvertToBigInt(obj, out intVal))
{
return(intVal == Value);
}
return(false);
}
public override IodineObject RightShift(VirtualMachine vm, IodineObject right)
{
BigInteger intVal;
if (!ConvertToBigInt(right, out intVal))
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
return(null);
}
return(new IodineBigInt(Value / BigInteger.Pow(2, (int)(uint)intVal)));
}
public override IodineObject GetIndex(VirtualMachine vm, IodineObject key)
{
var index = key as IodineInteger;
if (index.Value < Objects.Length)
{
return(Objects [(int)index.Value]);
}
vm.RaiseException(new IodineIndexException());
return(null);
}
public override IodineObject LessThanOrEqual(VirtualMachine vm, IodineObject right)
{
BigInteger intVal;
if (!ConvertToBigInt(right, out intVal))
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
return(null);
}
return(IodineBool.Create(Value <= intVal));
}
public override IodineObject GreaterThanOrEqual(VirtualMachine vm, IodineObject right)
{
IodineTimeStamp op = right as IodineTimeStamp;
if (op == null)
{
vm.RaiseException(new IodineTypeException(
"Right hand value expected to be of type TimeStamp"));
return(null);
}
return(IodineBool.Create(Value.CompareTo(op.Value) >= 0));
}
static IodineObject Alive(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
var thread = self as IodineThread;
if (thread == null)
{
vm.RaiseException(new IodineTypeException(TypeDefinition.Name));
return(null);
}
return(IodineBool.Create(thread.Value.IsAlive));
}
IodineObject Sleep(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
}
var time = args [0] as IodineInteger;
Thread.Sleep((int)time.Value);
return(null);
}
public override IodineObject NotEquals(VirtualMachine vm, IodineObject right)
{
double floatVal;
if (!(TryConvertToFloat(right, out floatVal)))
{
vm.RaiseException(new IodineTypeException(
"Right hand value expected to be of type Float"));
return(null);
}
return(IodineBool.Create(Math.Abs(Value - floatVal) > double.Epsilon));
}
private IodineObject getInterfaces(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineObject o1 = args [0];
IodineList list = new IodineList(o1.Interfaces.ToArray());
return(list);
}
public override IodineObject Add(VirtualMachine vm, IodineObject right)
{
var list = new IodineList(Objects.ToArray());
right.IterReset(vm);
while (right.IterMoveNext(vm))
{
var o = right.IterGetCurrent(vm);
list.Add(o);
}
return(list);
}
private IodineObject Empty(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineSubprocess proc = self as IodineSubprocess;
if (proc == null)
{
vm.RaiseException(new IodineTypeException(TypeDefinition.Name));
return(null);
}
return(IodineBool.Create(proc.Value.StandardOutput.Peek() < 0));
}
public virtual void SetAttribute(VirtualMachine vm, string name, IodineObject value)
{
if (Base != null && !Attributes.ContainsKey(name))
{
if (Base.HasAttribute(name))
{
Base.SetAttribute(vm, name, value);
return;
}
}
SetAttribute(name, value);
}
public override bool IterMoveNext(VirtualMachine vm)
{
if (frame.AbortExecution)
{
return(false);
}
vm.NewFrame(frame);
value = vm.EvalCode(Target);
vm.EndFrame();
return(frame.Yielded);
}
private IodineObject Upper(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
var thisObj = self as IodineString;
if (thisObj == null)
{
vm.RaiseException(new IodineFunctionInvocationException());
return(null);
}
return(new IodineString(thisObj.Value.ToUpper()));
}
private IodineObject Flush(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineStream thisObj = self as IodineStream;
if (thisObj.Closed)
{
vm.RaiseException("Stream has been closed!");
return(null);
}
thisObj.File.Flush();
return(null);
}
IodineObject Prepend(VirtualMachine vm, IodineObject self, IodineObject [] arguments)
{
var thisObj = self as IodineList;
if (arguments.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
thisObj.Objects.Insert(0, arguments [0]);
return(thisObj);
}
private IodineObject Alive(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineSubprocess proc = self as IodineSubprocess;
if (proc == null)
{
vm.RaiseException(new IodineTypeException(TypeDefinition.Name));
return(null);
}
return(IodineBool.Create(proc.Value.HasExited));
}
private StackFrame(
IodineModule module,
IodineMethod method,
IodineObject[] arguments,
StackFrame parent,
IodineObject self,
AttributeDictionary locals,
AttributeDictionary parentLocals) : this(module, method, arguments, parent, self)
{
this.parentLocals = parentLocals;
this.locals = locals;
}
private IodineObject Read(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineSubprocess proc = self as IodineSubprocess;
if (proc == null)
{
vm.RaiseException(new IodineTypeException(TypeDefinition.Name));
return(null);
}
return(new IodineString(proc.Value.StandardOutput.ReadToEnd()));
}
private IodineObject property(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineObject getter = args [0];
IodineObject setter = args.Length > 1 ? args [1] : null;
return(new IodineProperty(getter, setter, null));
}
public override void Inherit(VirtualMachine vm, IodineObject self, IodineObject[] arguments)
{
foreach (IodineMethod method in RequiredMethods)
{
if (!self.HasAttribute(method.Name))
{
vm.RaiseException(new IodineNotSupportedException());
return;
}
}
self.Interfaces.Add(this);
}
static IodineObject GetNextMatch(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
var match = self as IodineMatch;
if (match == null)
{
vm.RaiseException(new IodineFunctionInvocationException());
return(null);
}
return(new IodineMatch(match.Value.NextMatch()));
}