core/VectorClass.h

   1 /* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
   2 /* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is [Open Source Virtual Machine.].
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Adobe System Incorporated.
  20  * Portions created by the Initial Developer are Copyright (C) 2004-2006
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Adobe AS3 Team
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40
  41 #ifndef __avmplus_VectorClass__
  42 #define __avmplus_VectorClass__
  43
  44 namespace avmplus
  45 {
  46     // ----------------------------
  47
  48     class GC_AS3_EXACT(VectorClass, ClassClosure)
  49     {
  50     protected:
  51         VectorClass(VTable* vtable);
  52     public:
  53         REALLY_INLINE static VectorClass* create(MMgc::GC* gc, VTable* cvtable)
  54         {
  55             return new (gc, MMgc::kExact, cvtable->getExtraSize()) VectorClass(cvtable);
  56         }
  57
  58         virtual Atom applyTypeArgs(int argc, Atom* argv);
  59
  60         ClassClosure* getTypedVectorClass(ClassClosure* typeClass);
  61
  62         static Stringp makeVectorClassName(AvmCore* core, Traits* t);
  63
  64         // make a Vector of subtype Vector<typeClass>,
  65         // eg if typeClass == StringClass then return a new Vector<String>
  66         ObjectVectorObject* newVector(ClassClosure* typeClass, uint32_t length = 0);
  67
  68     private:
  69         GC_NO_DATA(VectorClass)
  70
  71         DECLARE_SLOTS_VectorClass;
  72     };
  73
  74     // ----------------------------
  75
  76     class GC_CPP_EXACT(TypedVectorClassBase, ClassClosure)
  77     {
  78     protected:
  79         explicit TypedVectorClassBase(VTable* vtable);
  80
  81     public:
  82         Traits* getTypeTraits() const;
  83
  84         // ClassClosure overrides
  85         virtual Atom call(int argc, Atom* argv);
  86
  87         // AS3 native function implementations
  88         void _forEach(Atom thisAtom, ScriptObject* callback, Atom thisObject);
  89         bool _every(Atom thisAtom, ScriptObject* callback, Atom thisObject);
  90         bool _some(Atom thisAtom, ScriptObject* callback, Atom thisObject);
  91         Atom _sort(Atom thisAtom, ArrayObject* args);
  92
  93     protected:
  94         virtual Atom createAndInitVectorFromObject(ScriptObject* so, uint32_t len) = 0;
  95
  96     protected:
  97         GC_DATA_BEGIN(TypedVectorClassBase)
  98
  99         DWB(Traits*) GC_POINTER(m_typeTraits);
 100
 101         GC_DATA_END(TypedVectorClassBase)
 102     };
 103
 104     // ----------------------------
 105
 106     template<class OBJ>
 107     class TypedVectorClass : public TypedVectorClassBase
 108     {
 109         friend class VectorClass;
 110
 111     protected:
 112         explicit TypedVectorClass(VTable* vtable);
 113
 114     public:
 115         OBJ* newVector(uint32_t length = 0, bool fixed = false);
 116
 117         virtual bool gcTrace(MMgc::GC* gc, size_t cursor)
 118         {
 119             return TypedVectorClassBase::gcTrace(gc, cursor);
 120         }
 121
 122     protected:
 123         virtual Atom createAndInitVectorFromObject(ScriptObject* so, uint32_t len);
 124         Atom constructImpl(int argc, Atom* argv);
 125     };
 126
 127
 128     // ----------------------------
 129
 130     class GC_AS3_EXACT(IntVectorClass, TypedVectorClass<IntVectorObject>)
 131     {
 132     private:
 133         explicit IntVectorClass(VTable* vtable);
 134     public:
 135         REALLY_INLINE static IntVectorClass* create(MMgc::GC* gc, VTable* cvtable)
 136         {
 137             return new (gc, MMgc::kExact, cvtable->getExtraSize()) IntVectorClass(cvtable);
 138         }
 139
 140         GC_NO_DATA(IntVectorClass)
 141
 142         DECLARE_SLOTS_IntVectorClass;
 143     };
 144
 145     // ----------------------------
 146
 147     class GC_AS3_EXACT(UIntVectorClass, TypedVectorClass<UIntVectorObject>)
 148     {
 149     private:
 150         explicit UIntVectorClass(VTable* vtable);
 151     public:
 152         REALLY_INLINE static UIntVectorClass* create(MMgc::GC* gc, VTable* cvtable)
 153         {
 154             return new (gc, MMgc::kExact, cvtable->getExtraSize()) UIntVectorClass(cvtable);
 155         }
 156
 157         GC_NO_DATA(UIntVectorClass)
 158
 159         DECLARE_SLOTS_UIntVectorClass;
 160     };
 161
 162     // ----------------------------
 163
 164     class GC_AS3_EXACT(DoubleVectorClass, TypedVectorClass<DoubleVectorObject>)
 165     {
 166     private:
 167         explicit DoubleVectorClass(VTable* vtable);
 168     public:
 169         REALLY_INLINE static DoubleVectorClass* create(MMgc::GC* gc, VTable* cvtable)
 170         {
 171             return new (gc, MMgc::kExact, cvtable->getExtraSize()) DoubleVectorClass(cvtable);
 172         }
 173
 174         GC_NO_DATA(DoubleVectorClass)
 175
 176         DECLARE_SLOTS_DoubleVectorClass;
 177     };
 178
 179     // ----------------------------
 180
 181     class GC_AS3_EXACT(ObjectVectorClass, TypedVectorClass<ObjectVectorObject>)
 182     {
 183     private:
 184         explicit ObjectVectorClass(VTable* vtable);
 185     public:
 186         REALLY_INLINE static ObjectVectorClass* create(MMgc::GC* gc, VTable* cvtable)
 187         {
 188             return new (gc, MMgc::kExact, cvtable->getExtraSize()) ObjectVectorClass(cvtable);
 189         }
 190
 191         GC_NO_DATA(ObjectVectorClass)
 192
 193         DECLARE_SLOTS_ObjectVectorClass;
 194     };
 195
 196     // ----------------------------
 197
 198     struct VectorIndex
 199     {
 200         explicit VectorIndex(AvmCore* core, Atom name);
 201
 202         uint32_t index;
 203         enum { kNotNumber, kInvalidNumber, kValidNumber } status;
 204     };
 205
 206     // ----------------------------
 207
 208     template<class T>
 209     struct TypedVectorConstants
 210     {
 211         static T nullValue();
 212         static T undefinedValue();
 213     };
 214
 215     // ----------------------------
 216
 217     class GC_CPP_EXACT(VectorBaseObject, ScriptObject)
 218     {
 219     protected:
 220         explicit VectorBaseObject(VTable* ivtable, ScriptObject* delegate);
 221
 222     public:
 223         // AS3 native getter/setter implementations
 224         bool get_fixed() const;
 225         void set_fixed(bool fixed);
 226
 227         // used by Flash code for AMF3 -- note that this is
 228         // the type that the Vector contains, not the Vector itself
 229         // (ie, "int" rather than "Vector<int>")
 230         Traits* getTypeTraits() const;
 231
 232         // AIR needs to be able to get/set the length of an arbitrary
 233         // Vector without knowing its subclass; these simply forward into the
 234         // appropriate calls of the well-typed subclass.
 235         virtual uint32_t getLength() const = 0;
 236         virtual void setLength(uint32_t length) = 0;
 237
 238     protected:
 239
 240         Atom _mapImpl(ScriptObject* callback, Atom thisObject, VectorBaseObject* r, uint32_t len);
 241         Atom _filterImpl(ScriptObject* callback, Atom thisObject, VectorBaseObject* r, uint32_t len);
 242
 243         VectorBaseObject* _newVector();
 244
 245         void checkFixed() const;
 246         void FASTCALL throwFixedError() const;
 247
 248         void atomToValue(Atom atom, int32_t& value);
 249         Atom valueToAtom(const int32_t& value) const;
 250
 251         void atomToValue(Atom atom, uint32_t& value);
 252         Atom valueToAtom(const uint32_t& value) const;
 253
 254         void atomToValue(Atom atom, double& value);
 255         Atom valueToAtom(const double& value) const;
 256
 257         void atomToValue(Atom atom, OpaqueAtom& value);
 258         Atom valueToAtom(const OpaqueAtom& value) const;
 259
 260         enum VectorIndexStatus { kNotNumber, kInvalidNumber, kValidNumber };
 261         VectorIndexStatus getVectorIndex(Atom name, uint32_t& index) const;
 262
 263         GC_DATA_BEGIN(VectorBaseObject)
 264
 265         DRCWB(TypedVectorClassBase*)    GC_POINTER(m_vecClass);
 266         bool                            m_fixed;
 267
 268         GC_DATA_END(VectorBaseObject)
 269     };
 270
 271     // ----------------------------
 272
 273     template<class TLIST>
 274     class TypedVectorObject : public VectorBaseObject
 275     {
 276         template<class OBJ> friend class TypedVectorClass;
 277         template<class TLISTVA> friend class VectorAccessor;
 278
 279     public:
 280         typedef TLIST LIST;
 281
 282     protected:
 283         explicit TypedVectorObject(VTable* ivtable, ScriptObject* delegate);
 284
 285     public:
 286         // overrides
 287         virtual uint32_t getLength() const;
 288         virtual void setLength(uint32_t length);
 289
 290         // AS3 native getter/setter implementations
 291         uint32_t get_length() const;
 292         void set_length(uint32_t newLength);
 293
 294         // AS3 native function implementations
 295         Atom _map(ScriptObject* callback, Atom thisObject);
 296         Atom _filter(ScriptObject* callback, Atom thisObject);
 297         void _reverse();
 298         void _spliceHelper(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, Atom args, uint32_t offset);
 299         uint32_t AS3_push(Atom* argv, int argc);
 300         typename TLIST::TYPE AS3_pop();
 301         uint32_t AS3_unshift(Atom* argv, int argc);
 302         typename TLIST::TYPE AS3_shift();
 303
 304         // ScriptObject method overrides
 305         virtual bool hasAtomProperty(Atom name) const;
 306         virtual Atom getAtomProperty(Atom name) const;
 307         virtual void setAtomProperty(Atom name, Atom value);
 308         virtual bool hasUintProperty(uint32_t index) const;
 309         virtual Atom getUintProperty(uint32_t index) const;
 310         virtual void setUintProperty(uint32_t index, Atom value);
 311         virtual Atom nextName(int index);
 312         virtual Atom nextValue(int index);
 313         virtual int nextNameIndex(int index);
 314
 315         // "fast" methods that don't range-check in nondebug builds
 316         // and are inlined; for internal use by various bits of Flash glue code
 317         typename TLIST::TYPE getUintPropertyFast(uint32_t index) const;
 318         void setUintPropertyFast(uint32_t index, typename TLIST::TYPE value);
 319
 320         // JIT helpers -- not for public use!
 321         // (declared public only to avoid a painful 'friend' declaration)
 322         typename TLIST::TYPE _getNativeIntProperty(int32_t index) const;
 323         void _setNativeIntProperty(int32_t index, typename TLIST::TYPE value);
 324         typename TLIST::TYPE _getNativeUintProperty(uint32_t index) const;
 325         void _setNativeUintProperty(uint32_t index, typename TLIST::TYPE value);
 326         bool _hasUintProperty(uint32_t index) const;
 327         Atom _getUintProperty(uint32_t index) const;
 328         void _setUintProperty(uint32_t index, Atom value);
 329         Atom _getIntProperty(int32_t index) const;
 330         void _setIntProperty(int32_t index, Atom value);
 331
 332 #ifdef DEBUGGER
 333         virtual uint64_t bytesUsed() const;
 334 #endif
 335
 336     private:
 337
 338         void FASTCALL throwRangeError(uint32_t index) const;
 339
 340         uint32_t checkReadIndex_u(uint32_t index) const;
 341         uint32_t checkWriteIndex_u(uint32_t index) const;
 342
 343         // variant of _spliceHelper with explicit array of Atom.
 344         // (Not exposed to AS3.)
 345         // Note:
 346         //      _splice(0, 1, 0, &foo)           == Array.unshift(foo)
 347         //      _splice(this.length, 1, 0, &foo) == Array.push(foo)
 348         void _splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const Atom* argv);
 349
 350         // _spliceHelper for when we already know that we have an object that is *not* of our Vector type.
 351         void _spliceHelper_so(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, ScriptObject* so_args, uint32_t offset);
 352
 353     public:
 354         virtual bool gcTrace(MMgc::GC* gc, size_t cursor)
 355         {
 356             (void)cursor;
 357             VectorBaseObject::gcTrace(gc, 0);
 358             m_list.gcTrace(gc);
 359             return false;
 360         }
 361
 362     private:
 363         TLIST                           m_list;
 364     };
 365
 366     // Some code internal to Flash/AIR needs to directly get/set the contents of Vectors;
 367     // this class provides an implicit lock/unlock mechanism. We guarantee that
 368     // the value returned by addr() is valid for reading/writing for the lifespan of
 369     // the VectorAccessor (but only for entries 0...get_length()-1, of course).
 370     // length() is identical to VectorObject::get_length() but is provided here for symmetry.
 371     // This should obviously only be used in cases where performance is critical, or
 372     // other circumstances requires it (eg, to pass an array of numbers to a GPU
 373     // without intermediate copying). Note that it is explicitly legal to pass
 374     // a NULL VectorObject to the ctor (which will cause addr() to also return NULL
 375     // and length() to return 0). This class must be used only on the stack.
 376     template<class TLIST>
 377     class VectorAccessor
 378     {
 379     public:
 380         explicit VectorAccessor(TypedVectorObject<TLIST>* v);
 381         typename TLIST::TYPE* addr();
 382         uint32_t length();
 383
 384     private:
 385         TypedVectorObject<TLIST>* m_vector;
 386
 387     private:
 388         void* operator new(size_t size);                                        // unimplemented
 389     };
 390
 391     // ----------------------------
 392
 393     class GC_AS3_EXACT(IntVectorObject, TypedVectorObject< DataList<int32_t> >)
 394     {
 395     protected:
 396         explicit IntVectorObject(VTable* ivtable, ScriptObject* delegate);
 397
 398     public:
 399         REALLY_INLINE static IntVectorObject* create(MMgc::GC* gc, VTable* ivtable, ScriptObject* delegate)
 400         {
 401             return new (gc, MMgc::kExact, ivtable->getExtraSize()) IntVectorObject(ivtable, delegate);
 402         }
 403
 404         // AS3 native function implementations
 405         IntVectorObject* newThisType();
 406
 407     // ------------------------ DATA SECTION BEGIN
 408     private:
 409         GC_NO_DATA(IntVectorObject)
 410
 411         DECLARE_SLOTS_IntVectorObject;
 412     // ------------------------ DATA SECTION END
 413     };
 414     typedef VectorAccessor< DataList<int32_t> > IntVectorAccessor;
 415
 416     // ----------------------------
 417
 418     class GC_AS3_EXACT(UIntVectorObject, TypedVectorObject< DataList<uint32_t> >)
 419     {
 420     protected:
 421         explicit UIntVectorObject(VTable* ivtable, ScriptObject* delegate);
 422
 423     public:
 424         REALLY_INLINE static UIntVectorObject* create(MMgc::GC* gc, VTable* ivtable, ScriptObject* delegate)
 425         {
 426             return new (gc, MMgc::kExact, ivtable->getExtraSize()) UIntVectorObject(ivtable, delegate);
 427         }
 428
 429         // AS3 native function implementations
 430         UIntVectorObject* newThisType();
 431
 432     // ------------------------ DATA SECTION BEGIN
 433     private:
 434         GC_NO_DATA(UIntVectorObject)
 435
 436         DECLARE_SLOTS_UIntVectorObject;
 437     // ------------------------ DATA SECTION END
 438     };
 439     typedef VectorAccessor< DataList<uint32_t> > UIntVectorAccessor;
 440
 441     // ----------------------------
 442
 443     class GC_AS3_EXACT(DoubleVectorObject, TypedVectorObject< DataList<double> >)
 444     {
 445     protected:
 446         explicit DoubleVectorObject(VTable* ivtable, ScriptObject* delegate);
 447
 448     public:
 449         REALLY_INLINE static DoubleVectorObject* create(MMgc::GC* gc, VTable* ivtable, ScriptObject* delegate)
 450         {
 451             return new (gc, MMgc::kExact, ivtable->getExtraSize()) DoubleVectorObject(ivtable, delegate);
 452         }
 453
 454         // AS3 native function implementations
 455         DoubleVectorObject* newThisType();
 456
 457     // ------------------------ DATA SECTION BEGIN
 458     private:
 459         GC_NO_DATA(DoubleVectorObject)
 460
 461         DECLARE_SLOTS_DoubleVectorObject;
 462     // ------------------------ DATA SECTION END
 463     };
 464     typedef VectorAccessor< DataList<double> > DoubleVectorAccessor;
 465
 466     // ----------------------------
 467
 468     class GC_AS3_EXACT(ObjectVectorObject, TypedVectorObject< AtomList >)
 469     {
 470     protected:
 471         explicit ObjectVectorObject(VTable* ivtable, ScriptObject* delegate);
 472
 473     public:
 474         REALLY_INLINE static ObjectVectorObject* create(MMgc::GC* gc, VTable* ivtable, ScriptObject* delegate)
 475         {
 476             return new (gc, MMgc::kExact, ivtable->getExtraSize()) ObjectVectorObject(ivtable, delegate);
 477         }
 478
 479         // AS3 native function implementations
 480         ObjectVectorObject* newThisType();
 481
 482     // ------------------------ DATA SECTION BEGIN
 483     private:
 484         GC_NO_DATA(ObjectVectorObject)
 485
 486         DECLARE_SLOTS_ObjectVectorObject;
 487     // ------------------------ DATA SECTION END
 488     };
 489     // This is explicitly NOT provided, as
 490     // (1) there's currently no need for it, and
 491     // (2) it would require WB hackery on the part of the user, which is error-prone
 492     //typedef VectorAccessor<Atom> ObjectVectorAccessor;
 493
 494     // ----------------------------
 495 }
 496
 497 #endif /* __avmplus_VectorClass__ */