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