public static bool ToBoolean(BoxedValue v) { switch (v.Tag) { case TypeTags.Bool: return v.Bool; case TypeTags.String: return !string.IsNullOrEmpty(v.String); case TypeTags.SuffixString: var ss = (SuffixString)v.Clr; return ss.Length > 0; case TypeTags.Undefined: return false; case TypeTags.Clr: return v.Clr != null; case TypeTags.Object: case TypeTags.Function: return true; default: return ToBoolean(v.Number); } }
public UserError(BoxedValue value, int line, int column) : base(TypeConverter.ToString(value)) { Value = value; Line = line; Column = column; }
/// <summary> /// Represents low-level networking call that can be used to transmit an event to the browser. /// </summary> /// <param name="client">The client to transmit the event to.</param> /// <param name="propertyName">The name of the event to transmit.</param> /// <param name="type">The type of the event to transmit.</param> /// <param name="eventValue">The value of the event to transmit.</param> internal static void SendEvent(ClientObject client, AppEventType type, BoxedValue target, string eventName, BoxedValue eventValue) { try { // Check if the target is an object and retrieve the id. var oid = 0; if (target.IsObject && target.Object is BaseObject) oid = ((BaseObject)target.Object).Oid; // Get the client var channel = client.Target; // Convert to a string var stringValue = TypeConverter.ToNullableString( Native.Serialize(client.Env, eventValue, true) ); // Dispatch the inform channel.TransmitEvent(type, oid, eventName, stringValue); } catch (Exception ex) { // Log the exception Service.Logger.Log(ex); } }
/// <summary> /// Opens a file, appends the specified string to the file, and then closes the file. If the file does not exist, this method creates a file, writes the specified string to the file, then closes the file. /// </summary> internal static void AppendJson(FunctionObject ctx, ScriptObject instance, BoxedValue path, BoxedValue contents, BoxedValue onComplete, BoxedValue encodingName) { if (!path.IsString) throw new ArgumentException("[appendJson] First parameter should be defined and be a string."); if (!contents.IsStrictlyObject) throw new ArgumentException("[appendJson] Second parameter should be defined and be an object."); if (!onComplete.IsUndefined && !onComplete.IsFunction) throw new ArgumentException("[appendJson] Third parameter should be an onComplete function."); // Get the curent channel var channel = Channel.Current; // Dispatch the task channel.Async(() => { // The encoding to use Encoding encoding = encodingName.IsString ? TextEncoding.GetEncoding(encodingName.String) : null; // Defaults to UTF8 if (encoding == null) encoding = TextEncoding.UTF8; // Unbox the array of lines and execute the append File.AppendAllText( path.Unbox<string>(), Native.Serialize(instance.Env, contents, false).Unbox<string>(), encoding ); // Dispatch the on complete asynchronously channel.DispatchCallback(onComplete, instance); }); }
/// <summary> /// Represents an event fired when a script object property has been changed. /// </summary> /// <param name="instance">The instance of the script object that contains the property.</param> /// <param name="changeType">The type of the change.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="newValue">The new value of the property.</param> /// <param name="oldValue">The old value of the property.</param> public static void OnPropertyChange(ScriptObject instance, PropertyChangeType changeType, string propertyName, BoxedValue newValue, BoxedValue oldValue) { // Ignore identifier property if (propertyName == "$i") return; switch (changeType) { // Occurs when a new property is assigned to an object, either by // using the indexer, property access or array methods. case PropertyChangeType.Put: { // We need to make sure the new value is marked as observed // as well, so its members will notify us too. if (newValue.IsStrictlyObject) newValue.Object.Observe(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Put, instance.Oid, propertyName, newValue); break; } // Occurs when a property change occurs, by using an assignment // operator, or the array indexer. case PropertyChangeType.Set: { // We need to unmark the old value and ignore it, as we no // longer require observations from that value. if (oldValue.IsStrictlyObject) oldValue.Object.Ignore(); // We need to make sure the new value is marked as observed // as well, so its members will notify us too. if (newValue.IsStrictlyObject) newValue.Object.Observe(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Set, instance.Oid, propertyName, newValue); break; } // Occurs when a property was deleted from the object, either by // using a 'delete' keyword or the array removal methods. case PropertyChangeType.Delete: { // We need to unmark the old value and ignore it, as we no // longer require observations from that value. if (oldValue.IsStrictlyObject) oldValue.Object.Ignore(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Delete, instance.Oid, propertyName, newValue); break; } } //Console.WriteLine("Observe: [{0}] {1} = {2}", changeType.ToString(), propertyName, propertyValue); }
public static void TaskFunction(BoxedValue options) { var paths = options.ComplexProperty("Paths").ToArray<string>(); var numberOfRetries = options.SimpleProperty<double>("NumberOfRetries"); System.Console.WriteLine(numberOfRetries); TaskFunction(paths); }
private static BoxedValue GetPathOf(BoxedValue path) { var filePath = TypeConverter.ToString(path); var file = new FileInfo(filePath); var directory = file.DirectoryName; return TypeConverter.ToBoxedValue(directory); }
public override sealed void Put(string name, BoxedValue value) { int index = 0; if (this.CanPut(name, out index)) { this.Properties[index].Value = value; this.Properties[index].HasValue = true; } }
/// <summary> /// Initializes a new instance of the <see cref="ArgumentsObject"/> class. /// </summary> /// <param name="env">The environment.</param> /// <param name="linkMap">The link map.</param> /// <param name="privateScope">The private scope.</param> /// <param name="sharedScope">The shared scope.</param> public ArgumentsObject( Environment env, ArgLink[] linkMap, BoxedValue[] privateScope, BoxedValue[] sharedScope) : base(env, env.Maps.Base, env.Prototypes.Object) { PrivateScope = privateScope; SharedScope = sharedScope; LinkMap = linkMap; }
private BoxedValue GetDirectoryFiles(BoxedValue options) { var directoryPath = options.SimpleProperty<string>("directory"); var searchPattern = "*.*"; if (options.Has("pattern")) searchPattern = options.SimpleProperty<string>("pattern"); var recurse = SearchOption.TopDirectoryOnly; if (options.Has("recurse")) recurse = SearchOption.AllDirectories; var files = Directory.GetFiles(directoryPath, searchPattern, recurse); return files.ToBoxedValue(context.Environment); }
/// <summary> /// Implements the binary `in` operator. /// </summary> public static bool @in(Environment env, BoxedValue l, BoxedValue r) { if (!r.IsObject) { return env.RaiseTypeError<bool>("Right operand is not a object"); } uint index = 0; if (TypeConverter.TryToIndex(l, out index)) { return r.Object.Has(index); } string name = TypeConverter.ToString(l); return r.Object.Has(name); }
/// <summary> /// Creates a new instance of an object. /// </summary> /// <param name="prototype">The prototype to use.</param> /// <param name="param">Either the size of the buffer, a string or the array of octets.</param> /// <param name="encodingName">The encoding of a string.</param> public BufferObject(ScriptObject prototype, BoxedValue param, BoxedValue encodingName) : base(prototype) { if (param.IsNumber) { // Create a new array with the provided size this.Buffer = new ArraySegment<byte>( new byte[(int)param.Number] ); this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly); return; } if (param.IsString) { // The encoding to use Encoding encoding = encodingName.IsString ? TextEncoding.GetEncoding(encodingName.String) : null; // Defaults to UTF8 if (encoding == null) encoding = TextEncoding.UTF8; // Decode this.Buffer = new ArraySegment<byte>(encoding.GetBytes(param.String)); this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly); return; } if (param.IsStrictlyObject && param.Object is ArrayObject) { // Allocate a new array var bytes = (param.Object as ArrayObject); this.Buffer = new ArraySegment<byte>(new byte[bytes.Length]); this.Put("length", this.Buffer.Count, DescriptorAttrs.ReadOnly); // Iterate through the array and convert each integer to a byte for (int i = 0; i < bytes.Length; ++i) { // Get the number and convert to byte var item = bytes.Get(i); if (item.IsNumber) this.Buffer.Array[i] = Convert.ToByte(item.Number); } } }
/// <summary> /// Implements the binary `+` operator. /// </summary> public static BoxedValue add(BoxedValue l, BoxedValue r) { if (l.Tag == TypeTags.SuffixString) { var newString = SuffixString.Concat( l.SuffixString, TypeConverter.ToString(TypeConverter.ToPrimitive(r))); return BoxedValue.Box(newString); } if (l.Tag == TypeTags.String || r.Tag == TypeTags.String || r.Tag == TypeTags.SuffixString) { var newString = SuffixString.Concat( TypeConverter.ToString(TypeConverter.ToPrimitive(l)), TypeConverter.ToString(TypeConverter.ToPrimitive(r))); return BoxedValue.Box(newString); } var lPrim = TypeConverter.ToPrimitive(l); var rPrim = TypeConverter.ToPrimitive(r); if (lPrim.Tag == TypeTags.SuffixString) { var newString = SuffixString.Concat( lPrim.SuffixString, TypeConverter.ToString(rPrim)); return BoxedValue.Box(newString); } if (lPrim.Tag == TypeTags.String || rPrim.Tag == TypeTags.String || rPrim.Tag == TypeTags.SuffixString) { var newString = SuffixString.Concat( TypeConverter.ToString(lPrim), TypeConverter.ToString(rPrim)); return BoxedValue.Box(newString); } return BoxedValue.Box(TypeConverter.ToNumber(lPrim) + TypeConverter.ToNumber(rPrim)); }
private void TryUpdateValue(StoryInstance instance) { if (m_DlgId.HaveValue && m_Index.HaveValue) { m_HaveValue = true; int dlgId = m_DlgId.Value; int index = m_Index.Value; int dlgItemId = TableConfigUtility.GenStoryDlgItemId(dlgId, index); TableConfig.StoryDlg cfg = TableConfig.StoryDlgProvider.Instance.GetStoryDlg(dlgItemId); if (null != cfg) { m_Value = BoxedValue.From(cfg); } else { m_Value = BoxedValue.NullObject; } } }
private void TryUpdateValue() { if (m_Var.HaveValue) { object obj = m_Var.Value.Get <object>(); var dict = obj as IDictionary; m_HaveValue = true; if (null != dict) { ArrayList list = new ArrayList(); list.AddRange(dict.Values); m_Value = BoxedValue.From(list); } else { m_Value.SetNullObject(); } } }
public static uint strnappend(BoxedValue <Pointer <byte> > dest, BoxedValue <uint> dest_allocation, Pointer <byte> source, uint n) { uint source_len, required_allocation; if (dest == null || dest_allocation == null) { return(uint.MaxValue); } if (dest.Val.IsNull && dest_allocation.Val != 0) { return(uint.MaxValue); } if (source.IsNull) { return(dest_allocation.Val); } source_len = cstring.strlen(source); if (n != 0 && n < source_len) { source_len = n; } required_allocation = (dest.Val.IsNonNull ? cstring.strlen(dest.Val) : 0) + source_len + 1; if (dest_allocation.Val < required_allocation) { if (dest_allocation.Val == 0) { dest.Val = ckd_alloc.ckd_calloc <byte>(required_allocation * 2); } else { dest.Val = ckd_alloc.ckd_realloc(dest.Val, required_allocation * 2); } dest_allocation.Val = required_allocation * 2; } cstring.strncat(dest.Val, source, source_len); return(dest_allocation.Val); }
private void TryUpdateValue(StoryInstance instance) { if (m_AttrName.HaveValue) { string name = m_AttrName.Value; m_HaveValue = true; object v; if (PluginFramework.Instance.BlackBoard.TryGetVariable(name, out v)) { m_Value = BoxedValue.From(v); } else { if (m_ParamNum > 1) { m_Value = m_DefaultValue.Value; } } } }
public static int cmd_ln_free_r(Pointer <cmd_ln_t> cmdln) { if (cmdln.IsNull) { return(0); } if (--cmdln.Deref.refcount > 0) { return(cmdln.Deref.refcount); } if (cmdln.Deref.ht.IsNonNull) { Pointer <gnode_t> entries; Pointer <gnode_t> gn; BoxedValue <int> n = new BoxedValue <int>(); entries = hash_table.hash_table_tolist(cmdln.Deref.ht, n); for (gn = entries; gn.IsNonNull; gn = glist.gnode_next(gn)) { Pointer <hash_entry_t> e = (Pointer <hash_entry_t>)glist.gnode_ptr(gn); cmd_ln_val_free((Pointer <cmd_ln_val_t>)e.Deref.val); } glist.glist_free(entries); hash_table.hash_table_free(cmdln.Deref.ht); cmdln.Deref.ht = PointerHelpers.NULL <hash_table_t>(); } if (cmdln.Deref.f_argv.IsNonNull) { int i; for (i = 0; i < cmdln.Deref.f_argc; ++i) { ckd_alloc.ckd_free(cmdln.Deref.f_argv[i]); } ckd_alloc.ckd_free(cmdln.Deref.f_argv); cmdln.Deref.f_argv = PointerHelpers.NULL <Pointer <byte> >(); cmdln.Deref.f_argc = 0; } ckd_alloc.ckd_free(cmdln); return(0); }
private void TryUpdateValue(StoryInstance instance) { UserThread userThread = instance.Context as UserThread; if (null != userThread) { if (m_UserGuid.HaveValue && m_Index.HaveValue) { ulong userGuid = m_UserGuid.Value; var id = m_Index.Value; m_HaveValue = true; UserInfo ui = userThread.GetUserInfo(userGuid); if (null != ui) { if (id.Type == BoxedValue.c_ULongType) { ulong guid = id.Get <ulong>(); m_Value = BoxedValue.From(ui.ItemBag.GetItemData(guid)); } else { try { int index = id.Get <int>(); if (index >= 0 && index < ui.MemberInfos.Count) { m_Value = BoxedValue.From(ui.FriendInfos[index]); } else { m_Value = BoxedValue.NullObject; } } catch { m_Value = BoxedValue.NullObject; } } } } } }
/// <summary>Adds an ID, object combination to the index.</summary> internal void Add(object[] row, int fieldNumber) { var value = row.GetValue(fieldNumber); #if USE_BOXING BoxedValue obj = new BoxedValue(value); #else var obj = value == null ? nullValue : value; #endif if (index.ContainsKey(obj)) { index[obj].Add(row); } else { index[obj] = new List <object[]> { row }; } Count++; }
/// <summary> /// Represents low-level networking call that can be used to transmit an event to the browser. /// </summary> /// <param name="client">The client to transmit the event to.</param> /// <param name="propertyName">The name of the event to transmit.</param> /// <param name="type">The type of the event to transmit.</param> /// <param name="eventValue">The value of the event to transmit.</param> internal static void SendEvent(BoxedValue client, AppEventType type, BoxedValue target, string eventName, BoxedValue eventValue) { try { // Check if it's an object if (!client.IsObject) return; // Unbox & check if alive var unboxedClient = client.Object as ClientObject; if (unboxedClient == null && unboxedClient.IsAlive) return; // Unboxed call Native.SendEvent(unboxedClient, type, target, eventName, eventValue); } catch (Exception ex) { // Log the exception Service.Logger.Log(ex); } }
/// <summary>Removes a row from the index.</summary> /// <param name="row">The row.</param> /// <param name="fieldNumber">The fieldnumber.</param> /// <exception cref="ArgumentException"> /// Value {value} is not present at index (equals check {index})! or Row {row} is not /// present at index! (Present: {value} => {rows})! or Could not remove row {row} value {value}!. /// </exception> internal void Delete(object[] row, int fieldNumber) { var value = row.GetValue(fieldNumber); #if USE_BOXING BoxedValue obj = new BoxedValue(value); #else var obj = value == null ? nullValue : value; #endif // remove ID from old hash if (!index.TryGetValue(obj, out var rows)) { throw new ArgumentException($"Value {value} is not present at index (equals check {index.Join(",")})!"); } var i = GetRowIndex(rows, row); if (i < 0) { throw new KeyNotFoundException($"Row {row} is not present at index! (Present: {value} => {rows.Join(",")})!"); } if (rows.Count > 1) { rows.RemoveAt(i); } else { if (!index.Remove(obj)) { throw new ArgumentException($"Could not remove row {row} value {value}!"); } } Count--; }
private void TryUpdateValue(StoryInstance instance) { if (m_Spline.HaveValue && m_Offset.HaveValue) { var list = m_Spline.Value as IList <object>; Vector3 offset = m_Offset.Value; m_HaveValue = true; if (null != list) { List <object> npts = new List <object>(); int ct = list.Count; float dir = 0; Vector3 curPt = Vector3.Zero; for (int i = 0; i < ct; ++i) { if (i == 0) { curPt = (Vector3)list[i]; } Vector3 pt = Vector3.Zero; if (i + 1 < ct) { pt = (Vector3)list[i + 1]; dir = Geometry.GetYRadian(curPt, pt); } npts.Add(curPt + Geometry.GetRotate(offset, dir)); curPt = pt; } m_Value = BoxedValue.From(npts); } else { m_Value = BoxedValue.NullObject; } } }
public void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_HaveValue = false; m_X.Evaluate(instance, handler, iterator, args); if (m_X.HaveValue) { int x = m_X.Value.Get <int>(); if (x == 0) { m_HaveValue = true; m_Value = 0; } else { m_Y.Evaluate(instance, handler, iterator, args); if (m_Y.HaveValue) { int y = m_Y.Value.Get <int>(); m_HaveValue = true; m_Value = (y != 0 ? 1 : 0); } } } }
public void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_HaveValue = false; m_X.Evaluate(instance, handler, iterator, args); TryUpdateValue(); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { if (m_HaveUserId) { m_UserId.Evaluate(instance, handler, iterator, args); } for (int i = 0; i < m_UnitIds.Count; i++) { m_UnitIds[i].Evaluate(instance, handler, iterator, args); } }
public static void Map(FunctionObject _, CommonObject that, string str, BoxedValue func) { var configObj = that.CastTo<ConfigJsObject>(); configObj.configBase.Map(str, BuilderJsObject.MapBuilder(func.Func)); }
/// <summary> /// Implements the binary `<=` operator. /// </summary> public static bool ltEq(BoxedValue l, BoxedValue r) { return Compare(l, r, true, (a, b) => string.CompareOrdinal(a, b) <= 0, (a, b) => a <= b); }
/// <summary> /// Implements the unary `!` operator. /// </summary> public static bool not(BoxedValue value) { return !TypeConverter.ToBoolean(value); }
/// <summary> /// Implements the binary `>` operator. /// </summary> public static bool gt(BoxedValue l, BoxedValue r) { return Compare(l, r, true, (a, b) => string.CompareOrdinal(a, b) > 0, (a, b) => a > b); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { if (m_HaveUserId) { m_UserId.Evaluate(instance, handler, iterator, args); } m_StoryDlgId.Evaluate(instance, handler, iterator, args); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_Receiver.Evaluate(instance, handler, iterator, args); m_Title.Evaluate(instance, handler, iterator, args); m_Content.Evaluate(instance, handler, iterator, args); m_Sender.Evaluate(instance, handler, iterator, args); m_LevelDemand.Evaluate(instance, handler, iterator, args); m_ValidPeriod.Evaluate(instance, handler, iterator, args); m_Money.Evaluate(instance, handler, iterator, args); m_Gold.Evaluate(instance, handler, iterator, args); for (int i = 0; i < m_MailItems.Count; ++i) { IStoryValue <int> val = m_MailItems[i]; val.Evaluate(instance, handler, iterator, args); } }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { }
/// <summary> /// Implements the unary `~` operator. /// </summary> public static double bitCmpl(BoxedValue value) { return (double)~TypeConverter.ToInt32(TypeConverter.ToNumber(value)); }
public void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_HaveValue = false; m_Object.Evaluate(instance, handler, iterator, args); m_Method.Evaluate(instance, handler, iterator, args); bool canCalc = true; if (!m_Object.HaveValue || !m_Method.HaveValue) { canCalc = false; } if (canCalc) { m_HaveValue = true; var obj = m_Object.Value; string method = m_Method.Value; if (obj.IsObject && !string.IsNullOrEmpty(method)) { object v = 0; IEnumerable list = obj.ObjectVal as IEnumerable; if (null != list) { if (method == "orderby" || method == "orderbydesc") { bool desc = method == "orderbydesc"; ObjList results = new ObjList(); IEnumerator enumer = list.GetEnumerator(); while (enumer.MoveNext()) { object val = enumer.Current; results.Add(val); } results.Sort((object o1, object o2) => { BoxedValue r1 = BoxedValue.NullObject; for (int i = 0; i < m_Args.Count; i++) { m_Args[i].Evaluate(instance, handler, BoxedValue.From(o1), args); r1 = m_Args[i].Value; } BoxedValue r2 = BoxedValue.NullObject; for (int i = 0; i < m_Args.Count; i++) { m_Args[i].Evaluate(instance, handler, BoxedValue.From(o2), args); r2 = m_Args[i].Value; } string rs1 = r1.ToString(); string rs2 = r2.ToString(); int r = 0; if (null != rs1 && null != rs2) { r = rs1.CompareTo(rs2); } else { float rd1 = r1.Get <float>(); float rd2 = r2.Get <float>(); r = rd1.CompareTo(rd2); } if (desc) { r = -r; } return(r); }); v = results; } else if (method == "where") { ObjList results = new ObjList(); IEnumerator enumer = list.GetEnumerator(); while (enumer.MoveNext()) { object val = enumer.Current; BoxedValue r = BoxedValue.NullObject; for (int i = 0; i < m_Args.Count; i++) { m_Args[i].Evaluate(instance, handler, BoxedValue.From(val), args); r = m_Args[i].Value; } if (r.Get <int>() != 0) { results.Add(val); } } v = results; } else if (method == "top") { BoxedValue r = BoxedValue.NullObject; for (int i = 0; i < m_Args.Count; i++) { m_Args[i].Evaluate(instance, handler, iterator, args); r = m_Args[i].Value; } int ct = r.Get <int>(); ObjList results = new ObjList(); IEnumerator enumer = list.GetEnumerator(); while (enumer.MoveNext()) { object val = enumer.Current; if (ct > 0) { results.Add(val); --ct; } } v = results; } } m_Value = BoxedValue.From(v); } else { m_Value = BoxedValue.NullObject; } } for (int i = 0; i < m_Args.Count; i++) { m_Args[i].Evaluate(instance, handler, iterator, args); } }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_Pos.Evaluate(instance, handler, iterator, args); m_Radius.Evaluate(instance, handler, iterator, args); m_Type.Evaluate(instance, handler, iterator, args); m_EventName.Evaluate(instance, handler, iterator, args); if (m_HaveSet) { m_SetVar.Evaluate(instance, handler, iterator, args); m_SetVal.Evaluate(instance, handler, iterator, args); m_ElseSetVal.Evaluate(instance, handler, iterator, args); } }
public void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { }
/// <summary> /// Implements the binary `instanceof` operator. /// </summary> public static bool instanceOf(Environment env, BoxedValue l, BoxedValue r) { if (!r.IsFunction) { return env.RaiseTypeError<bool>("Right operand is not a function"); } if (!l.IsObject) { return false; } return r.Func.HasInstance(l.Object); }
/// <summary> /// Implements the binary `!==` operator. /// </summary> public static bool notSame(BoxedValue l, BoxedValue r) { return !Operators.same(l, r); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { if (m_ParamNum > 1) { m_ObjId.Evaluate(instance, handler, iterator, args); } m_LeaderId.Evaluate(instance, handler, iterator, args); }
/// <summary> /// Implements the binary `>=` operator. /// </summary> public static bool gtEq(BoxedValue l, BoxedValue r) { return Compare(l, r, false, (a, b) => string.CompareOrdinal(a, b) >= 0, (a, b) => a >= b); }
/// <summary> /// Implements the binary `===` operator. /// </summary> public static bool same(BoxedValue l, BoxedValue r) { if (l.IsNumber && r.IsNumber) { return l.Number == r.Number; } if ((l.Tag == TypeTags.String || l.Tag == TypeTags.SuffixString) && (r.Tag == TypeTags.String || r.Tag == TypeTags.SuffixString)) { return l.Clr.ToString() == r.Clr.ToString(); } if (l.Tag == r.Tag) { switch (l.Tag) { case TypeTags.Undefined: return true; case TypeTags.Bool: return l.Bool == r.Bool; case TypeTags.Clr: case TypeTags.Function: case TypeTags.Object: return object.ReferenceEquals(l.Clr, r.Clr); default: return false; } } return false; }
/// <summary> /// Implements the binary `<` operator. /// </summary> public static bool lt(BoxedValue l, BoxedValue r) { return Compare(l, r, false, (a, b) => string.CompareOrdinal(a, b) < 0, (a, b) => a < b); }
/// <summary> /// Supports the binary comparison operators. /// </summary> private static bool Compare(BoxedValue l, BoxedValue r, bool rightToLeft, Func<string, string, bool> stringCompare, Func<double, double, bool> numberCompare) { if ((l.Tag == TypeTags.String || l.Tag == TypeTags.SuffixString) && (r.Tag == TypeTags.String || r.Tag == TypeTags.SuffixString)) { return stringCompare( l.Clr.ToString(), r.Clr.ToString()); } if (l.IsNumber && r.IsNumber) { return numberCompare( l.Number, r.Number); } BoxedValue lPrim, rPrim; if (rightToLeft) { rPrim = TypeConverter.ToPrimitive(r, DefaultValueHint.Number); lPrim = TypeConverter.ToPrimitive(l, DefaultValueHint.Number); } else { lPrim = TypeConverter.ToPrimitive(l, DefaultValueHint.Number); rPrim = TypeConverter.ToPrimitive(r, DefaultValueHint.Number); } if ((lPrim.Tag == TypeTags.String || lPrim.Tag == TypeTags.SuffixString) && (rPrim.Tag == TypeTags.String || rPrim.Tag == TypeTags.SuffixString)) { return stringCompare( lPrim.Clr.ToString(), rPrim.Clr.ToString()); } var lNum = TypeConverter.ToNumber(lPrim); var rNum = TypeConverter.ToNumber(rPrim); return numberCompare( lNum, rNum); }
/// <summary> /// Implements the unary `-` operator. /// </summary> public static BoxedValue minus(BoxedValue o) { return BoxedValue.Box((double)(TypeConverter.ToNumber(o) * -1.0)); }
internal void PostCall(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { PopStack(instance, handler); }
/// <summary> /// Implements the binary `!=` operator. /// </summary> public static bool notEq(BoxedValue l, BoxedValue r) { return !Operators.eq(l, r); }
public void SendConcurrentMessage(string msgId, BoxedValue arg1, BoxedValue arg2, BoxedValue arg3) { var args = NewBoxedValueList(); args.Add(arg1); args.Add(arg2); args.Add(arg3); SendConcurrentMessage(msgId, args); }
/// <summary> /// Implements the unary `+` operator. /// </summary> public static BoxedValue plus(BoxedValue value) { return BoxedValue.Box(TypeConverter.ToNumber(value)); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { //PreCall do all things, so do nothing here. }
/// <summary> /// Implements the unary `typeof` operator. /// </summary> public static string typeOf(BoxedValue value) { if (value.IsNumber) { return "number"; } if (value.IsNull) { return "object"; } return TypeTags.GetName(value.Tag); }
protected override bool ExecCommand(StoryInstance instance, StoryMessageHandler handler, long delta, BoxedValue iterator, BoxedValueList args) { var runtime = handler.PeekRuntime(); if (runtime.CompositeReentry) { return(false); } bool ret = false; var stackInfo = handler.PeekLocalInfo(); for (int i = 0; i < m_ArgNames.Count; ++i) { if (i < stackInfo.Args.Count) { instance.SetVariable(m_ArgNames[i], stackInfo.Args[i].Value); } else { instance.SetVariable(m_ArgNames[i], BoxedValue.NullObject); } } foreach (var pair in stackInfo.OptArgs) { instance.SetVariable(pair.Key, pair.Value.Value); } Prepare(handler); runtime = handler.PeekRuntime(); runtime.Arguments = instance.NewBoxedValueList(); runtime.Arguments.Capacity = stackInfo.Args.Count; for (int i = 0; i < stackInfo.Args.Count; i++) { runtime.Arguments.Add(stackInfo.Args[i].Value); } runtime.Iterator = stackInfo.Args.Count; //没有wait之类命令直接执行 runtime.Tick(instance, handler, delta); instance.RecycleBoxedValueList(runtime.Arguments); if (runtime.CommandQueue.Count == 0) { handler.PopRuntime(instance); } else { //遇到wait命令,跳出执行,之后直接在StoryMessageHandler里执行栈顶的命令队列(降低开销) ret = true; } return(ret); }
public static int bio_fread(Pointer <byte> buf, int el_sz, int n_el, FILE fp, int swap, BoxedValue <uint> chksum) { if (fp.fread(buf, (uint)el_sz, (uint)n_el) != (uint)n_el) { return(-1); } if (swap != 0) { swap_buf(buf, el_sz, n_el); } if (chksum != null) { chksum.Val = chksum_accum(buf, el_sz, n_el, chksum.Val); } return(n_el); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_Cmd.PostCall(instance, handler, iterator, args); }
/// <summary> /// Implements the binary `==` operator. /// </summary> public static bool eq(BoxedValue l, BoxedValue r) { if (Operators.same(l, r)) { return true; } if (l.IsNull && r.IsUndefined || l.IsUndefined && r.IsNull) { return true; } if (l.IsNumber && r.IsString) { return l.Number == TypeConverter.ToNumber(r); } if (l.IsString && r.IsNumber) { return TypeConverter.ToNumber(l) == r.Number; } if (l.Tag == TypeTags.Bool) { var newL = BoxedValue.Box(TypeConverter.ToNumber(l)); return Operators.eq(newL, r); } if (r.Tag == TypeTags.Bool) { var newR = BoxedValue.Box(TypeConverter.ToNumber(r)); return Operators.eq(l, newR); } if (l.Tag >= TypeTags.Object) { if (r.Tag == TypeTags.SuffixString || r.Tag == TypeTags.String || r.IsNumber) { var newL = TypeConverter.ToPrimitive(l.Object, DefaultValueHint.None); return Operators.eq(newL, r); } return false; } if (r.Tag >= TypeTags.Object) { if (l.Tag == TypeTags.SuffixString || l.Tag == TypeTags.String || l.IsNumber) { var newR = TypeConverter.ToPrimitive(r.Object, DefaultValueHint.None); return Operators.eq(l, newR); } return false; } return false; }
public static int bio_fread_1d(BoxedValue <Pointer <byte> > buf, uint el_sz, BoxedValue <uint> n_el, FILE fp, int sw, BoxedValue <uint> ck) { /* Read 1-d array size */ Pointer <byte> array_size = PointerHelpers.Malloc <byte>(4); if (bio_fread(array_size, 4, 1, fp, sw, ck) != 1) { err.E_FATAL("fread(arraysize) failed\n"); } n_el.Val = array_size.ReinterpretCast <uint>().Deref; if (n_el.Val <= 0) { err.E_FATAL(string.Format("Bad arraysize: {0}\n", n_el.Val)); } /* Allocate memory for array data */ buf.Val = ckd_alloc.ckd_calloc <byte>(n_el.Val * el_sz); /* Read array data */ if (bio_fread(buf.Val, (int)el_sz, (int)n_el.Val, fp, sw, ck) != n_el.Val) { err.E_FATAL("fread(arraydata) failed\n"); } return((int)(n_el.Val)); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_UserGuid.Evaluate(instance, handler, iterator, args); m_ItemId.Evaluate(instance, handler, iterator, args); m_ItemNum.Evaluate(instance, handler, iterator, args); }
public static int bio_fread_3d(BoxedValue <Pointer <Pointer <Pointer <float> > > > arr, BoxedValue <uint> d1, BoxedValue <uint> d2, BoxedValue <uint> d3, FILE fp, uint swap, BoxedValue <uint> chksum) { MemoryBlock <byte> length_buf = new MemoryBlock <byte>(12); Pointer <byte> length = new Pointer <byte>(new BasicMemoryBlockAccess <byte>(length_buf), 0); Pointer <uint> l_d1 = new Pointer <uint>(new UpcastingMemoryBlockAccess <uint>(length_buf), 0); Pointer <uint> l_d2 = new Pointer <uint>(new UpcastingMemoryBlockAccess <uint>(length_buf), 4); Pointer <uint> l_d3 = new Pointer <uint>(new UpcastingMemoryBlockAccess <uint>(length_buf), 8); uint n = 0; Pointer <byte> raw = PointerHelpers.NULL <byte>(); uint ret; ret = (uint)bio_fread(length.Point(0), 4, 1, fp, (int)swap, chksum); if (ret != 1) { if (ret == 0) { err.E_ERROR_SYSTEM("Unable to read complete data"); } else { err.E_ERROR_SYSTEM("OS error in bio_fread_3d"); } return(-1); } ret = (uint)bio_fread(length.Point(4), 4, 1, fp, (int)swap, chksum); if (ret != 1) { if (ret == 0) { err.E_ERROR_SYSTEM("Unable to read complete data"); } else { err.E_ERROR_SYSTEM("OS error in bio_fread_3d"); } return(-1); } ret = (uint)bio_fread(length.Point(8), 4, 1, fp, (int)swap, chksum); if (ret != 1) { if (ret == 0) { err.E_ERROR_SYSTEM("Unable to read complete data"); } else { err.E_ERROR_SYSTEM("OS error in bio_fread_3d"); } return(-1); } BoxedValue <Pointer <byte> > boxed_raw = new BoxedValue <Pointer <byte> >(raw); BoxedValue <uint> boxed_n = new BoxedValue <uint>(n); if (bio_fread_1d(boxed_raw, 4, boxed_n, fp, (int)swap, chksum) != n) { return(-1); } n = boxed_n.Val; raw = boxed_raw.Val; SphinxAssert.assert(n == +l_d1 * +l_d2 * +l_d3); // LOGAN changed // Convert byte data to float Pointer <float> float_upcast_buf = raw.ReinterpretCast <float>(); Pointer <float> float_copy_buf = PointerHelpers.Malloc <float>(n); float_upcast_buf.MemCopyTo(float_copy_buf, (int)n); arr.Val = ckd_alloc.ckd_alloc_3d_ptr <float>(+l_d1, +l_d2, +l_d3, float_copy_buf); d1.Val = +l_d1; d2.Val = +l_d2; d3.Val = +l_d3; return((int)n); }
protected override void Evaluate(StoryInstance instance, StoryMessageHandler handler, BoxedValue iterator, BoxedValueList args) { m_Key.Evaluate(instance, handler, iterator, args); m_Value.Evaluate(instance, handler, iterator, args); }
public static int bio_readhdr(FILE fp, BoxedValue <Pointer <Pointer <byte> > > argname, BoxedValue <Pointer <Pointer <byte> > > argval, out int swap) { Pointer <byte> line = PointerHelpers.Malloc <byte>(16384); Pointer <byte> word = PointerHelpers.Malloc <byte>(4096); int i, l; int lineno; argname.Val = ckd_alloc.ckd_calloc <Pointer <byte> >(BIO_HDRARG_MAX + 1); argval.Val = ckd_alloc.ckd_calloc <Pointer <byte> >(BIO_HDRARG_MAX); lineno = 0; if (fp.fgets(line, 16384).IsNull) { err.E_ERROR(string.Format("Premature EOF, line {0}\n", lineno)); goto error_out; } lineno++; if ((line[0] == 's') && (line[1] == '3') && (line[2] == '\n')) { /* New format (post Dec-1996, including checksums); read argument-value pairs */ for (i = 0; ;) { if (fp.fgets(line, 16384).IsNull) { err.E_ERROR(string.Format("Premature EOF, line {0}\n", lineno)); goto error_out; } lineno++; if (stdio.sscanf_s_n(line, word, out l) != 1) { err.E_ERROR(string.Format("Header format error, line {0}\n", lineno)); goto error_out; } if (cstring.strcmp(word, cstring.ToCString("endhdr")) == 0) { break; } if (word[0] == '#') /* Skip comments */ { continue; } if (i >= BIO_HDRARG_MAX) { err.E_ERROR (string.Format("Max arg-value limit({0}) exceeded; increase BIO_HDRARG_MAX\n", BIO_HDRARG_MAX)); goto error_out; } argname.Val[i] = ckd_alloc.ckd_salloc(word); if (stdio.sscanf_s(line + l, word) != 1) { /* Multi-word values not allowed */ err.E_ERROR(string.Format("Header format error, line {0}\n", lineno)); goto error_out; } argval.Val[i] = ckd_alloc.ckd_salloc(word); i++; } } else { /* Old format (without checksums); the first entry must be the version# */ if (stdio.sscanf_s(line, word) != 1) { err.E_ERROR(string.Format("Header format error, line {0}\n", lineno)); goto error_out; } argname.Val[0] = ckd_alloc.ckd_salloc(cstring.ToCString("version")); argval.Val[0] = ckd_alloc.ckd_salloc(word); i = 1; bcomment_read(fp); } argname.Val[i] = PointerHelpers.NULL <byte>(); if ((swap = swap_check(fp)) < 0) { err.E_ERROR("swap_check failed\n"); goto error_out; } return(0); error_out: bio_hdrarg_free(argname.Val, argval.Val); argname.Val = argval.Val = PointerHelpers.NULL <Pointer <byte> >(); swap = 0; return(-1); }