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 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)); }
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)); }
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()))); }
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()))); }
public override IodineObject PerformUnaryOperation(VirtualMachine vm, UnaryOperation op) { switch (op) { case UnaryOperation.BoolNot: return(IodineBool.Create(!Value)); } return(null); }
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) { 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 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)); }
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))); }
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()))); }
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 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)); }
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 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))); }
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)); }
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)); }
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 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 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)); }
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)); }
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())); }
IodineObject Alive(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.HasExited)); }
private IodineObject isSymbol(VirtualMachine vm, IodineObject self, IodineObject[] args) { bool result = Value.Length == 0 ? false : true; for (int i = 0; i < Value.Length; i++) { if (!char.IsSymbol(Value [i])) { return(IodineBool.False); } } return(IodineBool.Create(result)); }