public IodineMatch(Match val)
: base(MatchTypeDef)
{
Value = val;
SetAttribute("value", new IodineString(val.Value));
SetAttribute("success", IodineBool.Create(val.Success));
}
IodineObject IsMatch(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
var regexObj = self as IodineRegex;
if (regexObj == null)
{
vm.RaiseException(new IodineFunctionInvocationException());
return(null);
}
var expr = args [0] as IodineString;
if (expr == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
return(IodineBool.Create(regexObj.Value.IsMatch(expr.ToString())));
}
private IodineObject unpackObj(VirtualMachine vm, BinaryReader br, char type, int arg)
{
switch (type)
{
case '?':
{
return(IodineBool.Create(br.ReadBoolean()));
}
case 'b':
{
return(new IodineInteger(br.ReadSByte()));
}
case 'B':
{
return(new IodineInteger(br.ReadByte()));
}
case 'h':
{
return(new IodineInteger(br.ReadInt16()));
}
case 'H':
{
return(new IodineInteger(br.ReadUInt16()));
}
case 'l':
case 'i':
{
return(new IodineInteger(br.ReadInt32()));
}
case 'I':
case 'L':
{
return(new IodineInteger(br.ReadUInt32()));
}
case 'q':
{
return(new IodineInteger(br.ReadInt64()));
}
case 'Q':
{
return(new IodineInteger((long)br.ReadUInt64()));
}
case 'p':
case 's':
{
return(new IodineString(Encoding.ASCII.GetString(br.ReadBytes(arg))));
}
}
return(null);
}
public virtual IodineObject Equals(VirtualMachine vm, IodineObject right)
{
if (Attributes.ContainsKey("__equals__"))
{
return(GetAttribute(vm, "__equals__").Invoke(vm, new IodineObject[] { right }));
}
return(IodineBool.Create(this == right));
}
public virtual IodineObject NotEquals(VirtualMachine vm, IodineObject left)
{
if (Attributes.ContainsKey("__notequals__"))
{
return(GetAttribute(vm, "__notequals__").Invoke(vm, new IodineObject[] { left }));
}
return(IodineBool.Create(this != left));
}
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())));
}
public IodineMatch(Match val)
: base(MatchTypeDef)
{
Value = val;
SetAttribute("value", new IodineString(val.Value));
SetAttribute("success", IodineBool.Create(val.Success));
SetAttribute("getNextMatch", new InternalMethodCallback(getNextMatch, this));
}
private IodineObject endsWith(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(IodineBool.Create(Value.EndsWith(args [0].ToString())));
}
private IodineObject Call(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
IodineString program = args [0] as IodineString;
string arguments = "";
bool useShell = false;
if (program == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
if (args.Length > 1)
{
IodineString argObj = args [1] as IodineString;
if (argObj == null)
{
vm.RaiseException(new IodineTypeException("Str"));
return(null);
}
arguments = argObj.Value;
}
if (args.Length > 2)
{
IodineBool useShellObj = args [1] as IodineBool;
if (useShellObj == null)
{
vm.RaiseException(new IodineTypeException("Bool"));
return(null);
}
useShell = useShellObj.Value;
}
ProcessStartInfo info = new ProcessStartInfo();
info.FileName = program.Value;
info.Arguments = arguments;
info.UseShellExecute = useShell;
Process proc = Process.Start(info);
proc.WaitForExit();
return(new IodineInteger(proc.ExitCode));
}
public override IodineObject PerformUnaryOperation(VirtualMachine vm, UnaryOperation op)
{
switch (op)
{
case UnaryOperation.BoolNot:
return(IodineBool.Create(!Value));
}
return(null);
}
private IodineObject contains(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(IodineBool.Create(Dict.ContainsKey(args [0].GetHashCode())));
}
public override IodineObject GreaterThanOrEqual(VirtualMachine vm, IodineObject right)
{
BigInteger intVal;
if (!ConvertToBigInt(right, out intVal))
{
vm.RaiseException(new IodineTypeException("Right hand side must be of type Int!"));
}
return(IodineBool.Create(Value >= intVal));
}
public override IodineObject NotEquals(VirtualMachine vm, IodineObject right)
{
var str = right as IodineString;
if (str == null)
{
return(base.NotEquals(vm, right));
}
return(IodineBool.Create(str.Value != Value));
}
public override IodineObject NotEquals(VirtualMachine vm, IodineObject right)
{
IodineBytes str = right as IodineBytes;
if (str == null)
{
return(base.NotEquals(vm, right));
}
return(IodineBool.Create(!Enumerable.SequenceEqual <byte> (str.Value, Value)));
}
public override IodineObject GreaterThanOrEqual(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(IodineBool.Create(Value >= intVal.Value));
}
private IodineObject StartsWith(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineString thisObj = self as IodineString;
if (args.Length < 1)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(IodineBool.Create(thisObj.Value.StartsWith(args [0].ToString())));
}
public override IodineObject Equals(VirtualMachine vm, IodineObject right)
{
IodineList listVal = right as IodineList;
if (listVal == null)
{
vm.RaiseException(new IodineTypeException("List"));
return(null);
}
return(IodineBool.Create(compare(this, listVal)));
}
public override IodineObject Equals(VirtualMachine vm, IodineObject right)
{
IodineHashMap hash = right as IodineHashMap;
if (hash == null)
{
vm.RaiseException(new IodineTypeException("HashMap"));
return(null);
}
return(IodineBool.Create(compareTo(hash)));
}
public override bool Equals(IodineObject obj)
{
IodineBool boolVal = obj as IodineBool;
if (boolVal != null)
{
return(boolVal.Value == Value);
}
return(false);
}
public override IodineObject NotEquals(VirtualMachine vm, IodineObject right)
{
var boolVal = right as IodineBool;
if (boolVal == null)
{
vm.RaiseException("Right hand side expected to be Bool!");
return(null);
}
return(IodineBool.Create(boolVal.Value != Value));
}
IodineObject Contains(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
var thisObj = self as IodineDictionary;
if (args.Length <= 0)
{
vm.RaiseException(new IodineArgumentException(1));
return(null);
}
return(IodineBool.Create(thisObj.dict.ContainsKey(args [0])));
}
public override IodineObject Equals(VirtualMachine vm, IodineObject right)
{
var hash = right as IodineDictionary;
if (hash == null)
{
vm.RaiseException(new IodineTypeException("HashMap"));
return(null);
}
return(IodineBool.Create(Equals(hash)));
}
IodineObject Empty(VirtualMachine vm, IodineObject self, IodineObject [] args)
{
var thisObj = self as IodineSubprocess;
if (thisObj == null)
{
vm.RaiseException(new IodineFunctionInvocationException());
return(null);
}
return(IodineBool.Create(thisObj.Value.StandardOutput.Peek() < 0));
}
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));
}
private static IodineObject Locked(VirtualMachine vm, IodineObject self, IodineObject[] args)
{
IodineLock spinlock = self as IodineLock;
if (spinlock == null)
{
vm.RaiseException(new IodineTypeException(TypeDefinition.Name));
return(null);
}
return(IodineBool.Create(spinlock.IsLocked()));
}
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 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));
}
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));
}
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));
}
public override IodineObject LessThanOrEqual(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(Value <= floatVal));
}
