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);
}
