/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
Variant val = new Variant(string.Empty);
if ((param.Length > 0) ? param[0].IsVoid() != true : false)
{
val.CopyRef(param[0]);
}
string message_name = "message";
objthis.PropSet(Interface.MEMBERENSURE, message_name, val, objthis);
if ((param.Length > 1) ? param[1].IsVoid() != true : false)
{
val.CopyRef(param[1]);
}
else
{
val.Set(string.Empty);
}
string trace_name = "trace";
objthis.PropSet(Interface.MEMBERENSURE, trace_name, val, objthis);
return Error.S_OK;
}
// operation with member
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
public virtual int Operation(int flag, string memberName, Variant result, Variant
param, Dispatch2 objThis)
{
int op = flag & OP_MASK;
if (op != OP_INC && op != OP_DEC && param == null)
{
return Error.E_INVALIDPARAM;
}
if (op < OP_MIN || op > OP_MAX)
{
return Error.E_INVALIDPARAM;
}
Variant tmp = new Variant();
int hr = PropGet(0, memberName, tmp, objThis);
if (hr < 0)
{
return hr;
}
// #define TJS_FAILED(x) ((x)<0)
DoVariantOperation(op, tmp, param);
hr = PropSet(0, memberName, tmp, objThis);
if (hr < 0)
{
return hr;
}
if (result != null)
{
result.CopyRef(tmp);
}
return Error.S_OK;
}
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
public override int Operation(int flag, string membername, Variant result, Variant
param, Dispatch2 objthis)
{
if (!GetValidity())
{
return Error.E_INVALIDOBJECT;
}
// operation about the member
// processing line is the same as above function
if (membername == null)
{
return Error.E_INVALIDTYPE;
}
int op = flag & OP_MASK;
if (op != OP_INC && op != OP_DEC && param == null)
{
return Error.E_INVALIDPARAM;
}
if (op < OP_MIN || op > OP_MAX)
{
return Error.E_INVALIDPARAM;
}
SymbolData data = Find(membername);
if (data == null)
{
if (mCallMissing)
{
// call default operation
return base.Operation(flag, membername, result, param, objthis);
}
}
if (data == null)
{
return Error.E_MEMBERNOTFOUND;
}
// not found
if (data.mValue.IsObject())
{
int hr;
VariantClosure tvclosure;
tvclosure = data.mValue.AsObjectClosure();
if (tvclosure.mObject != null)
{
Dispatch2 ot = tvclosure.mObjThis != null ? tvclosure.mObjThis : objthis;
Variant tmp = new Variant();
hr = tvclosure.mObject.PropGet(0, null, tmp, ot);
if (hr >= 0)
{
DoVariantOperation(op, tmp, param);
hr = tvclosure.mObject.PropSet(0, null, tmp, ot);
if (hr < 0)
{
return hr;
}
if (result != null)
{
result.CopyRef(tmp);
}
return Error.S_OK;
}
else
{
if (hr != Error.E_NOTIMPL && hr != Error.E_INVALIDTYPE && hr != Error.E_INVALIDOBJECT)
{
return hr;
}
}
}
}
//checkObjectClosureRemove( data.mValue );
Variant tmp_1 = data.mValue;
try
{
DoVariantOperation(op, tmp_1, param);
}
finally
{
}
//checkObjectClosureAdd( data.mValue );
if (result != null)
{
result.CopyRef(tmp_1);
}
return Error.S_OK;
}
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
private static bool EnumCallback(int flags, EnumMembersCallback callback, Variant
value, Dispatch2 objthis, SymbolData data)
{
int newflags = 0;
if ((data.mSymFlags & SYMBOL_HIDDEN) != 0)
{
newflags |= Interface.HIDDENMEMBER;
}
if ((data.mSymFlags & SYMBOL_STATIC) != 0)
{
newflags |= Interface.STATICMEMBER;
}
value.Clear();
if ((flags & Interface.ENUM_NO_VALUE) == 0)
{
bool getvalues = false;
if ((flags & Interface.IGNOREPROP) == 0)
{
Variant targ = data.mValue;
if (targ.IsObject())
{
VariantClosure tvclosure = targ.AsObjectClosure();
int hr = Error.E_NOTIMPL;
if (tvclosure.mObject != null)
{
Dispatch2 disp = tvclosure.mObjThis != null ? tvclosure.mObjThis : objthis;
hr = tvclosure.mObject.PropGet(0, null, value, disp);
}
if (hr >= 0)
{
getvalues = true;
}
else
{
if (hr != Error.E_NOTIMPL && hr != Error.E_INVALIDTYPE && hr != Error.E_INVALIDOBJECT)
{
return false;
}
}
}
}
if (getvalues == false)
{
value.CopyRef(data.mValue);
}
}
return callback.Callback(data.mName, newflags, value);
}
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
protected internal static int DefaultPropSet(int flag, Variant targ, Variant param
, Dispatch2 objthis)
{
if ((flag & Interface.IGNOREPROP) == 0)
{
if (targ.IsObject())
{
// roughly the same as TJSDefaultPropGet
VariantClosure tvclosure = targ.AsObjectClosure();
int hr = Error.E_NOTIMPL;
if (tvclosure.mObject != null)
{
Dispatch2 disp = tvclosure.mObjThis != null ? tvclosure.mObjThis : objthis;
hr = tvclosure.mObject.PropSet(0, null, param, disp);
}
if (hr >= 0)
{
return hr;
}
if (hr != Error.E_NOTIMPL && hr != Error.E_INVALIDTYPE && hr != Error.E_INVALIDOBJECT)
{
return hr;
}
}
}
// normal substitution
if (param == null)
{
return Error.E_INVALIDPARAM;
}
targ.CopyRef(param);
return Error.S_OK;
}
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
protected internal static int DefaultPropGet(int flag, Variant targ, Variant result
, Dispatch2 objthis)
{
if ((flag & Interface.IGNOREPROP) == 0)
{
// if IGNOREPROP is not specified
// if member's type is tvtObject, call the object's PropGet with "member=NULL"
// ( default member invocation ). if it is succeeded, return its return value.
// if the PropGet's return value is TJS_E_ACCESSDENYED,
// return as an error, otherwise return the member itself.
if (targ.IsObject())
{
VariantClosure tvclosure = targ.AsObjectClosure();
int hr = Error.E_NOTIMPL;
if (tvclosure.mObject != null)
{
Dispatch2 disp = tvclosure.mObjThis != null ? tvclosure.mObjThis : objthis;
hr = tvclosure.mObject.PropGet(0, null, result, disp);
}
if (hr >= 0)
{
return hr;
}
if (hr != Error.E_NOTIMPL && hr != Error.E_INVALIDTYPE && hr != Error.E_INVALIDOBJECT)
{
return hr;
}
}
}
// return the member itself
if (result == null)
{
return Error.E_INVALIDPARAM;
}
result.CopyRef(targ);
return Error.S_OK;
}
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
/// <exception cref="Kirikiri.Tjs2.TJSException"></exception>
protected internal static int DefaultOperation(int flag, Variant targ, Variant result
, Variant param, Dispatch2 objthis)
{
int op = flag & OP_MASK;
if (op != OP_INC && op != OP_DEC && param == null)
{
return Error.E_INVALIDPARAM;
}
if (op < OP_MIN || op > OP_MAX)
{
return Error.E_INVALIDPARAM;
}
if (targ.IsObject())
{
// the member may be a property handler if the member's type is "tvtObject"
// so here try to access the object.
int hr;
VariantClosure tvclosure = targ.AsObjectClosure();
if (tvclosure.mObject != null)
{
Dispatch2 ot = tvclosure.mObjThis != null ? tvclosure.mObjThis : objthis;
Variant tmp = new Variant();
hr = tvclosure.mObject.PropGet(0, null, tmp, ot);
if (hr >= 0)
{
DoVariantOperation(op, tmp, param);
hr = tvclosure.mObject.PropSet(0, null, tmp, ot);
if (hr < 0)
{
return hr;
}
if (result != null)
{
result.CopyRef(tmp);
}
return Error.S_OK;
}
else
{
if (hr != Error.E_NOTIMPL && hr != Error.E_INVALIDTYPE && hr != Error.E_INVALIDOBJECT)
{
return hr;
}
}
}
}
// normal operation is proceeded if "PropGet" is failed.
DoVariantOperation(op, targ, param);
if (result != null)
{
result.CopyRef(targ);
}
return Error.S_OK;
}
/// <exception cref="Kirikiri.Tjs2.TJSScriptError"></exception>
/// <exception cref="Kirikiri.Tjs2.VariantException"></exception>
private int ExecuteCode(Variant[] ra_org, int ra_offset, int startip, Variant[] args
, Variant result)
{
// execute VM codes
int codesave = startip;
try
{
int code = startip;
//mCodeArea.get(startip);
//if(TJSStackTracerEnabled()) TJSStackTracerSetCodePointer(CodeArea, &codesave);
Variant[] ra = ra_org;
Variant[] da = mDataArray;
short[] ca = mCode;
int ri;
bool flag = false;
//int op;
while (true)
{
codesave = code;
switch (ca[code])
{
case VM_NOP:
{
//op = ca[code];
code++;
break;
}
case VM_CONST:
{
//TJS_GET_VM_REG(ra, code[1]).CopyRef(TJS_GET_VM_REG(da, code[2]));
ra[ra_offset + ca[code + 1]].Set(da[ca[code + 2]]);
code += 3;
break;
}
case VM_CP:
{
//TJS_GET_VM_REG(ra, code[1]).CopyRef(TJS_GET_VM_REG(ra, code[2]));
ra[ra_offset + ca[code + 1]].Set(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_CL:
{
//TJS_GET_VM_REG(ra, code[1]).Clear();
ra[ra_offset + ca[code + 1]].Clear();
code += 2;
break;
}
case VM_CCL:
{
ContinuousClear(ra, ra_offset, code);
code += 3;
break;
}
case VM_TT:
{
//flag = TJS_GET_VM_REG(ra, code[1]).operator bool();
flag = ra[ra_offset + ca[code + 1]].AsBoolean();
code += 2;
break;
}
case VM_TF:
{
//flag = !(TJS_GET_VM_REG(ra, code[1]).operator bool());
flag = !ra[ra_offset + ca[code + 1]].AsBoolean();
code += 2;
break;
}
case VM_CEQ:
{
//flag = TJS_GET_VM_REG(ra, code[1]).NormalCompare( TJS_GET_VM_REG(ra, code[2]));
flag = ra[ra_offset + ca[code + 1]].NormalCompare(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_CDEQ:
{
//flag = TJS_GET_VM_REG(ra, code[1]).DiscernCompare( TJS_GET_VM_REG(ra, code[2]));
ri = ca[code + 2];
if (ri == 0)
{
flag = ra[ra_offset + ca[code + 1]].IsVoid();
}
else
{
flag = ra[ra_offset + ca[code + 1]].DiscernCompare(ra[ra_offset + ca[code + 2]]).
AsBoolean();
}
code += 3;
break;
}
case VM_CLT:
{
//flag = TJS_GET_VM_REG(ra, code[1]).GreaterThan( TJS_GET_VM_REG(ra, code[2]));
flag = ra[ra_offset + ca[code + 1]].GreaterThan(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_CGT:
{
//flag = TJS_GET_VM_REG(ra, code[1]).LittlerThan( TJS_GET_VM_REG(ra, code[2]));
flag = ra[ra_offset + ca[code + 1]].LittlerThan(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_SETF:
{
//TJS_GET_VM_REG(ra, code[1]) = flag;
ra[ra_offset + ca[code + 1]].Set(flag ? 1 : 0);
code += 2;
break;
}
case VM_SETNF:
{
//TJS_GET_VM_REG(ra, code[1]) = !flag;
ra[ra_offset + ca[code + 1]].Set(flag ? 0 : 1);
code += 2;
break;
}
case VM_LNOT:
{
//TJS_GET_VM_REG(ra, code[1]).logicalnot();
ra[ra_offset + ca[code + 1]].Logicalnot();
code += 2;
break;
}
case VM_NF:
{
flag = !flag;
code++;
break;
}
case VM_JF:
{
// TJS_ADD_VM_CODE_ADDR(dest, x) ((*(char **)&(dest)) += (x))
if (flag)
{
//TJS_ADD_VM_CODE_ADDR(code, code[1]);
//code += ra[ra_offset+ca[code+1]).asInteger();
code += ca[code + 1];
}
else
{
code += 2;
}
break;
}
case VM_JNF:
{
if (!flag)
{
//TJS_ADD_VM_CODE_ADDR(code, code[1]);
//code += ra[ra_offset+ca[code+1]).asInteger();
code += ca[code + 1];
}
else
{
code += 2;
}
break;
}
case VM_JMP:
{
//TJS_ADD_VM_CODE_ADDR(code, code[1]);
//code += ra[ra_offset+ca[code+1]).asInteger();
code += ca[code + 1];
break;
}
case VM_INC:
{
//TJS_GET_VM_REG(ra, code[1]).increment();
ra[ra_offset + ca[code + 1]].Increment();
code += 2;
break;
}
case VM_INCPD:
{
OperatePropertyDirect0(ra, ra_offset, code, OP_INC);
code += 4;
break;
}
case VM_INCPI:
{
OperatePropertyIndirect0(ra, ra_offset, code, OP_INC);
code += 4;
break;
}
case VM_INCP:
{
OperateProperty0(ra, ra_offset, code, OP_INC);
code += 3;
break;
}
case VM_DEC:
{
//TJS_GET_VM_REG(ra, code[1]).decrement();
ra[ra_offset + ca[code + 1]].Decrement();
code += 2;
break;
}
case VM_DECPD:
{
OperatePropertyDirect0(ra, ra_offset, code, OP_DEC);
code += 4;
break;
}
case VM_DECPI:
{
OperatePropertyIndirect0(ra, ra_offset, code, OP_DEC);
code += 4;
break;
}
case VM_DECP:
{
OperateProperty0(ra, ra_offset, code, OP_DEC);
code += 3;
break;
}
case VM_LOR:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].Logicalorequal(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_LORPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_LOR);
code += 5;
break;
}
case VM_LORPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_LOR);
code += 5;
break;
}
case VM_LORP:
{
OperateProperty(ra, ra_offset, code, OP_LOR);
code += 4;
break;
}
case VM_LAND:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].Logicalandequal(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_LANDPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_LAND);
code += 5;
break;
}
case VM_LANDPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_LAND);
code += 5;
break;
}
case VM_LANDP:
{
OperateProperty(ra, ra_offset, code, OP_LAND);
code += 4;
break;
}
case VM_BOR:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].OrEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_BORPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_BOR);
code += 5;
break;
}
case VM_BORPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_BOR);
code += 5;
break;
}
case VM_BORP:
{
OperateProperty(ra, ra_offset, code, OP_BOR);
code += 4;
break;
}
case VM_BXOR:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].BitXorEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_BXORPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_BXOR);
code += 5;
break;
}
case VM_BXORPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_BXOR);
code += 5;
break;
}
case VM_BXORP:
{
OperateProperty(ra, ra_offset, code, OP_BXOR);
code += 4;
break;
}
case VM_BAND:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].AndEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_BANDPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_BAND);
code += 5;
break;
}
case VM_BANDPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_BAND);
code += 5;
break;
}
case VM_BANDP:
{
OperateProperty(ra, ra_offset, code, OP_BAND);
code += 4;
break;
}
case VM_SAR:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].RightShiftEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_SARPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_SAR);
code += 5;
break;
}
case VM_SARPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_SAR);
code += 5;
break;
}
case VM_SARP:
{
OperateProperty(ra, ra_offset, code, OP_SAR);
code += 4;
break;
}
case VM_SAL:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].LeftShiftEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_SALPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_SAL);
code += 5;
break;
}
case VM_SALPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_SAL);
code += 5;
break;
}
case VM_SALP:
{
OperateProperty(ra, ra_offset, code, OP_SAL);
code += 4;
break;
}
case VM_SR:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].Rbitshiftequal(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_SRPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_SR);
code += 5;
break;
}
case VM_SRPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_SR);
code += 5;
break;
}
case VM_SRP:
{
OperateProperty(ra, ra_offset, code, OP_SR);
code += 4;
break;
}
case VM_ADD:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].AddEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_ADDPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_ADD);
code += 5;
break;
}
case VM_ADDPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_ADD);
code += 5;
break;
}
case VM_ADDP:
{
OperateProperty(ra, ra_offset, code, OP_ADD);
code += 4;
break;
}
case VM_SUB:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].SubtractEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_SUBPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_SUB);
code += 5;
break;
}
case VM_SUBPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_SUB);
code += 5;
break;
}
case VM_SUBP:
{
OperateProperty(ra, ra_offset, code, OP_SUB);
code += 4;
break;
}
case VM_MOD:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].ResidueEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_MODPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_MOD);
code += 5;
break;
}
case VM_MODPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_MOD);
code += 5;
break;
}
case VM_MODP:
{
OperateProperty(ra, ra_offset, code, OP_MOD);
code += 4;
break;
}
case VM_DIV:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].DivideEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_DIVPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_DIV);
code += 5;
break;
}
case VM_DIVPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_DIV);
code += 5;
break;
}
case VM_DIVP:
{
OperateProperty(ra, ra_offset, code, OP_DIV);
code += 4;
break;
}
case VM_IDIV:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].Idivequal(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_IDIVPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_IDIV);
code += 5;
break;
}
case VM_IDIVPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_IDIV);
code += 5;
break;
}
case VM_IDIVP:
{
OperateProperty(ra, ra_offset, code, OP_IDIV);
code += 4;
break;
}
case VM_MUL:
{
// TJS_DEF_VM_P
ra[ra_offset + ca[code + 1]].MultiplyEqual(ra[ra_offset + ca[code + 2]]);
code += 3;
break;
}
case VM_MULPD:
{
OperatePropertyDirect(ra, ra_offset, code, OP_MUL);
code += 5;
break;
}
case VM_MULPI:
{
OperatePropertyIndirect(ra, ra_offset, code, OP_MUL);
code += 5;
break;
}
case VM_MULP:
{
OperateProperty(ra, ra_offset, code, OP_MUL);
code += 4;
break;
}
case VM_BNOT:
{
// TJS_DEF_VM_P
//TJS_GET_VM_REG(ra, code[1]).bitnot();
ra[ra_offset + ca[code + 1]].Bitnot();
code += 2;
break;
}
case VM_ASC:
{
//CharacterCodeOf(TJS_GET_VM_REG(ra, code[1]));
CharacterCodeOf(ra[ra_offset + ca[code + 1]]);
code += 2;
break;
}
case VM_CHR:
{
//CharacterCodeFrom(TJS_GET_VM_REG(ra, code[1]));
CharacterCodeFrom(ra[ra_offset + ca[code + 1]]);
code += 2;
break;
}
case VM_NUM:
{
//TJS_GET_VM_REG(ra, code[1]).tonumber();
ra[ra_offset + ca[code + 1]].Tonumber();
code += 2;
break;
}
case VM_CHS:
{
//TJS_GET_VM_REG(ra, code[1]).changesign();
ra[ra_offset + ca[code + 1]].Changesign();
code += 2;
break;
}
case VM_INV:
{
int offset = ra_offset + ca[code + 1];
bool tmp = ra[offset].IsObject() == false ? false : ra[offset].AsObjectClosure().
Invalidate(0, null, ra[ra_offset - 1].AsObject()) == Error.S_TRUE;
ra[offset].Set(tmp ? 1 : 0);
code += 2;
break;
}
case VM_CHKINV:
{
int offset = ra_offset + ca[code + 1];
bool tmp;
if (ra[offset].IsObject() == false)
{
tmp = true;
}
else
{
int ret = ra[offset].AsObjectClosure().IsValid(0, null, ra[ra_offset - 1].AsObject
());
tmp = ret == Error.S_TRUE || ret == Error.E_NOTIMPL;
}
ra[offset].Set(tmp ? 1 : 0);
code += 2;
break;
}
case VM_INT:
{
//TJS_GET_VM_REG(ra, code[1]).ToInteger();
ra[ra_offset + ca[code + 1]].ToInteger();
code += 2;
break;
}
case VM_REAL:
{
//TJS_GET_VM_REG(ra, code[1]).ToReal();
ra[ra_offset + ca[code + 1]].ToReal();
code += 2;
break;
}
case VM_STR:
{
//TJS_GET_VM_REG(ra, code[1]).ToString();
ra[ra_offset + ca[code + 1]].SelfToString();
code += 2;
break;
}
case VM_OCTET:
{
//TJS_GET_VM_REG(ra, code[1]).ToOctet();
ra[ra_offset + ca[code + 1]].ToOctet();
code += 2;
break;
}
case VM_TYPEOF:
{
//TypeOf(TJS_GET_VM_REG(ra, code[1]));
TypeOf(ra[ra_offset + ca[code + 1]]);
code += 2;
break;
}
case VM_TYPEOFD:
{
TypeOfMemberDirect(ra, ra_offset, code, Interface.MEMBERMUSTEXIST);
code += 4;
break;
}
case VM_TYPEOFI:
{
TypeOfMemberIndirect(ra, ra_offset, code, Interface.MEMBERMUSTEXIST);
code += 4;
break;
}
case VM_EVAL:
{
Eval(ra[ra_offset + ca[code + 1]], TJS.mEvalOperatorIsOnGlobal ? null : ra[ra_offset
- 1].AsObject(), true);
code += 2;
break;
}
case VM_EEXP:
{
Eval(ra[ra_offset + ca[code + 1]], TJS.mEvalOperatorIsOnGlobal ? null : ra[ra_offset
- 1].AsObject(), false);
code += 2;
break;
}
case VM_CHKINS:
{
InstanceOf(ra[ra_offset + ca[code + 2]], ra[ra_offset + ca[code + 1]]);
code += 3;
break;
}
case VM_CALL:
case VM_NEW:
{
code += CallFunction(ra, ra_offset, code, args);
break;
}
case VM_CALLD:
{
code += CallFunctionDirect(ra, ra_offset, code, args);
break;
}
case VM_CALLI:
{
code += CallFunctionIndirect(ra, ra_offset, code, args);
break;
}
case VM_GPD:
{
GetPropertyDirect(ra, ra_offset, code, 0);
code += 4;
break;
}
case VM_GPDS:
{
GetPropertyDirect(ra, ra_offset, code, Interface.IGNOREPROP);
code += 4;
break;
}
case VM_SPD:
{
SetPropertyDirect(ra, ra_offset, code, 0);
code += 4;
break;
}
case VM_SPDE:
{
SetPropertyDirect(ra, ra_offset, code, Interface.MEMBERENSURE);
code += 4;
break;
}
case VM_SPDEH:
{
SetPropertyDirect(ra, ra_offset, code, Interface.MEMBERENSURE | Interface.HIDDENMEMBER
);
code += 4;
break;
}
case VM_SPDS:
{
SetPropertyDirect(ra, ra_offset, code, Interface.MEMBERENSURE | Interface.IGNOREPROP
);
code += 4;
break;
}
case VM_GPI:
{
GetPropertyIndirect(ra, ra_offset, code, 0);
code += 4;
break;
}
case VM_GPIS:
{
GetPropertyIndirect(ra, ra_offset, code, Interface.IGNOREPROP);
code += 4;
break;
}
case VM_SPI:
{
SetPropertyIndirect(ra, ra_offset, code, 0);
code += 4;
break;
}
case VM_SPIE:
{
SetPropertyIndirect(ra, ra_offset, code, Interface.MEMBERENSURE);
code += 4;
break;
}
case VM_SPIS:
{
SetPropertyIndirect(ra, ra_offset, code, Interface.MEMBERENSURE | Interface.IGNOREPROP
);
code += 4;
break;
}
case VM_GETP:
{
GetProperty(ra, ra_offset, code);
code += 3;
break;
}
case VM_SETP:
{
SetProperty(ra, ra_offset, code);
code += 3;
break;
}
case VM_DELD:
{
DeleteMemberDirect(ra, ra_offset, code);
code += 4;
break;
}
case VM_DELI:
{
DeleteMemberIndirect(ra, ra_offset, code);
code += 4;
break;
}
case VM_SRV:
{
if (result != null)
{
result.CopyRef(ra[ra_offset + ca[code + 1]]);
}
code += 2;
break;
}
case VM_RET:
{
return code + 1;
}
case VM_ENTRY:
{
// TJS_FROM_VM_REG_ADDR(x) ((tjs_int)(x) / (tjs_int)sizeof(tTJSVariant))
// TJS_FROM_VM_CODE_ADDR(x) ((tjs_int)(x) / (tjs_int)sizeof(tjs_uint32))
code = ExecuteCodeInTryBlock(ra, ra_offset, code + 3, args, result, ca[code + 1]
+ code, ca[code + 2]);
break;
}
case VM_EXTRY:
{
return code + 1;
}
case VM_THROW:
{
// same as ret
ThrowScriptException(ra[ra_offset + ca[code + 1]], mBlock, CodePosToSrcPos(code));
code += 2;
// actually here not proceed...
break;
}
case VM_CHGTHIS:
{
ra[ra_offset + ca[code + 1]].ChangeClosureObjThis(ra[ra_offset + ca[code + 2]].AsObject
());
code += 3;
break;
}
case VM_GLOBAL:
{
ra[ra_offset + ca[code + 1]].Set(mBlock.GetTJS().GetGlobal());
code += 2;
break;
}
case VM_ADDCI:
{
AddClassInstanceInfo(ra, ra_offset, code);
code += 3;
break;
}
case VM_REGMEMBER:
{
//registerObjectMember( ra[ra_offset-1].asObject() );
CopyAllMembers((CustomObject)ra[ra_offset - 1].AsObject());
code++;
break;
}
case VM_DEBUGGER:
{
//TJSNativeDebuggerBreak();
code++;
break;
}
default:
{
ThrowInvalidVMCode();
break;
}
}
}
}
catch (TJSScriptException e)
{
e.AddTrace(this, codesave);
//e.printStackTrace();
throw;
}
catch (TJSScriptError e)
{
e.AddTrace(this, codesave);
//e.printStackTrace();
throw;
}
catch (TJSException e)
{
DisplayExceptionGeneratedCode(codesave, ra_org, ra_offset);
//TJS_eTJSScriptError( e.getMessage(), this, codesave );
//e.printStackTrace();
Error.ReportExceptionSource(e.Message, this, CodePosToSrcPos(codesave));
throw new TJSScriptError(e.Message, mBlock, CodePosToSrcPos(codesave));
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
DisplayExceptionGeneratedCode(codesave, ra_org, ra_offset);
//TJS_eTJSScriptError( e.getMessage(), this, codesave );
Error.ReportExceptionSource(e.Message, this, CodePosToSrcPos(codesave));
throw new TJSScriptError(e.Message, mBlock, CodePosToSrcPos(codesave));
}
}
