private string GetText()
{
Variant value = Variant.Create();
TextView_c.GetValue(Pointer, value.Pointer);
return(value.AsString());
}
/// <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);
}
public void TestString()
{
String s = "hello";
Variant v = new Variant(s);
Assert.AreEqual(s, v.AsString());
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
private static void GetStringProperty(Variant result, Variant str, string name)
{
// processes properties toward strings.
if (name == null)
{
ThrowFrom_tjs_error(Error.E_MEMBERNOTFOUND, string.Empty);
}
if (name.Equals("length"))
{
// get string length
string s = str.AsString();
if (s == null)
{
result.Set(0);
}
else
{
// tTJSVariantString::GetLength can return zero if 'this' is NULL
result.Set(s.Length);
}
return;
}
else
{
if (name[0] >= '0' && name[0] <= '9')
{
string s = str.AsString();
int n = int.Parse(name);
int len = s.Length;
if (n == len)
{
result.Set(string.Empty);
return;
}
if (n < 0 || n > len)
{
throw new TjsException(Error.RangeError);
}
result.Set(Sharpen.Runtime.Substring(s, n, n + 1));
return;
}
}
ThrowFrom_tjs_error(Error.E_MEMBERNOTFOUND, name);
}
/// <exception cref="VariantException"></exception>
public static string VariantToExpressionString(Variant val)
{
// convert given variant to string which can be interpret as an expression.
// this function does not convert objects ( returns empty string )
if (val.IsVoid())
{
return("void");
}
else
{
if (val.IsInteger())
{
return(val.AsString());
}
else
{
if (val.IsReal())
{
string s = Variant.RealToHexString(val.AsDouble());
return(s + " /* " + val.AsString() + " */");
}
else
{
if (val.IsString())
{
string s = LexBase.EscapeC(val.AsString());
return("\"" + s + "\"");
}
else
{
if (val.IsOctet())
{
string s = Variant.OctetToListString(val.AsOctet());
return("<%" + s + "%>");
}
else
{
return(string.Empty);
}
}
}
}
}
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public static void SaveStructuredDataForObject(Dispatch2 dsp, AList <Dispatch2> stack
, TextWriteStreamInterface stream, string indentstr)
{
// check object recursion
int count = stack.Count;
for (int i = 0; i < count; i++)
{
Dispatch2 d = stack[i];
if (d == dsp)
{
// object recursion detected
stream.Write("null /* object recursion detected */");
return;
}
}
// determin dsp's object type
DictionaryNI dicni;
ArrayNI arrayni;
if (dsp != null)
{
dicni = (DictionaryNI)dsp.GetNativeInstance(DictionaryClass.ClassID);
if (dicni != null)
{
// dictionary
stack.AddItem(dsp);
dicni.SaveStructuredData(stack, stream, indentstr);
stack.Remove(stack.Count - 1);
return;
}
else
{
arrayni = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID);
if (arrayni != null)
{
// array
stack.AddItem(dsp);
arrayni.SaveStructuredData(stack, stream, indentstr);
stack.Remove(stack.Count - 1);
return;
}
else
{
// other objects
stream.Write("null /* (object) \"");
// stored as a null
Variant val = new Variant(dsp, dsp);
stream.Write(LexBase.EscapeC(val.AsString()));
stream.Write("\" */");
return;
}
}
}
stream.Write("null");
}
/// <exception cref="VariantException"></exception>
public static void CharacterCodeOf(Variant val)
{
string str = val.AsString();
if (str != null)
{
int v = str[0];
val.Set(v);
}
else
{
val.Set(0);
}
}
// 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="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);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
string delimiter = param[0].AsString();
bool purgeempty = false;
if (param.Length >= 3 && param[2].IsVoid() != true)
{
purgeempty = param[2].AsBoolean();
}
bool first = true;
StringBuilder builer = new StringBuilder(1024);
int count = ni.mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = ni.mItems[i];
if (purgeempty && v.IsVoid())
{
}
else
{
if (!first)
{
builer.Append(delimiter);
}
first = false;
builer.Append(v.AsString());
}
}
if (result != null)
{
result.Set(builer.ToString());
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
protected internal static void InstanceOf(Variant name, Variant targ)
{
// checks instance inheritance.
string str = name.AsString();
if (str != null)
{
int hr = CustomObject.DefaultIsInstanceOf(0, targ, str, null);
if (hr < 0)
{
ThrowFrom_tjs_error(hr, null);
}
targ.Set((hr == Error.S_TRUE) ? 1 : 0);
return;
}
targ.Set(0);
}
/// <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);
}
string name = param[0].AsString();
string mode = null;
if (param.Length >= 2 && param[1].IsVoid() == false)
{
mode = param[1].AsString();
}
TextWriteStreamInterface stream = Tjs.mStorage.CreateTextWriteStream(name, mode);
try
{
Iterator <Variant> i = ni.mItems.Iterator();
while (i.HasNext())
{
Variant o = i.Next();
if (o != null && (o.IsString() || o.IsNumber()))
{
stream.Write(o.AsString());
}
stream.Write("\n");
}
}
finally
{
stream.Destruct();
}
if (result != null)
{
result.Set(new Variant(objthis, objthis));
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
/// <exception cref="VariantException"></exception>
private static void GetStringProperty(Variant result, Variant str, int n)
{
// processes properties toward strings.
string s = str.AsString();
int len = s.Length;
if (n == len)
{
result.Set(string.Empty);
return;
}
if (n < 0 || n > len)
{
throw new TjsException(Error.RangeError);
}
result.Set(Sharpen.Runtime.Substring(s, n, n + 1));
return;
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual void Assign(Dispatch2 dsp, bool clear)
{
// copy members from "dsp" to "Owner"
// determin dsp's object type
ArrayNI arrayni = null;
CustomObject owner = mOwner.Get();
if (dsp != null && (arrayni = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID))
!= null)
{
// convert from array
if (clear)
{
owner.Clear();
}
int count = arrayni.mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = arrayni.mItems[i];
string name = v.AsString();
i++;
if (i >= count)
{
break;
}
Variant v2 = arrayni.mItems[i];
owner.PropSet(Interface.MEMBERENSURE | Interface.IGNOREPROP, name, v2, owner);
}
}
else
{
// otherwise
if (clear)
{
owner.Clear();
}
DictionaryNI.AssignCallback callback = new DictionaryNI.AssignCallback(owner);
dsp.EnumMembers(Interface.IGNOREPROP, callback, dsp);
}
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
/// <exception cref="CompileException"></exception>
protected internal virtual void Eval(Variant val, Dispatch2 objthis, bool resneed
)
{
Variant res = new Variant();
string str = val.AsString();
if (str.Length > 0)
{
if (resneed)
{
GetOwner().EvalExpression(str, res, objthis, null, 0);
}
else
{
GetOwner().EvalExpression(str, null, objthis, null, 0);
}
}
if (resneed)
{
val.Set(res);
}
}
/// <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="VariantException"></exception>
public static object[] VariantArrayToJavaObjectArray(Variant[] @params, Type[] types)
{
if (types.Length == 0)
{
return(null);
}
// 元々引数不要
if (@params.Length < types.Length)
{
return(null);
}
// パラメータが少ない
int count = types.Length;
object[] ret = new object[count];
for (int i = 0; i < count; i++)
{
Type type = types[i];
Variant param = @params[i];
if (type.GetTypeInfo().IsPrimitive)
{
// プリミティブタイプの场合
if (type == typeof(int))
{
ret[i] = Extensions.ValueOf(param.AsInteger());
}
else if (type == typeof(double))
{
ret[i] = (param.AsDouble());
}
else if (type == typeof(bool))
{
ret[i] = Extensions.ValueOf(param.AsInteger() != 0);
}
else if (type == typeof(float))
{
ret[i] = ((float)param.AsDouble());
}
else if (type == typeof(long))
{
ret[i] = Extensions.ValueOf(param.AsInteger());
}
else if (type == typeof(char))
{
ret[i] = ((char)param.AsInteger());
}
else if (type == typeof(byte))
{
ret[i] = (unchecked ((byte)param.AsInteger()));
}
else if (type == typeof(short))
{
ret[i] = ((short)param.AsInteger());
}
else
{
// may be Void.TYPE
ret[i] = null;
}
}
else if (type == typeof(string))
{
ret[i] = param.AsString();
}
else if (type == typeof(ByteBuffer))
{
ret[i] = param.AsOctet();
}
else if (type == typeof(Variant))
{
ret[i] = param;
}
else if (type == typeof(VariantClosure))
{
ret[i] = param.AsObjectClosure();
}
else if (type == typeof(Dispatch2))
{
ret[i] = param.AsObject();
}
else if (type == param.ToJavaObject().GetType())
{
ret[i] = param.ToJavaObject();
}
else
{
// その他 のクラス
ret[i] = null;
}
}
return(ret);
}
private void WriteVariant(Variant value)
{
switch (value.Kind)
{
case VariantKind.Null:
_writer.Write((byte)EncodingKind.Null);
break;
case VariantKind.Boolean:
_writer.Write((byte)(value.AsBoolean() ? EncodingKind.Boolean_True : EncodingKind.Boolean_False));
break;
case VariantKind.Byte:
_writer.Write((byte)EncodingKind.UInt8);
_writer.Write(value.AsByte());
break;
case VariantKind.SByte:
_writer.Write((byte)EncodingKind.Int8);
_writer.Write(value.AsSByte());
break;
case VariantKind.Int16:
_writer.Write((byte)EncodingKind.Int16);
_writer.Write(value.AsInt16());
break;
case VariantKind.UInt16:
_writer.Write((byte)EncodingKind.UInt16);
_writer.Write(value.AsUInt16());
break;
case VariantKind.Int32:
{
var v = value.AsInt32();
if (v >= 0 && v <= 10)
{
_writer.Write((byte)((int)EncodingKind.Int32_0 + v));
}
else if (v >= 0 && v < byte.MaxValue)
{
_writer.Write((byte)EncodingKind.Int32_1Byte);
_writer.Write((byte)v);
}
else if (v >= 0 && v < ushort.MaxValue)
{
_writer.Write((byte)EncodingKind.Int32_2Bytes);
_writer.Write((ushort)v);
}
else
{
_writer.Write((byte)EncodingKind.Int32);
_writer.Write(v);
}
}
break;
case VariantKind.UInt32:
{
var v = value.AsUInt32();
if (v >= 0 && v <= 10)
{
_writer.Write((byte)((int)EncodingKind.UInt32_0 + v));
}
else if (v >= 0 && v < byte.MaxValue)
{
_writer.Write((byte)EncodingKind.UInt32_1Byte);
_writer.Write((byte)v);
}
else if (v >= 0 && v < ushort.MaxValue)
{
_writer.Write((byte)EncodingKind.UInt32_2Bytes);
_writer.Write((ushort)v);
}
else
{
_writer.Write((byte)EncodingKind.UInt32);
_writer.Write(v);
}
}
break;
case VariantKind.Int64:
_writer.Write((byte)EncodingKind.Int64);
_writer.Write(value.AsInt64());
break;
case VariantKind.UInt64:
_writer.Write((byte)EncodingKind.UInt64);
_writer.Write(value.AsUInt64());
break;
case VariantKind.Decimal:
_writer.Write((byte)EncodingKind.Decimal);
_writer.Write(value.AsDecimal());
break;
case VariantKind.Float4:
_writer.Write((byte)EncodingKind.Float4);
_writer.Write(value.AsSingle());
break;
case VariantKind.Float8:
_writer.Write((byte)EncodingKind.Float8);
_writer.Write(value.AsDouble());
break;
case VariantKind.Char:
_writer.Write((byte)EncodingKind.Char);
_writer.Write((ushort)value.AsChar()); // written as ushort because BinaryWriter fails on chars that are unicode surrogates
break;
case VariantKind.String:
WriteStringValue(value.AsString());
break;
case VariantKind.BoxedEnum:
var e = value.AsBoxedEnum();
WriteBoxedEnum(e, e.GetType());
break;
case VariantKind.DateTime:
_writer.Write((byte)EncodingKind.DateTime);
_writer.Write(value.AsDateTime().ToBinary());
break;
case VariantKind.Type:
WriteType(value.AsType());
break;
case VariantKind.Array:
WriteArray(value.AsArray());
break;
case VariantKind.Object:
WriteObject(value.AsObject());
break;
}
}
/// <exception cref="VariantException"></exception>
public static string VariantToReadableString(Variant val, int maxlen)
{
string ret = null;
if (val == null || val.IsVoid())
{
ret = "(void)";
}
else
{
if (val.IsInteger())
{
ret = "(int)" + val.AsString();
}
else
{
if (val.IsReal())
{
ret = "(real)" + val.AsString();
}
else
{
if (val.IsString())
{
ret = "(string)\"" + LexBase.EscapeC(val.AsString()) + "\"";
}
else
{
if (val.IsOctet())
{
ret = "(octet)<% " + Variant.OctetToListString(val.AsOctet()) + " %>";
}
else
{
if (val.IsObject())
{
VariantClosure c = (VariantClosure)val.AsObjectClosure();
StringBuilder str = new StringBuilder(128);
str.Append("(object)");
str.Append('(');
if (c.mObject != null)
{
str.Append('[');
if (c.mObject is NativeClass)
{
str.Append(((NativeClass)c.mObject).GetClassName());
}
else
{
if (c.mObject is InterCodeObject)
{
str.Append(((InterCodeObject)c.mObject).GetName());
}
else
{
if (c.mObject is CustomObject)
{
string name = ((CustomObject)c.mObject).GetClassNames();
if (name != null)
{
str.Append(name);
}
else
{
str.Append(c.mObject.GetType().FullName);
}
}
else
{
str.Append(c.mObject.GetType().FullName);
}
}
}
str.Append(']');
}
else
{
str.Append("0x00000000");
}
if (c.mObjThis != null)
{
str.Append('[');
if (c.mObjThis is NativeClass)
{
str.Append(((NativeClass)c.mObjThis).GetClassName());
}
else
{
if (c.mObjThis is InterCodeObject)
{
str.Append(((InterCodeObject)c.mObjThis).GetName());
}
else
{
if (c.mObjThis is CustomObject)
{
string name = ((CustomObject)c.mObjThis).GetClassNames();
if (name != null)
{
str.Append(name);
}
else
{
str.Append(c.mObjThis.GetType().FullName);
}
}
else
{
str.Append(c.mObjThis.GetType().FullName);
}
}
}
str.Append(']');
}
else
{
str.Append(":0x00000000");
}
str.Append(')');
ret = str.ToString();
}
else
{
// native object ?
ret = "(octet) [" + val.GetType().FullName + "]";
}
}
}
}
}
}
if (ret != null)
{
if (ret.Length > maxlen)
{
return(Sharpen.Runtime.Substring(ret, 0, maxlen));
}
else
{
return(ret);
}
}
return(string.Empty);
}
/// <exception cref="VariantException"></exception>
public static object VariantToJavaObject(Variant param, Type type)
{
if (type.GetTypeInfo().IsPrimitive)
{
// プリミティブタイプの场合
if (type == typeof(int))
{
return(Extensions.ValueOf(param.AsInteger()));
}
if (type == typeof(double))
{
return(param.AsDouble());
}
if (type == typeof(bool))
{
return(Extensions.ValueOf(param.AsInteger() != 0));
}
if (type == typeof(float))
{
return((float)param.AsDouble());
}
if (type == typeof(long))
{
return(Extensions.ValueOf(param.AsInteger()));
}
if (type == typeof(char))
{
return((char)param.AsInteger());
}
if (type == typeof(byte))
{
return(unchecked ((byte)param.AsInteger()));
}
if (type == typeof(short))
{
return((short)param.AsInteger());
}
// may be Void.TYPE
return(null);
}
if (type == typeof(string))
{
return(param.AsString());
}
if (type == typeof(ByteBuffer))
{
return(param.AsOctet());
}
if (type == typeof(Variant))
{
return(param);
}
if (type == typeof(VariantClosure))
{
return(param.AsObjectClosure());
}
if (type == typeof(Dispatch2))
{
return(param.AsObject());
}
if (type == param.ToJavaObject().GetType())
{
return(param.ToJavaObject());
}
// その他 のクラス
return(null);
}
/// <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);
}
/// <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);
}
}
}
}
