src/core/object.cpp

   1
   2 #include "pcheader.hpp"
   3 #include "vm.hpp"
   4 #include "string.hpp"
   5 #include "table.hpp"
   6 #include "userdata.hpp"
   7 #include "funcproto.hpp"
   8 #include "class.hpp"
   9 #include "closure.hpp"
  10
  11
  12
  13
  14 VXWeakRefObj *VXRefCountedObj::GetWeakRef(VXOType type)
  15 {
  16     if(!_weakref)
  17     {
  18         vox_new(_weakref,VXWeakRefObj);
  19         _weakref->_obj._type = type;
  20         _weakref->_obj._unVal.pRefCounted = this;
  21     }
  22     return _weakref;
  23 }
  24
  25 VXRefCountedObj::~VXRefCountedObj()
  26 {
  27     if(_weakref)
  28     {
  29         _weakref->_obj._type = VX_OT_NULL;
  30         _weakref->_obj._unVal.pRefCounted = NULL;
  31     }
  32 }
  33
  34 void VXWeakRefObj::Release()
  35 {
  36     if(ISREFCOUNTED(_obj._type))
  37     {
  38         _obj._unVal.pRefCounted->_weakref = NULL;
  39     }
  40     vox_delete(this,VXWeakRefObj);
  41 }
  42
  43 bool VXDelegableObj::GetMetaMethod(VXState *v,VXMetaMethod mm,VXObject &res)
  44 {
  45     if(_delegate)
  46     {
  47         return _delegate->Get((*_ss(v)->_metamethods)[mm],res);
  48     }
  49     return false;
  50 }
  51
  52 bool VXDelegableObj::SetDelegate(VXTableObj *mt)
  53 {
  54     VXTableObj *temp = mt;
  55     if(temp == this) return false;
  56     while (temp)
  57     {
  58                                  //cycle detected
  59         if (temp->_delegate == this) return false;
  60         temp = temp->_delegate;
  61     }
  62     if (mt) __ObjAddRef(mt);
  63     __ObjRelease(_delegate);
  64     _delegate = mt;
  65     return true;
  66 }
  67
  68 bool VXGeneratorObj::Yield(VXState *v,VXInteger target)
  69 {
  70     if(_state==eSuspended)
  71     {
  72         v->ThrowError("internal vm error, yielding dead generator");
  73         return false;
  74     }
  75     if(_state==eDead)
  76     {
  77         v->ThrowError("internal vm error, yielding a dead generator");
  78         return false;
  79     }
  80     VXInteger size = ((v->_top) - (v->_stackbase));
  81     _stack.resize(size);
  82     VXRawObj _this = v->_stack[v->_stackbase];
  83     _stack.values()[0] = (
  84         ISREFCOUNTED(type(_this)) ?
  85         VXObject(_refcounted(_this)->GetWeakRef(type(_this))) :
  86         _this);
  87     for(VXInteger n =1; n<target; n++)
  88     {
  89         _stack.values()[n] = v->_stack[v->_stackbase+n];
  90     }
  91     for(VXInteger j =0; j < size; j++)
  92     {
  93         v->_stack[v->_stackbase+j].Null();
  94     }
  95
  96     _ci = *v->ci;
  97     _ci._generator=NULL;
  98     for(VXInteger i=0;i<_ci._etraps;i++)
  99     {
 100         _etraps.push_back(v->_etraps.top());
 101         v->_etraps.pop_back();
 102     }
 103     _state=eSuspended;
 104     return true;
 105 }
 106
 107 bool VXGeneratorObj::Resume(VXState *v,VXObject &dest)
 108 {
 109     if(_state==eDead)
 110     {
 111         v->ThrowError("resuming dead generator");
 112         return false;
 113     }
 114     if(_state==eRunning)
 115     {
 116         v->ThrowError("resuming active generator");
 117         return false;
 118     }
 119     VXInteger size = _stack.size();
 120     VXInteger target = &dest - &(v->_stack.values()[v->_stackbase]);
 121     vox_assert(target>=0 && target<=255);
 122     if(!v->EnterFrame(v->_top, v->_top + size, false))
 123     {
 124         return false;
 125     }
 126     v->ci->_generator   = this;
 127     v->ci->_target      = (VXInt32)target;
 128     v->ci->_closure     = _ci._closure;
 129     v->ci->_ip          = _ci._ip;
 130     v->ci->_literals    = _ci._literals;
 131     v->ci->_ncalls      = _ci._ncalls;
 132     v->ci->_etraps      = _ci._etraps;
 133     v->ci->_root        = _ci._root;
 134     for(VXInteger i=0;i<_ci._etraps;i++)
 135     {
 136         v->_etraps.push_back(_etraps.top());
 137         _etraps.pop_back();
 138     }
 139     VXRawObj _this = _stack.values()[0];
 140     v->_stack[v->_stackbase] = type(_this) == VX_OT_WEAKREF ? _weakref(_this)->_obj : _this;
 141
 142     for(VXInteger n = 1; n<size; n++)
 143     {
 144         v->_stack[v->_stackbase+n] = _stack.values()[n];
 145         _stack.values()[n].Null();
 146     }
 147
 148     _state=eRunning;
 149     if (v->_debughook)
 150     {
 151         v->CallDebugHook('c');
 152     }
 153     return true;
 154 }
 155
 156
 157 void VXInstanceObj::Mark(VXCollectable **chain)
 158 {
 159     START_MARK()
 160         _class->Mark(chain);
 161     VXUnsignedInteger nvalues = _class->_defaultvalues.size();
 162     for(VXUnsignedInteger i =0; i< nvalues; i++)
 163     {
 164         VXSharedState::MarkObject(_values[i], chain);
 165     }
 166     END_MARK()
 167 }
 168
 169 void VXGeneratorObj::Mark(VXCollectable **chain)
 170 {
 171     START_MARK()
 172     for(VXUnsignedInteger i = 0; i < _stack.size(); i++)
 173     {
 174         VXSharedState::MarkObject(_stack[i], chain);
 175     }
 176     VXSharedState::MarkObject(_closure, chain);
 177     END_MARK()
 178 }
 179
 180
 181
 182 void VXOuterObj::Mark(VXCollectable **chain)
 183 {
 184     START_MARK()
 185     /* If the valptr points to a closed value, that value is alive */
 186     if(_valptr == &_value)
 187     {
 188         VXSharedState::MarkObject(_value, chain);
 189     }
 190     END_MARK()
 191 }
 192
 193 void VXUserDataObj::Mark(VXCollectable **chain)
 194 {
 195     START_MARK()
 196     if(_delegate)
 197     {
 198         _delegate->Mark(chain);
 199     }
 200     END_MARK()
 201 }
 202
 203 void VXCollectable::UnMark()
 204 {
 205     _uiRef&=~MARK_FLAG;
 206 }
 207
 208
 209
 210 void VXObject::Null()
 211 {
 212     __Release(_type ,_unVal);
 213     _type = VX_OT_NULL;
 214     _unVal.raw = (VXRawValue)NULL;
 215 }
 216
 217 bool VXObject::IsNull() const
 218 {
 219     return (_unVal.raw == (VXRawValue)NULL);
 220 }
 221
 222 bool VXObject::IsNumeric() const
 223 {
 224     return (Type() & VXOBJECT_NUMERIC);
 225 }
 226
 227
 228 /**
 229 *    Object instance access methods
 230 */
 231
 232 VXInteger VXObject::Integer()
 233 {
 234     return _unVal.nInteger;
 235 }
 236
 237 VXInteger VXObject::Integer() const
 238 {
 239     return _unVal.nInteger;
 240 }
 241
 242 VXFloat VXObject::Float()
 243 {
 244     return _unVal.fFloat;
 245 }
 246
 247 VXFloat VXObject::Float() const
 248 {
 249     return _unVal.fFloat;
 250 }
 251
 252 VXStringObj* VXObject::String()
 253 {
 254     return _unVal.pString;
 255 }
 256
 257
 258 VXStringObj* VXObject::String() const
 259 {
 260     return _unVal.pString;
 261 }
 262
 263 void VXObject::String(const char** dest, VXInteger* len_dest) const
 264 {
 265     VXStringObj* ob = this->String();
 266     (*dest) = ob->_val;
 267     if(len_dest != NULL)
 268     {
 269         (*len_dest) = ob->_len;
 270     }
 271 }
 272
 273 VXTableObj* VXObject::Table()
 274 {
 275     return _unVal.pTable;
 276 }
 277
 278 VXTableObj* VXObject::Table() const
 279 {
 280     return _unVal.pTable;
 281 }
 282
 283 VXArrayObj* VXObject::Array()
 284 {
 285     return _unVal.pArray;
 286 }
 287
 288 VXArrayObj* VXObject::Array() const
 289 {
 290     return _unVal.pArray;
 291 }
 292 VXForeignClosureObj* VXObject::Closure()
 293 {
 294     return _unVal.pClosure;
 295 }
 296
 297 VXGeneratorObj* VXObject::Generator()
 298 {
 299     return _unVal.pGenerator;
 300 }
 301
 302 VXNativeClosureObj* VXObject::NativeClosure()
 303 {
 304     return _unVal.pNativeClosure;
 305 }
 306
 307 VXUserDataObj* VXObject::UserData()
 308 {
 309     return _unVal.pUserData;
 310 }
 311
 312 VXUserPointer VXObject::UserPointer()
 313 {
 314     return _unVal.pUserPointer;
 315 }
 316
 317 VXState* VXObject::Thread()
 318 {
 319     return _unVal.pThread;
 320 }
 321
 322 VXFuncProtoObj* VXObject::FuncProto()
 323 {
 324     return _unVal.pFunctionProto;
 325 }
 326
 327 VXClassObj* VXObject::Class()
 328 {
 329     return _unVal.pClass;
 330 }
 331
 332 VXInstanceObj* VXObject::Instance()
 333 {
 334     return _unVal.pInstance;
 335 }
 336
 337 VXDelegableObj* VXObject::Delegable()
 338 {
 339     return (VXDelegableObj*)(_unVal.pDelegable);
 340 }
 341
 342 VXWeakRefObj* VXObject::WeakRef()
 343 {
 344     return _unVal.pWeakRef;
 345 }
 346
 347 VXOuterObj* VXObject::Outer()
 348 {
 349     return _unVal.pOuter;
 350 }
 351
 352 VXRefCountedObj* VXObject::RefCounted()
 353 {
 354     return _unVal.pRefCounted;
 355 }
 356
 357 VXRefCountedObj* VXObject::RefCounted() const
 358 {
 359     return _unVal.pRefCounted;
 360 }
 361
 362 VXRawValue VXObject::Raw()
 363 {
 364     return _unVal.raw;
 365 }
 366
 367
 368 template<> VXFloat VXObject::As<VXFloat>()
 369 {
 370     return Float();
 371 }
 372
 373 template<> VXInteger VXObject::As<VXInteger>()
 374 {
 375     return Integer();
 376 }
 377
 378 /**
 379 *   Type Information
 380 */
 381
 382 VXOType VXObject::Type() const
 383 {
 384     return _type;
 385 }
 386
 387 const char* VXObject::TypeString() const
 388 {
 389     return IdType2Name(this->Type());
 390 }
 391
 392 bool VXObject::Is(VXOType tp) const
 393 {
 394     return Type() == tp;
 395 }
 396
 397 bool VXObject::IsTable() const
 398 {
 399     return Is(VX_OT_TABLE);
 400 }
 401
 402 bool VXObject::IsArray() const
 403 {
 404     return Is(VX_OT_ARRAY);
 405 }
 406
 407 bool VXObject::IsFunction() const
 408 {
 409     return Is(VX_OT_FUNCPROTO);
 410 }
 411 bool VXObject::IsClosure() const
 412 {
 413     return Is(VX_OT_CLOSURE);
 414 }
 415
 416 bool VXObject::IsNativeClosure() const
 417 {
 418     return Is(VX_OT_NATIVECLOSURE);
 419 }
 420
 421 bool VXObject::IsGenerator() const
 422 {
 423     return Is(VX_OT_GENERATOR);
 424 }
 425
 426 bool VXObject::IsString() const
 427 {
 428     return Is(VX_OT_STRING);
 429 }
 430
 431 bool VXObject::IsInteger() const
 432 {
 433     return Is(VX_OT_INTEGER);
 434 }
 435
 436 bool VXObject::IsFloat() const
 437 {
 438     return Is(VX_OT_FLOAT);
 439 }
 440
 441 bool VXObject::IsUserPointer() const
 442 {
 443     return Is(VX_OT_USERPOINTER);
 444 }
 445
 446 bool VXObject::IsUserData() const
 447 {
 448     return Is(VX_OT_USERDATA);
 449 }
 450
 451 bool VXObject::IsThread() const
 452 {
 453     return Is(VX_OT_THREAD);
 454 }
 455
 456 bool VXObject::IsClass() const
 457 {
 458     return Is(VX_OT_CLASS);
 459 }
 460
 461 bool VXObject::IsInstance() const
 462 {
 463     return Is(VX_OT_INSTANCE);
 464 }
 465
 466 bool VXObject::IsBool() const
 467 {
 468     return Is(VX_OT_BOOL);
 469 }
 470
 471 bool VXObject::IsWeakRef() const
 472 {
 473     return Is(VX_OT_WEAKREF);
 474 }
 475
 476 /**
 477 *   Constructors
 478 */
 479
 480 VXObject::~VXObject()
 481 {
 482     __Release(_type,_unVal);
 483 }
 484
 485 VXObject::VXObject()
 486 {
 487     VX_OBJECT_RAWINIT(this)
 488     _type=VX_OT_NULL;
 489     _unVal.pUserPointer=NULL;
 490 }
 491 VXObject::VXObject(const VXObject &o)
 492 {
 493     _type=o._type;
 494     _unVal=o._unVal;
 495     VX_ADDREF(_type,_unVal);
 496 }
 497
 498 VXObject::VXObject(const VXRawObj &o)
 499 {
 500     _type=o._type;
 501     _unVal=o._unVal;
 502     VX_ADDREF(_type,_unVal);
 503 }
 504
 505
 506 VXObject::VXObject(bool bBool)
 507 {
 508     VX_OBJECT_RAWINIT(this)
 509     _type = VX_OT_BOOL;
 510     _unVal.nInteger = bBool?1:0;
 511 }
 512
 513 VXObject::VXObject (VXTableObj * x)
 514 {
 515     VX_OBJECT_RAWINIT(this)
 516     _type = VX_OT_TABLE;
 517     _unVal.pTable = x;
 518     vox_assert (_unVal.pTable);
 519     _unVal.pRefCounted->_uiRef++;
 520 }
 521
 522 VXObject::VXObject (VXClassObj * x)
 523 {
 524     VX_OBJECT_RAWINIT(this)
 525     _type = VX_OT_CLASS;
 526     _unVal.pClass = x;
 527     vox_assert (_unVal.pTable);
 528     _unVal.pRefCounted->_uiRef++;
 529 }
 530
 531 VXObject & VXObject::operator= (VXClassObj * x)
 532 {
 533     VXOType tOldType;
 534     VXRawObj::Value unOldVal;
 535     tOldType = _type;
 536     unOldVal = _unVal;
 537     _type = VX_OT_CLASS;
 538     VX_REFOBJECT_INIT (this)
 539     _unVal.pClass = x;
 540     _unVal.pRefCounted->_uiRef++;
 541     __Release (tOldType, unOldVal);
 542     return *this;
 543 }
 544
 545 VXObject::VXObject (VXInstanceObj * x)
 546 {
 547     VX_OBJECT_RAWINIT(this)
 548     _type = VX_OT_INSTANCE;
 549     _unVal.pInstance = x;
 550     vox_assert (_unVal.pTable);
 551     _unVal.pRefCounted->_uiRef++;
 552 }
 553
 554 VXObject::VXObject(VXArrayObj * x)
 555 {
 556     VX_OBJECT_RAWINIT(this)
 557     _type = VX_OT_ARRAY;
 558     _unVal.pArray = x;
 559     vox_assert(_unVal.pTable);
 560     _unVal.pRefCounted->_uiRef++;
 561 }
 562
 563
 564
 565 VXObject::VXObject (VXForeignClosureObj * x)
 566 {
 567     VX_OBJECT_RAWINIT(this)
 568     _type = VX_OT_CLOSURE;
 569     _unVal.pClosure = x;
 570     vox_assert (_unVal.pTable);
 571     _unVal.pRefCounted->_uiRef++;
 572 }
 573
 574
 575
 576 VXObject::VXObject (VXNativeClosureObj * x)
 577 {
 578     VX_OBJECT_RAWINIT(this)
 579     _type = VX_OT_NATIVECLOSURE;
 580     _unVal.pNativeClosure = x;
 581     vox_assert (_unVal.pTable);
 582     _unVal.pRefCounted->_uiRef++;
 583 }
 584
 585
 586
 587 VXObject::VXObject (VXOuterObj * x)
 588 {
 589     VX_OBJECT_RAWINIT(this)
 590     _type = VX_OT_OUTER;
 591     _unVal.pOuter = x;
 592     vox_assert (_unVal.pTable);
 593     _unVal.pRefCounted->_uiRef++;
 594 }
 595
 596
 597 VXObject::VXObject (VXGeneratorObj * x)
 598 {
 599     VX_OBJECT_RAWINIT(this)
 600     _type = VX_OT_GENERATOR;
 601     _unVal.pGenerator = x;
 602     vox_assert (_unVal.pTable);
 603     _unVal.pRefCounted->_uiRef++;
 604 }
 605
 606 VXObject::VXObject (VXStringObj * x)
 607 {
 608     VX_OBJECT_RAWINIT(this)
 609     _type = VX_OT_STRING;
 610     _unVal.pString = x;
 611     vox_assert (_unVal.pTable);
 612     _unVal.pRefCounted->_uiRef++;
 613 }
 614
 615 VXObject::VXObject (VXUserDataObj * x)
 616 {
 617     VX_OBJECT_RAWINIT(this)
 618     _type = VX_OT_USERDATA;
 619     _unVal.pUserData = x;
 620     vox_assert (_unVal.pTable);
 621     _unVal.pRefCounted->_uiRef++;
 622 }
 623
 624
 625 VXObject::VXObject (VXWeakRefObj * x)
 626 {
 627     VX_OBJECT_RAWINIT(this)
 628     _type = VX_OT_WEAKREF;
 629     _unVal.pWeakRef = x;
 630     vox_assert (_unVal.pTable);
 631     _unVal.pRefCounted->_uiRef++;
 632 }
 633
 634
 635 VXObject::VXObject (VXState * x)
 636 {
 637     VX_OBJECT_RAWINIT(this)
 638     _type = VX_OT_THREAD;
 639     _unVal.pThread = x;
 640     vox_assert (_unVal.pTable);
 641     _unVal.pRefCounted->_uiRef++;
 642 }
 643
 644
 645 VXObject::VXObject (VXFuncProtoObj * x)
 646 {
 647     VX_OBJECT_RAWINIT(this)
 648     _unVal.pFunctionProto = x;
 649     _type = VX_OT_FUNCPROTO;
 650     vox_assert (_unVal.pTable);
 651     _unVal.pRefCounted->_uiRef++;
 652 }
 653
 654 VXObject::VXObject(VXInteger x)
 655 {
 656     VX_OBJECT_RAWINIT(this)
 657     _type = VX_OT_INTEGER;
 658     _unVal.nInteger = x;
 659 }
 660
 661 VXObject::VXObject (VXFloat x)
 662 {
 663     VX_OBJECT_RAWINIT(this)
 664     _type = VX_OT_FLOAT;
 665     _unVal.fFloat = x;
 666 }
 667
 668 VXObject::VXObject (VXUserPointer x)
 669 {
 670     VX_OBJECT_RAWINIT(this)
 671     _type = VX_OT_USERPOINTER;
 672     _unVal.pUserPointer = x;
 673 }
 674
 675 /**
 676 *    operator=() methods
 677 */
 678
 679 VXObject & VXObject::operator= (VXGeneratorObj * x)
 680 {
 681     VXOType tOldType;
 682     VXRawObj::Value unOldVal;
 683     tOldType = _type;
 684     unOldVal = _unVal;
 685     _type = VX_OT_GENERATOR;
 686     VX_REFOBJECT_INIT (this)
 687     _unVal.pGenerator = x;
 688     _unVal.pRefCounted->_uiRef++;
 689     __Release (tOldType, unOldVal);
 690     return *this;
 691 }
 692
 693 VXObject & VXObject::operator= (VXOuterObj * x)
 694 {
 695     VXOType tOldType;
 696     VXRawObj::Value unOldVal;
 697     tOldType = _type;
 698     unOldVal = _unVal;
 699     _type = VX_OT_OUTER;
 700     VX_REFOBJECT_INIT (this)
 701     _unVal.pOuter = x;
 702     _unVal.pRefCounted->_uiRef++;
 703     __Release (tOldType, unOldVal);
 704     return *this;
 705 }
 706
 707
 708 VXObject & VXObject::operator= (VXNativeClosureObj * x)
 709 {
 710     VXOType tOldType;
 711     VXRawObj::Value unOldVal;
 712     tOldType = _type;
 713     unOldVal = _unVal;
 714     _type = VX_OT_NATIVECLOSURE;
 715     VX_REFOBJECT_INIT (this)
 716     _unVal.pNativeClosure = x;
 717     _unVal.pRefCounted->_uiRef++;
 718     __Release (tOldType, unOldVal);
 719     return *this;
 720 }
 721
 722 VXObject & VXObject::operator= (VXForeignClosureObj * x)
 723 {
 724     VXOType tOldType;
 725     VXRawObj::Value unOldVal;
 726     tOldType = _type;
 727     unOldVal = _unVal;
 728     _type = VX_OT_CLOSURE;
 729     VX_REFOBJECT_INIT (this)
 730     _unVal.pClosure = x;
 731     _unVal.pRefCounted->_uiRef++;
 732     __Release (tOldType, unOldVal);
 733     return *this;
 734 }
 735
 736 VXObject & VXObject::operator= (VXArrayObj * x)
 737 {
 738     VXOType tOldType;
 739     VXRawObj::Value unOldVal;
 740     tOldType = _type;
 741     unOldVal = _unVal;
 742     _type = VX_OT_ARRAY;
 743     VX_REFOBJECT_INIT(this)
 744     _unVal.pArray = x;
 745     _unVal.pRefCounted->_uiRef++;
 746     __Release (tOldType, unOldVal);
 747     return *this;
 748 }
 749
 750 VXObject & VXObject::operator= (VXInstanceObj * x)
 751 {
 752     VXOType tOldType;
 753     VXRawObj::Value unOldVal;
 754     tOldType = _type;
 755     unOldVal = _unVal;
 756     _type = VX_OT_INSTANCE;
 757     VX_REFOBJECT_INIT (this)
 758     _unVal.pInstance = x;
 759     _unVal.pRefCounted->_uiRef++;
 760     __Release (tOldType, unOldVal);
 761     return *this;
 762 }
 763
 764 VXObject & VXObject::operator= (VXTableObj * x)
 765 {
 766     VXOType tOldType;
 767     VXRawObj::Value unOldVal;
 768     tOldType = _type;
 769     unOldVal = _unVal;
 770     _type = VX_OT_TABLE;
 771     VX_REFOBJECT_INIT(this)
 772     _unVal.pTable = x;
 773     _unVal.pRefCounted->_uiRef++;
 774     __Release (tOldType, unOldVal);
 775     return *this;
 776 }
 777
 778 VXObject& VXObject::operator=(const VXObject& obj)
 779 {
 780     VXOType tOldType;
 781     VXRawObj::Value unOldVal;
 782     tOldType=_type;
 783     unOldVal=_unVal;
 784     _unVal = obj._unVal;
 785     _type = obj._type;
 786     VX_ADDREF(_type,_unVal);
 787     __Release(tOldType,unOldVal);
 788     return *this;
 789 }
 790
 791 VXObject& VXObject::operator=(const VXRawObj& obj)
 792 {
 793     VXOType tOldType;
 794     VXRawObj::Value unOldVal;
 795     tOldType=_type;
 796     unOldVal=_unVal;
 797     _unVal = obj._unVal;
 798     _type = obj._type;
 799     VX_ADDREF(_type,_unVal);
 800     __Release(tOldType,unOldVal);
 801     return *this;
 802 }
 803
 804 VXObject& VXObject::operator=(bool b)
 805 {
 806     __Release(_type,_unVal);
 807     VX_OBJECT_RAWINIT(this)
 808     _type = VX_OT_BOOL;
 809     _unVal.nInteger = b?1:0;
 810     return *this;
 811 }
 812
 813 VXObject & VXObject::operator= (VXStringObj * x)
 814 {
 815     VXOType tOldType;
 816     VXRawObj::Value unOldVal;
 817     tOldType = _type;
 818     unOldVal = _unVal;
 819     _type = VX_OT_STRING;
 820     VX_REFOBJECT_INIT (this)
 821     _unVal.pString = x;
 822     _unVal.pRefCounted->_uiRef++;
 823     __Release (tOldType, unOldVal);
 824     return *this;
 825 }
 826
 827 VXObject & VXObject::operator= (VXUserDataObj * x)
 828 {
 829     VXOType tOldType;
 830     VXRawObj::Value unOldVal;
 831     tOldType = _type;
 832     unOldVal = _unVal;
 833     _type = VX_OT_USERDATA;
 834     VX_REFOBJECT_INIT (this)
 835     _unVal.pUserData = x;
 836     _unVal.pRefCounted->_uiRef++;
 837     __Release (tOldType, unOldVal);
 838     return *this;
 839 }
 840
 841 VXObject & VXObject::operator= (VXWeakRefObj * x)
 842 {
 843     VXOType tOldType;
 844     VXRawObj::Value unOldVal;
 845     tOldType = _type;
 846     unOldVal = _unVal;
 847     _type = VX_OT_WEAKREF;
 848     VX_REFOBJECT_INIT (this)
 849     _unVal.pWeakRef = x;
 850     _unVal.pRefCounted->_uiRef++;
 851     __Release (tOldType, unOldVal);
 852     return *this;
 853 }
 854
 855 VXObject & VXObject::operator= (VXState * x)
 856 {
 857     VXOType tOldType;
 858     VXRawObj::Value unOldVal;
 859     tOldType = _type;
 860     unOldVal = _unVal;
 861     _type = VX_OT_THREAD;
 862     VX_REFOBJECT_INIT (this)
 863     _unVal.pThread = x;
 864     _unVal.pRefCounted->_uiRef++;
 865     __Release (tOldType, unOldVal);
 866     return *this;
 867 }
 868
 869 VXObject & VXObject::operator= (VXFuncProtoObj * x)
 870 {
 871     VXOType tOldType;
 872     VXRawObj::Value unOldVal;
 873     tOldType = _type;
 874     unOldVal = _unVal;
 875     _type = VX_OT_FUNCPROTO;
 876     VX_REFOBJECT_INIT (this)
 877     _unVal.pFunctionProto = x;
 878     _unVal.pRefCounted->_uiRef++;
 879     __Release (tOldType, unOldVal);
 880     return *this;
 881 }
 882
 883
 884 VXObject & VXObject::operator= (VXFloat x)
 885 {
 886     __Release (_type, _unVal);
 887     _type = VX_OT_FLOAT;
 888     VX_OBJECT_RAWINIT(this)
 889     _unVal.fFloat = x;
 890     return *this;
 891 }
 892
 893 VXObject & VXObject::operator= (VXInteger x)
 894 {
 895     __Release (_type, _unVal);
 896     _type = VX_OT_INTEGER;
 897     VX_OBJECT_RAWINIT(this)
 898     _unVal.nInteger = x;
 899     return *this;
 900 }
 901
 902 VXObject & VXObject::operator= (VXUserPointer x)
 903 {
 904     __Release (_type, _unVal);
 905     _type = VX_OT_USERPOINTER;
 906     VX_OBJECT_RAWINIT(this)
 907     _unVal.pUserPointer = x;
 908     return *this;
 909 }
 910
 911