/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual bool Callback(string name, int flags, Variant value)
{
if ((flags & Interface.HIDDENMEMBER) != 0)
{
return(true);
}
if (mCalled)
{
mStream.Write(",\n");
}
mCalled = true;
mStream.Write(mIndentStr);
mStream.Write("\"");
mStream.Write(LexBase.EscapeC(name));
mStream.Write("\" => ");
if (value.IsObject())
{
// object
VariantClosure clo = value.AsObjectClosure();
ArrayNI.SaveStructuredDataForObject(clo.SelectObject(), mStack, mStream, mIndentStr
);
}
else
{
mStream.Write(Utils.VariantToExpressionString(value));
}
return(true);
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void GetPropertyDirect(Variant result, Variant target,
int member, Dispatch2 objthis, int flags)
{
if (target.IsObject())
{
VariantClosure clo = target.AsObjectClosure();
string name = Sharpen.Extensions.ToString(member);
int hr = clo.PropGet(flags, name, result, clo.mObjThis != null ? clo.mObjThis : objthis
);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, name);
}
}
else
{
if (target.IsString())
{
GetStringProperty(result, target, member);
}
else
{
if (target.IsOctet())
{
GetOctetProperty(result, target, member);
}
else
{
string mes = Error.VariantConvertErrorToObject.Replace("%1", Utils.VariantToReadableString
(target));
throw new VariantException(mes);
}
}
}
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
((ArrayObject)objthis).Clear(ni);
AList <Dispatch2> stack = new AList <Dispatch2>();
VariantClosure clo = param[0].AsObjectClosure();
if (clo.mObjThis != null)
{
ni.AssignStructure(clo.mObjThis, stack);
}
else
{
if (clo.mObject != null)
{
ni.AssignStructure(clo.mObject, stack);
}
else
{
throw new TjsException(Error.NullAccess);
}
}
return(Error.S_OK);
}
// setPropertyDirect( ra[ra_offset+ca[code+1]], da[ca[code+2]], ra[ra_offset+ca[code+3]], objthis, flags );
// member は、固定值なので、事前に分岐判定出来るから、展开するようにした方がいいな
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void SetPropertyDirect(Variant target, string member, Variant
param, Dispatch2 objthis, int flags)
{
if (target.IsObject())
{
VariantClosure clo = target.AsObjectClosure();
int hr = clo.PropSet(flags, member, param, clo.mObjThis != null ? clo.mObjThis :
objthis);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, member);
}
}
else
{
if (target.IsString())
{
SetStringProperty(param, target, member);
}
else
{
if (target.IsOctet())
{
SetOctetProperty(param, target, member);
}
else
{
string mes = Error.VariantConvertErrorToObject.Replace("%1", Utils.VariantToReadableString
(target));
throw new VariantException(mes);
}
}
}
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual void SaveStructuredData(AList <Dispatch2> stack, TextWriteStreamInterface
stream, string indentstr)
{
stream.Write("(const) [\n");
string indentstr2 = indentstr + " ";
int count = mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = mItems[i];
stream.Write(indentstr2);
if (v.IsObject())
{
// object
VariantClosure clo = v.AsObjectClosure();
SaveStructuredDataForObject(clo.SelectObject(), stack, stream, indentstr2);
}
else
{
stream.Write(Utils.VariantToExpressionString(v));
}
if (i != mItems.Count - 1)
{
// unless last
stream.Write(",\n");
}
else
{
stream.Write("\n");
}
}
stream.Write(indentstr);
stream.Write("]");
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void ThrowScriptException(Variant val, ScriptBlock block
, int srcpos)
{
string msg = null;
if (val.IsObject())
{
VariantClosure clo = val.AsObjectClosure();
if (clo.mObject != null)
{
Variant v2 = new Variant();
string message_name = "message";
int hr = clo.PropGet(0, message_name, v2, null);
if (hr >= 0)
{
msg = "script exception : " + v2.AsString();
}
}
}
if (msg == null || msg.Length == 0)
{
msg = "script exception";
}
throw new TjsScriptException(msg, block, srcpos, val);
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void OperatePropertyDirect(VariantClosure clo, string name
, Variant result, Variant param, Dispatch2 objthis, int ope)
{
Dispatch2 objThis = clo.mObjThis != null ? clo.mObjThis : objthis;
int hr = clo.Operation(ope, name, result, param, objThis);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, name);
}
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void TypeOfMemberDirect(Variant result, Variant target,
string member, Dispatch2 objthis, int flags)
{
if (target.IsObject())
{
int hr;
VariantClosure clo = target.AsObjectClosure();
hr = clo.PropGet(flags, member, result, clo.mObjThis != null ? clo.mObjThis : objthis
);
if (hr == Error.S_OK)
{
TypeOf(result);
}
else
{
if (hr == Error.E_MEMBERNOTFOUND)
{
result.Set("undefined");
}
else
{
if (hr < 0)
{
ThrowFrom_tjs_error(hr, member);
}
}
}
}
else
{
if (target.IsString())
{
GetStringProperty(result, target, member);
TypeOf(result);
}
else
{
if (target.IsOctet())
{
GetOctetProperty(result, target, member);
TypeOf(result);
}
else
{
string mes = Error.VariantConvertErrorToObject.Replace("%1", Utils.VariantToReadableString
(target));
throw new VariantException(mes);
}
}
}
}
// getPropertyIndirect( ra[ra_offset+ca[code+1]], ra[ra_offset+ca[code+2]], ra[ra_offset+ca[code+3]], objthis, flags );
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void GetPropertyIndirect(Variant result, Variant target
, Variant member, Dispatch2 objthis, int flags)
{
if (target.IsObject())
{
VariantClosure clo = target.AsObjectClosure();
if (member.IsInteger() != true)
{
string str = member.AsString();
int hr = clo.PropGet(flags, str, result, clo.mObjThis != null ? clo.mObjThis : objthis
);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, str);
}
}
else
{
int hr = clo.PropGetByNum(flags, member.AsInteger(), result, clo.mObjThis != null
? clo.mObjThis : objthis);
if (hr < 0)
{
ThrowFrom_tjs_error_num(hr, member.AsInteger());
}
}
}
else
{
if (target.IsString())
{
GetStringProperty(result, target, member);
}
else
{
if (target.IsOctet())
{
GetOctetProperty(result, target, member);
}
else
{
string mes = Error.VariantConvertErrorToObject.Replace("%1", Utils.VariantToReadableString
(target));
throw new VariantException(mes);
}
}
}
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
DictionaryNI ni = (DictionaryNI)objthis.GetNativeInstance(DictionaryClass
.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (!ni.IsValid())
{
return(Error.E_INVALIDOBJECT);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
bool clear = true;
if (param.Length >= 2 && param[1].IsVoid() != true)
{
clear = param[1].AsBoolean();
}
VariantClosure clo = param[0].AsObjectClosure();
if (clo.mObjThis != null)
{
ni.Assign(clo.mObjThis, clear);
}
else
{
if (clo.mObject != null)
{
ni.Assign(clo.mObject, clear);
}
else
{
throw new TjsException(Error.NullAccess);
}
}
return(Error.S_OK);
}
/// <summary>TJSGetExceptionObject : retrieves TJS 'Exception' object</summary>
/// <exception cref="TjsException">TJSException</exception>
/// <exception cref="VariantException">VariantException</exception>
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public static void GetExceptionObject(Tjs tjs, Variant res, Variant msg, Variant
trace)
{
if (res == null)
{
return;
}
// not prcess
// retrieve class "Exception" from global
Dispatch2 global = tjs.GetGlobal();
Variant val = new Variant();
int hr = global.PropGet(0, EXCEPTION_NAME, val, global);
if (hr < 0)
{
throw new TjsException(ExceptionNotFound);
}
// create an Exception object
Holder <Dispatch2> excpobj = new Holder <Dispatch2>(null);
VariantClosure clo = val.AsObjectClosure();
Variant[] pmsg = new Variant[1];
pmsg[0] = msg;
hr = clo.CreateNew(0, null, excpobj, pmsg, clo.mObjThis);
if (hr < 0)
{
throw new TjsException(ExceptionNotFound);
}
Dispatch2 disp = excpobj.mValue;
if (trace != null)
{
string trace_name = "trace";
disp.PropSet(Interface.MEMBERENSURE, trace_name, trace, disp);
}
res.Set(disp, disp);
excpobj = null;
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
protected internal static void OperatePropertyIndirect0(VariantClosure clo, Variant
name, Variant result, Dispatch2 objthis, int ope)
{
if (name.IsInteger() != true)
{
string str = name.AsString();
int hr = clo.Operation(ope, str, result, null, clo.mObjThis != null ? clo.mObjThis
: objthis);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, str);
}
}
else
{
int hr = clo.OperationByNum(ope, name.AsInteger(), result, null, clo.mObjThis !=
null ? clo.mObjThis : objthis);
if (hr < 0)
{
ThrowFrom_tjs_error_num(hr, name.AsInteger());
}
}
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
RegExpNI _this = (RegExpNI)objthis.GetNativeInstance(RegExpClass.mClassID
);
if (_this == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 2)
{
return(Error.E_BADPARAMCOUNT);
}
string target = param[0].AsString();
string to = null;
bool func;
VariantClosure funcval = null;
if (param[1].IsObject() != true)
{
to = param[1].AsString();
func = false;
}
else
{
funcval = param[1].AsObjectClosure();
if (funcval.mObjThis == null)
{
funcval.mObjThis = objthis;
}
func = true;
}
string ret = null;
Matcher m = _this.RegEx.Matcher(target);
if (func == false)
{
ret = m.ReplaceAll(to);
}
else
{
int hr;
VariantClosure clo = new VariantClosure(null, null);
Variant funcret = new Variant();
Variant arrayval = new Variant(clo);
Variant[] args = new Variant[1];
args[0] = arrayval;
int size = target.Length;
ret = string.Empty;
for (int i = 0; i < size;)
{
if (m.Find(i))
{
ret += Sharpen.Runtime.Substring(target, i, m.Start());
Dispatch2 array = RegExpClass.GetResultArray(true, _this, m);
clo.Set(array, array);
hr = funcval.FuncCall(0, null, funcret, args, null);
if (hr >= 0)
{
ret += funcret.AsString();
}
i = m.End();
}
else
{
break;
}
}
}
if (result != null)
{
result.Set(ret);
}
return(Error.S_OK);
}
// enumerate members
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual int EnumMembers(int flag, VariantClosure callback, Dispatch2 objThis
)
{
return(Error.E_NOTIMPL);
}
public ArraySortCompare_Functional(VariantClosure clo)
{
mClosure = clo;
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 2)
{
return(Error.E_BADPARAMCOUNT);
}
ni.mItems.Clear();
string @string = param[1].AsString();
bool purgeempty = false;
if (param.Length >= 4 && param[3].IsVoid() == false)
{
purgeempty = param[3].AsBoolean();
}
if (param[0].IsObject())
{
RegExpNI re;
VariantClosure clo = param[0].AsObjectClosure();
if (clo.mObject != null)
{
if ((re = (RegExpNI)clo.mObject.GetNativeInstance(RegExpClass.ClassID)) != null)
{
Holder <Dispatch2> array = new Holder <Dispatch2>(objthis);
re.Split(array, @string, purgeempty);
if (result != null)
{
result.Set(new Variant(objthis, objthis));
}
return(Error.S_OK);
}
}
}
string pattern = param[0].AsString();
int count = @string.Length;
int start = 0;
for (int i = 0; i < count; i++)
{
char ch = @string[i];
if (pattern.IndexOf(ch) != -1)
{
if (purgeempty == false || (purgeempty == true && (i - start) != 0))
{
ni.mItems.AddItem(new Variant(Sharpen.Runtime.Substring(@string, start, i)));
}
start = i + 1;
}
}
if (purgeempty == false || (purgeempty == true && (count - start) >= 0))
{
ni.mItems.AddItem(new Variant(Sharpen.Runtime.Substring(@string, start, count)));
}
if (result != null)
{
result.Set(new Variant(objthis, objthis));
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
int method = '+';
VariantClosure closure = null;
if (param.Length >= 1 && param[0].IsVoid() != true)
{
if (param[0].IsObject())
{
closure = param[0].AsObjectClosure();
method = (char)0;
}
else
{
string me = param[0].AsString();
method = me[0];
switch (method)
{
case '+':
case '-':
case '0':
case '9':
case 'a':
case 'z':
{
break;
}
default:
{
method = '+';
break;
}
}
}
}
switch (method)
{
case '+':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NormalAscending());
break;
}
case '-':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NormalDescending());
break;
}
case '0':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NumericAscending());
break;
}
case '9':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NumericDescending());
break;
}
case 'a':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_StringAscending());
break;
}
case 'z':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_StringDescending());
break;
}
case 0:
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_Functional(closure));
break;
}
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
public virtual void Randomize(Variant[] param)
{
if (param.Length == 0)
{
// parametor not given
if (mRandomBits128 != null)
{
// another random generator is given
//tjs_uint8 buf[32];
//unsigned long tmp[32];
ByteBuffer buf = ByteBuffer.AllocateDirect(32);
mRandomBits128.GetRandomBits128(buf, 0);
mRandomBits128.GetRandomBits128(buf, 16);
int[] tmp = new int[32];
for (int i = 0; i < 32; i++)
{
long num = (long)buf.Get(i) + ((long)buf.Get(i) << 8) + ((long)buf.Get(1) << 16)
+ ((long)buf.Get(i) << 24);
tmp[i] = (int)(num > int.MaxValue ? num - unchecked ((long)(0x100000000L)) : num);
}
if (mGenerator != null)
{
mGenerator = null;
}
mGenerator = new MersenneTwister(tmp);
}
else
{
if (mGenerator != null)
{
mGenerator = null;
}
mGenerator = new MersenneTwister(Runtime.CurrentTimeMillis());
}
}
else
{
if (param.Length >= 1)
{
if (param[0].IsObject())
{
MersenneTwisterData data = null;
try
{
// may be a reconstructible information
VariantClosure clo = param[0].AsObjectClosure();
if (clo.mObject == null)
{
throw new TjsException(Error.NullAccess);
}
string state;
Variant val = new Variant();
data = new MersenneTwisterData();
// get state array
//TJSThrowFrom_tjs_error
int hr = clo.PropGet(Interface.MEMBERMUSTEXIST, "state", val, null);
if (hr < 0)
{
Error.ThrowFrom_tjs_error(hr, null);
}
state = val.AsString();
if (state.Length != MT_N * 8)
{
throw new TjsException(Error.NotReconstructiveRandomizeData);
}
int p = 0;
for (int i = 0; i < MT_N; i++)
{
long n = 0;
int tmp;
for (int j = 0; j < 8; j++)
{
int c = state[p + j];
tmp = -1;
if (c >= '0' && c <= '9')
{
n = c - '0';
}
else
{
if (c >= 'a' && c <= 'f')
{
n = c - 'a' + 10;
}
else
{
if (c >= 'A' && c <= 'F')
{
n = c - 'A' + 10;
}
}
}
if (tmp == -1)
{
throw new TjsException(Error.NotReconstructiveRandomizeData);
}
else
{
n <<= 4;
n += tmp;
}
}
p += 8;
data.state.Put(i, n & unchecked ((long)(0xffffffffL)));
}
// get other members
hr = clo.PropGet(Interface.MEMBERMUSTEXIST, "left", val, null);
if (hr < 0)
{
Error.ThrowFrom_tjs_error(hr, null);
}
data.left = val.AsInteger();
hr = clo.PropGet(Interface.MEMBERMUSTEXIST, "next", val, null);
data.next = val.AsInteger();
if (mGenerator != null)
{
mGenerator = null;
}
mGenerator = new MersenneTwister(data);
}
catch (VariantException)
{
data = null;
throw new TjsException(Error.NotReconstructiveRandomizeData);
}
catch (TjsException)
{
data = null;
throw new TjsException(Error.NotReconstructiveRandomizeData);
}
data = null;
}
else
{
// 64bitじゃなくて、32bit にしてしまっている。实用上问题あれば修正。
int n = param[0].AsInteger();
int[] tmp = new int[1];
tmp[0] = n;
if (mGenerator != null)
{
mGenerator = null;
}
mGenerator = new MersenneTwister(tmp);
}
}
}
}
