core/avmplusList-inlines.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 #ifndef __avmplus_List_inlines__
  41 #define __avmplus_List_inlines__
  42
  43 namespace avmplus
  44 {
  45     template<>
  46     REALLY_INLINE bool TracedListData<Atom>::gcTrace(MMgc::GC* gc, size_t cursor)
  47     {
  48         const size_t work_increment = 2000/sizeof(void*);
  49         const size_t work_count = len;
  50         if (cursor * work_increment >= work_count)
  51             return false;
  52
  53         size_t work = work_increment;
  54         bool more = true;
  55         if ((cursor + 1) * work_increment >= work_count)
  56         {
  57             work = work_count - (cursor * work_increment);
  58             more = false;
  59         }
  60
  61         gc->TraceAtoms(entries + (cursor*work_increment), work);
  62         return more;
  63     }
  64
  65     template<class T>
  66     inline bool TracedListData<T>::gcTrace(MMgc::GC* gc, size_t cursor)
  67     {
  68         const size_t work_increment = 2000/sizeof(void*);
  69         const size_t work_count = len;
  70         if (cursor * work_increment >= work_count)
  71             return false;
  72
  73         size_t work = work_increment;
  74         bool more = true;
  75         if ((cursor + 1) * work_increment >= work_count)
  76         {
  77             work = work_count - (cursor * work_increment);
  78             more = false;
  79         }
  80
  81         gc->TraceLocations(entries + (cursor*work_increment), work);
  82         return more;
  83     }
  84
  85     // ----------------------------
  86
  87     template<class T>
  88     REALLY_INLINE /*static*/ void DataListHelper<T>::wbData(const void* /*container*/, LISTDATA** address, LISTDATA* data)
  89     {
  90         *address = data;
  91     }
  92
  93     template<class T>
  94     REALLY_INLINE /*static*/ typename DataListHelper<T>::TYPE DataListHelper<T>::load(LISTDATA* data, uint32_t index)
  95     {
  96         AvmAssert(data != NULL);
  97         return data->entries[index];
  98     }
  99
 100     template<class T>
 101     REALLY_INLINE /*static*/ void DataListHelper<T>::store(LISTDATA* data, uint32_t index, TYPE value)
 102     {
 103         AvmAssert(data != NULL);
 104         data->entries[index] = value;
 105     }
 106
 107     template<class T>
 108     REALLY_INLINE /*static*/ void DataListHelper<T>::storeInEmpty(LISTDATA* data, uint32_t index, TYPE value)
 109     {
 110         AvmAssert(data != NULL);
 111         // This is commented out because it's not necessary for safety of a DataList,
 112         // and it can generate an assert in List::insert(), which uses storeInEmpty() for efficiency;
 113         // since DataListHelper::moveRange doesn't zero out the cleared space we could get this
 114         // assertion firing. Better to neuter this assertion than add a unnecessary zeroing-out
 115         // to moveRange() just to pacify it.
 116         // AvmAssert(data->entries[index] == 0);
 117         data->entries[index] = value;
 118     }
 119
 120     template<class T>
 121     REALLY_INLINE /*static*/ void DataListHelper<T>::clearRange(LISTDATA* data, uint32_t start, uint32_t count)
 122     {
 123         AvmAssert(count > 0);
 124         VMPI_memset(&data->entries[start], 0, count*sizeof(T));
 125     }
 126
 127     template<class T>
 128     REALLY_INLINE /*static*/ void DataListHelper<T>::moveRange(LISTDATA* data, uint32_t srcStart, uint32_t dstStart, uint32_t count)
 129     {
 130         VMPI_memmove(&data->entries[dstStart], &data->entries[srcStart], count * sizeof(T));
 131     }
 132
 133     template<class T>
 134     REALLY_INLINE /*static*/ void DataListHelper<T>::gcTrace(MMgc::GC* gc, LISTDATA** loc)
 135     {
 136         AvmAssert(!gc->IsPointerToGCPage(*loc));
 137         (void)gc; (void)loc;
 138     }
 139
 140     // ----------------------------
 141
 142     REALLY_INLINE /*static*/ void GCListHelper::wbData(const void* container, LISTDATA** address, LISTDATA* data)
 143     {
 144         MMgc::GC* const gc = data->gc();
 145         if (gc->IsPointerToGCPage(container))
 146         {
 147             WB(gc, gc->FindBeginningFast(container), address, data);
 148         }
 149         else
 150         {
 151             *address = data;
 152         }
 153     }
 154
 155     REALLY_INLINE /*static*/ GCListHelper::TYPE GCListHelper::load(LISTDATA* data, uint32_t index)
 156     {
 157         AvmAssert(data != NULL);
 158         return data->entries[index];
 159     }
 160
 161     REALLY_INLINE /*static*/ void GCListHelper::store(LISTDATA* data, uint32_t index, TYPE value)
 162     {
 163         AvmAssert(data != NULL);
 164         WB(data->gc(), data, &data->entries[index], value);
 165     }
 166
 167     REALLY_INLINE /*static*/ void GCListHelper::storeInEmpty(LISTDATA* data, uint32_t index, TYPE value)
 168     {
 169         AvmAssert(data != NULL);
 170         AvmAssert(data->entries[index] == 0);
 171         WB(data->gc(), data, &data->entries[index], value);
 172     }
 173
 174     REALLY_INLINE /*static*/ void GCListHelper::clearRange(LISTDATA* data, uint32_t start, uint32_t count)
 175     {
 176         AvmAssert(count > 0);
 177         VMPI_memset(&data->entries[start], 0, count*sizeof(MMgc::GCObject*));
 178     }
 179
 180     REALLY_INLINE /*static*/ void GCListHelper::moveRange(LISTDATA* data, uint32_t srcStart, uint32_t dstStart, uint32_t count)
 181     {
 182         AvmAssert(data != NULL);
 183         data->gc()->movePointersWithinBlock((void**)data,
 184                                            uint32_t((char*)(&data->entries[dstStart]) - (char*)data),
 185                                            uint32_t((char*)(&data->entries[srcStart]) - (char*)data),
 186                                            count,
 187                                            /*zeroEmptied*/ true);
 188     }
 189
 190     REALLY_INLINE /*static*/ void GCListHelper::gcTrace(MMgc::GC* gc, LISTDATA** loc)
 191     {
 192         gc->TraceLocation(loc);
 193     }
 194
 195     // ----------------------------
 196
 197     REALLY_INLINE /*static*/ void RCListHelper::wbData(const void* container, LISTDATA** address, LISTDATA* data)
 198     {
 199         MMgc::GC* const gc = data->gc();
 200         if (gc->IsPointerToGCPage(container))
 201         {
 202             WB(gc, gc->FindBeginningFast(container), address, data);
 203         }
 204         else
 205         {
 206             *address = data;
 207         }
 208     }
 209
 210     REALLY_INLINE /*static*/ RCListHelper::TYPE RCListHelper::load(LISTDATA* data, uint32_t index)
 211     {
 212         AvmAssert(data != NULL);
 213         return data->entries[index];
 214     }
 215
 216     REALLY_INLINE /*static*/ void RCListHelper::store(LISTDATA* data, uint32_t index, TYPE value)
 217     {
 218         AvmAssert(data != NULL);
 219         WBRC(data->gc(), data, &data->entries[index], value);
 220     }
 221
 222     REALLY_INLINE /*static*/ void RCListHelper::storeInEmpty(LISTDATA* data, uint32_t index, TYPE value)
 223     {
 224         AvmAssert(data != NULL);
 225         AvmAssert(data->entries[index] == 0);
 226         // We can't use WriteBarrierRC_ctor here, as it will call GetGC() on the address, which might be
 227         // wrong if the allocation is large. Instead, replicate the necessary code inline (ugh) in
 228         // the tradition of AvmCore::atomWriteBarrier_ctor...
 229         if (value)
 230         {
 231             if (data->gc()->BarrierActive())
 232                 data->gc()->InlineWriteBarrierTrap(data);
 233             value->IncrementRef();
 234             data->entries[index] = value;
 235         }
 236     }
 237
 238     REALLY_INLINE /*static*/ void RCListHelper::clearRange(LISTDATA* data, uint32_t start, uint32_t count)
 239     {
 240         AvmAssert(count > 0);
 241         for (uint32_t i = start, n = start + count; i < n; i++)
 242         {
 243             if (data->entries[i])
 244             {
 245                 data->entries[i]->DecrementRef();
 246                 data->entries[i] = 0;
 247             }
 248         }
 249     }
 250
 251     REALLY_INLINE /*static*/ void RCListHelper::moveRange(LISTDATA* data, uint32_t srcStart, uint32_t dstStart, uint32_t count)
 252     {
 253         AvmAssert(data != NULL);
 254         data->gc()->movePointersWithinBlock((void**)data,
 255                                            uint32_t((char*)(&data->entries[dstStart]) - (char*)data),
 256                                            uint32_t((char*)(&data->entries[srcStart]) - (char*)data),
 257                                            count,
 258                                            /*zeroEmptied*/ true);
 259     }
 260
 261     REALLY_INLINE /*static*/ void RCListHelper::gcTrace(MMgc::GC* gc, LISTDATA** loc)
 262     {
 263         gc->TraceLocation(loc);
 264     }
 265
 266     // ----------------------------
 267
 268     REALLY_INLINE /*static*/ void AtomListHelper::wbData(const void* container, LISTDATA** address, LISTDATA* data)
 269     {
 270         MMgc::GC* const gc = data->gc();
 271         if (gc->IsPointerToGCPage(container))
 272         {
 273             WB(gc, gc->FindBeginningFast(container), address, data);
 274         }
 275         else
 276         {
 277             *address = data;
 278         }
 279     }
 280
 281     REALLY_INLINE /*static*/ AtomListHelper::TYPE AtomListHelper::load(LISTDATA* data, uint32_t index)
 282     {
 283         AvmAssert(data != NULL);
 284         return data->entries[index];
 285     }
 286
 287     REALLY_INLINE /*static*/ void AtomListHelper::store(LISTDATA* data, uint32_t index, TYPE value)
 288     {
 289         AvmAssert(data != NULL);
 290         AvmCore::atomWriteBarrier(data->gc(), data, &data->entries[index], value);
 291     }
 292
 293     REALLY_INLINE /*static*/ void AtomListHelper::storeInEmpty(LISTDATA* data, uint32_t index, TYPE value)
 294     {
 295         AvmAssert(data != NULL);
 296         // newly-allocated space clears to 0; clearRange() clears to nullObjectAtom.
 297         // Both are "empty" as far as AtomList is concerned.
 298         AvmAssert(data->entries[index] == 0 || data->entries[index] == nullObjectAtom);
 299         AvmCore::atomWriteBarrier_ctor(data->gc(), data, &data->entries[index], value);
 300     }
 301
 302     REALLY_INLINE /*static*/ void AtomListHelper::clearRange(LISTDATA* data, uint32_t start, uint32_t count)
 303     {
 304         AvmAssert(count > 0);
 305         AvmCore::decrementAtomRegion_null(&data->entries[start], count);
 306     }
 307
 308     REALLY_INLINE /*static*/ void AtomListHelper::moveRange(LISTDATA* data, uint32_t srcStart, uint32_t dstStart, uint32_t count)
 309     {
 310         AvmAssert(data != NULL);
 311         data->gc()->movePointersWithinBlock((void**)data,
 312                                            uint32_t((char*)(&data->entries[dstStart]) - (char*)data),
 313                                            uint32_t((char*)(&data->entries[srcStart]) - (char*)data),
 314                                            count,
 315                                            /*zeroEmptied*/ true);
 316     }
 317
 318     REALLY_INLINE /*static*/ void AtomListHelper::gcTrace(MMgc::GC* gc, LISTDATA** loc)
 319     {
 320         gc->TraceLocation(loc);
 321     }
 322
 323     // ----------------------------
 324
 325     REALLY_INLINE /*static*/ void WeakRefListHelper::wbData(const void* container, LISTDATA** address, LISTDATA* data)
 326     {
 327         MMgc::GC* const gc = data->gc();
 328         if (gc->IsPointerToGCPage(container))
 329         {
 330             WB(gc, gc->FindBeginningFast(container), address, data);
 331         }
 332         else
 333         {
 334             *address = data;
 335         }
 336     }
 337
 338     REALLY_INLINE /*static*/ WeakRefListHelper::TYPE WeakRefListHelper::load(LISTDATA* data, uint32_t index)
 339     {
 340         AvmAssert(data != NULL);
 341         MMgc::GCWeakRef* weak = data->entries[index];
 342         return weak ? (TYPE)weak->get() : NULL;
 343     }
 344
 345     REALLY_INLINE /*static*/ void WeakRefListHelper::store(LISTDATA* data, uint32_t index, TYPE value)
 346     {
 347         AvmAssert(data != NULL);
 348         MMgc::GCWeakRef* weak = value ? value->GetWeakRef() : NULL;
 349         WB(data->gc(), data, &data->entries[index], weak);
 350     }
 351
 352     REALLY_INLINE /*static*/ void WeakRefListHelper::storeInEmpty(LISTDATA* data, uint32_t index, TYPE value)
 353     {
 354         AvmAssert(data != NULL);
 355         AvmAssert(data->entries[index] == 0);
 356         store(data, index, value);
 357     }
 358
 359     REALLY_INLINE /*static*/ void WeakRefListHelper::clearRange(LISTDATA* data, uint32_t start, uint32_t count)
 360     {
 361         AvmAssert(count > 0);
 362         VMPI_memset(&data->entries[start], 0, count*sizeof(STORAGE));
 363     }
 364
 365     REALLY_INLINE /*static*/ void WeakRefListHelper::moveRange(LISTDATA* data, uint32_t srcStart, uint32_t dstStart, uint32_t count)
 366     {
 367         AvmAssert(data != NULL);
 368         data->gc()->movePointersWithinBlock((void**)data,
 369                                            uint32_t((char*)(&data->entries[dstStart]) - (char*)data),
 370                                            uint32_t((char*)(&data->entries[srcStart]) - (char*)data),
 371                                            count,
 372                                            /*zeroEmptied*/ true);
 373     }
 374
 375     REALLY_INLINE /*static*/ void WeakRefListHelper::gcTrace(MMgc::GC* gc, LISTDATA** loc)
 376     {
 377         gc->TraceLocation(loc);
 378     }
 379
 380     // ----------------------------
 381
 382     template<class T, class ListHelper>
 383     REALLY_INLINE bool ListImpl<T,ListHelper>::isEmpty() const
 384     {
 385         return m_data->len == 0;
 386     }
 387
 388     template<class T, class ListHelper>
 389     REALLY_INLINE uint32_t ListImpl<T,ListHelper>::length() const
 390     {
 391         return m_data->len;
 392     }
 393
 394     template<class T, class ListHelper>
 395     REALLY_INLINE uint32_t ListImpl<T,ListHelper>::capacity() const
 396     {
 397         return uint32_t((ListHelper::LISTDATA::getSize(m_data) - offsetof(typename ListHelper::LISTDATA, entries)) /
 398                 sizeof(typename ListHelper::STORAGE));
 399     }
 400
 401     template<class T, class ListHelper>
 402     REALLY_INLINE T ListImpl<T,ListHelper>::get(uint32_t index) const
 403     {
 404         AvmAssert(index < m_data->len);
 405         return ListHelper::load(m_data, index);
 406     }
 407
 408     template<class T, class ListHelper>
 409     REALLY_INLINE void ListImpl<T,ListHelper>::replace(uint32_t index, T value)
 410     {
 411         AvmAssert(index < m_data->len);
 412         ListHelper::store(m_data, index, value);
 413     }
 414
 415     template<class T, class ListHelper>
 416     REALLY_INLINE void ListImpl<T,ListHelper>::set(uint32_t index, T value)
 417     {
 418         // Yes, this is worth inlining, according to performance testing.
 419         if (index >= m_data->len)
 420         {
 421             ensureCapacityExtra(index, 1);
 422             m_data->len = index+1;
 423         }
 424         ListHelper::store(m_data, index, value);
 425     }
 426
 427     template<class T, class ListHelper>
 428     REALLY_INLINE T ListImpl<T,ListHelper>::first() const
 429     {
 430         AvmAssert(m_data->len > 0);
 431         return ListHelper::load(m_data, 0);
 432     }
 433
 434     template<class T, class ListHelper>
 435     REALLY_INLINE T ListImpl<T,ListHelper>::last() const
 436     {
 437         AvmAssert(m_data->len > 0);
 438         return ListHelper::load(m_data, m_data->len-1);
 439     }
 440
 441     template<class T, class ListHelper>
 442     REALLY_INLINE T ListImpl<T,ListHelper>::removeFirst()
 443     {
 444         AvmAssert(!isEmpty());
 445         return removeAt(0);
 446     }
 447
 448     template<class T, class ListHelper>
 449     REALLY_INLINE T ListImpl<T,ListHelper>::operator[](uint32_t index) const
 450     {
 451         AvmAssert(index < m_data->len);
 452         return ListHelper::load(m_data, index);
 453     }
 454
 455     template<class T, class ListHelper>
 456     REALLY_INLINE void ListImpl<T,ListHelper>::ensureCapacityExtra(uint32_t cap, uint32_t extra)
 457     {
 458         MMGC_STATIC_ASSERT(0xFFFFFFFF > kListMaxLength);
 459         uint32_t const ncap = (cap > 0xFFFFFFFF - extra) ?  // if true, cap + extra will overflow a uint32_t...
 460                               0xFFFFFFFF :                  // ...in that case, choose a size that will definitely fail in ensureCapacityImpl.
 461                               (cap + extra);
 462
 463         if (ncap > capacity())
 464         {
 465             ensureCapacityImpl(ncap);
 466         }
 467     }
 468
 469     template<class T, class ListHelper>
 470     REALLY_INLINE void ListImpl<T,ListHelper>::ensureCapacity(uint32_t cap)
 471     {
 472         AvmAssert(m_data != NULL);
 473         if (cap > capacity())
 474         {
 475             ensureCapacityImpl(cap);
 476         }
 477     }
 478
 479     template<class T, class ListHelper>
 480     REALLY_INLINE uint64_t ListImpl<T,ListHelper>::bytesUsed() const
 481     {
 482         AvmAssert(m_data != NULL);
 483         return ListHelper::LISTDATA::getSize(m_data);
 484     }
 485
 486     template<class T, class ListHelper>
 487     REALLY_INLINE /*static*/ typename ListHelper::LISTDATA* ListImpl<T,ListHelper>::allocData(MMgc::GC* gc, uint32_t cap)
 488     {
 489         AvmAssert(cap <= kListMaxLength);
 490         typename ListHelper::LISTDATA* newData = ListHelper::LISTDATA::create(gc, cap);
 491         newData->len = 0;
 492         newData->set_gc(gc);
 493         return newData;
 494     }
 495
 496     template<class T, class ListHelper>
 497     REALLY_INLINE void ListImpl<T,ListHelper>::skipDestructor()
 498     {
 499         // Note that we explicitly do not attempt to free the data here;
 500         // this method should only be called in situations where we
 501         // know that MMGC has already been torn down, thus an attempt
 502         // to free the data would be unsafe.
 503         m_data = NULL;
 504     }
 505
 506     // ----------------------------
 507
 508
 509     template<class T>
 510     REALLY_INLINE GCList<T>::GCList(MMgc::GC* gc, uint32_t capacity, const TYPE* args)
 511         : m_list(gc, capacity, (MMgc::GCObject* const*)args)
 512     {
 513         MMGC_STATIC_ASSERT((TypeSniffer<T>::isGCObject::value == true ||
 514                             TypeSniffer<T>::isGCFinalizedObject::value == true ||
 515                             TypeSniffer<T>::isGCTraceableObject::value == true) &&
 516                             TypeSniffer<T>::isRCObject::value == false);
 517         MMGC_STATIC_ASSERT(TypeSniffer<T>::isNonPointer::value == true);
 518     }
 519
 520     template<class T>
 521     REALLY_INLINE bool GCList<T>::isEmpty() const
 522     {
 523         return m_list.isEmpty();
 524     }
 525
 526     template<class T>
 527     REALLY_INLINE uint32_t GCList<T>::length() const
 528     {
 529         return m_list.length();
 530     }
 531
 532     template<class T>
 533     REALLY_INLINE uint32_t GCList<T>::capacity() const
 534     {
 535         return m_list.capacity();
 536     }
 537
 538     template<class T>
 539     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::get(uint32_t index) const
 540     {
 541         return reinterpret_cast<TYPE>(m_list.get(index));
 542     }
 543
 544     template<class T>
 545     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::first() const
 546     {
 547         return reinterpret_cast<TYPE>(m_list.first());
 548     }
 549
 550     template<class T>
 551     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::last() const
 552     {
 553         return reinterpret_cast<TYPE>(m_list.last());
 554     }
 555
 556     template<class T>
 557     REALLY_INLINE void GCList<T>::replace(uint32_t index, TYPE value)
 558     {
 559         m_list.replace(index, reinterpret_cast<MMgc::GCObject*>(value));
 560     }
 561
 562     template<class T>
 563     REALLY_INLINE void GCList<T>::set(uint32_t index, TYPE value)
 564     {
 565         m_list.set(index, reinterpret_cast<MMgc::GCObject*>(value));
 566     }
 567
 568     template<class T>
 569     REALLY_INLINE void GCList<T>::add(TYPE value)
 570     {
 571         m_list.add(reinterpret_cast<MMgc::GCObject*>(value));
 572     }
 573
 574     template<class T>
 575     REALLY_INLINE void GCList<T>::add(const GCList<T>& that)
 576     {
 577         m_list.add(*(const LIST*)&that);
 578     }
 579
 580     template<class T>
 581     REALLY_INLINE void GCList<T>::insert(uint32_t index, TYPE value, uint32_t count)
 582     {
 583         m_list.insert(index, reinterpret_cast<MMgc::GCObject*>(value), count);
 584     }
 585
 586     template<class T>
 587     REALLY_INLINE void GCList<T>::insert(uint32_t index, const TYPE* args, uint32_t argc)
 588     {
 589         m_list.insert(index, args, argc);
 590     }
 591
 592     template<class T>
 593     REALLY_INLINE void GCList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const TYPE* args)
 594     {
 595         m_list.splice(insertPoint, insertCount, deleteCount, args);
 596     }
 597
 598     template<class T>
 599     REALLY_INLINE void GCList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const GCList<T>& args, uint32_t argsOffset)
 600     {
 601         m_list.splice(insertPoint, insertCount, deleteCount, args, argsOffset);
 602     }
 603
 604     template<class T>
 605     REALLY_INLINE void GCList<T>::reverse()
 606     {
 607         m_list.reverse();
 608     }
 609
 610     template<class T>
 611     REALLY_INLINE void GCList<T>::clear()
 612     {
 613         m_list.clear();
 614     }
 615
 616     template<class T>
 617     REALLY_INLINE int32_t GCList<T>::indexOf(TYPE value) const
 618     {
 619         return m_list.indexOf(reinterpret_cast<MMgc::GCObject*>(value));
 620     }
 621
 622     template<class T>
 623     REALLY_INLINE int32_t GCList<T>::lastIndexOf(TYPE value) const
 624     {
 625         return m_list.lastIndexOf(reinterpret_cast<MMgc::GCObject*>(value));
 626     }
 627
 628     template<class T>
 629     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::removeAt(uint32_t index)
 630     {
 631         return reinterpret_cast<TYPE>(m_list.removeAt(index));
 632     }
 633
 634     template<class T>
 635     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::removeFirst()
 636     {
 637         return reinterpret_cast<TYPE>(m_list.removeFirst());
 638     }
 639
 640     template<class T>
 641     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::removeLast()
 642     {
 643         return reinterpret_cast<TYPE>(m_list.removeLast());
 644     }
 645
 646     template<class T>
 647     REALLY_INLINE typename GCList<T>::TYPE GCList<T>::operator[](uint32_t index) const
 648     {
 649         return reinterpret_cast<TYPE>(m_list[index]);
 650     }
 651
 652     template<class T>
 653     REALLY_INLINE void GCList<T>::ensureCapacity(uint32_t cap)
 654     {
 655         m_list.ensureCapacity(cap);
 656     }
 657
 658     template<class T>
 659     REALLY_INLINE uint64_t GCList<T>::bytesUsed() const
 660     {
 661         return m_list.bytesUsed();
 662     }
 663
 664     template<class T>
 665     REALLY_INLINE void GCList<T>::skipDestructor()
 666     {
 667         m_list.skipDestructor();
 668     }
 669
 670     template<class T>
 671     REALLY_INLINE void GCList<T>::gcTrace(MMgc::GC* gc)
 672     {
 673         m_list.gcTrace(gc);
 674     }
 675
 676     // ----------------------------
 677
 678     template<class T>
 679     REALLY_INLINE RCList<T>::RCList(MMgc::GC* gc, uint32_t capacity, const TYPE* args)
 680         : m_list(gc, capacity, (MMgc::RCObject* const*)args)
 681     {
 682         MMGC_STATIC_ASSERT(TypeSniffer<T>::isRCObject::value == true);
 683         MMGC_STATIC_ASSERT(TypeSniffer<T>::isNonPointer::value == true);
 684     }
 685
 686     template<class T>
 687     REALLY_INLINE bool RCList<T>::isEmpty() const
 688     {
 689         return m_list.isEmpty();
 690     }
 691
 692     template<class T>
 693     REALLY_INLINE uint32_t RCList<T>::length() const
 694     {
 695         return m_list.length();
 696     }
 697
 698     template<class T>
 699     REALLY_INLINE uint32_t RCList<T>::capacity() const
 700     {
 701         return m_list.capacity();
 702     }
 703
 704     template<class T>
 705     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::get(uint32_t index) const
 706     {
 707         return reinterpret_cast<TYPE>(m_list.get(index));
 708     }
 709
 710     template<class T>
 711     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::first() const
 712     {
 713         return reinterpret_cast<TYPE>(m_list.first());
 714     }
 715
 716     template<class T>
 717     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::last() const
 718     {
 719         return reinterpret_cast<TYPE>(m_list.last());
 720     }
 721
 722     template<class T>
 723     REALLY_INLINE void RCList<T>::replace(uint32_t index, TYPE value)
 724     {
 725         m_list.replace(index, value);
 726     }
 727
 728     template<class T>
 729     REALLY_INLINE void RCList<T>::set(uint32_t index, TYPE value)
 730     {
 731         m_list.set(index, value);
 732     }
 733
 734     template<class T>
 735     REALLY_INLINE void RCList<T>::add(TYPE value)
 736     {
 737         m_list.add(value);
 738     }
 739
 740     template<class T>
 741     REALLY_INLINE void RCList<T>::add(const RCList<T>& that)
 742     {
 743         m_list.add(*(const LIST*)&that);
 744     }
 745
 746     template<class T>
 747     REALLY_INLINE void RCList<T>::insert(uint32_t index, TYPE value, uint32_t count)
 748     {
 749         m_list.insert(index, value, count);
 750     }
 751
 752     template<class T>
 753     REALLY_INLINE void RCList<T>::insert(uint32_t index, const TYPE* args, uint32_t argc)
 754     {
 755         m_list.insert(index, args, argc);
 756     }
 757
 758     template<class T>
 759     REALLY_INLINE void RCList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const TYPE* args)
 760     {
 761         m_list.splice(insertPoint, insertCount, deleteCount, args);
 762     }
 763
 764     template<class T>
 765     REALLY_INLINE void RCList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const RCList<T>& args, uint32_t argsOffset)
 766     {
 767         m_list.splice(insertPoint, insertCount, deleteCount, args, argsOffset);
 768     }
 769
 770     template<class T>
 771     REALLY_INLINE void RCList<T>::reverse()
 772     {
 773         m_list.reverse();
 774     }
 775
 776     template<class T>
 777     REALLY_INLINE void RCList<T>::clear()
 778     {
 779         m_list.clear();
 780     }
 781
 782     template<class T>
 783     REALLY_INLINE int32_t RCList<T>::indexOf(TYPE value) const
 784     {
 785         return m_list.indexOf(value);
 786     }
 787
 788     template<class T>
 789     REALLY_INLINE int32_t RCList<T>::lastIndexOf(TYPE value) const
 790     {
 791         return m_list.lastIndexOf(value);
 792     }
 793
 794     template<class T>
 795     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::removeAt(uint32_t index)
 796     {
 797         return reinterpret_cast<TYPE>(m_list.removeAt(index));
 798     }
 799
 800     template<class T>
 801     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::removeFirst()
 802     {
 803         return reinterpret_cast<TYPE>(m_list.removeFirst());
 804     }
 805
 806     template<class T>
 807     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::removeLast()
 808     {
 809         return reinterpret_cast<TYPE>(m_list.removeLast());
 810     }
 811
 812     template<class T>
 813     REALLY_INLINE typename RCList<T>::TYPE RCList<T>::operator[](uint32_t index) const
 814     {
 815         return reinterpret_cast<TYPE>(m_list[index]);
 816     }
 817
 818     template<class T>
 819     REALLY_INLINE void RCList<T>::ensureCapacity(uint32_t cap)
 820     {
 821         m_list.ensureCapacity(cap);
 822     }
 823
 824     template<class T>
 825     REALLY_INLINE uint64_t RCList<T>::bytesUsed() const
 826     {
 827         return m_list.bytesUsed();
 828     }
 829
 830     template<class T>
 831     REALLY_INLINE void RCList<T>::skipDestructor()
 832     {
 833         m_list.skipDestructor();
 834     }
 835
 836     template<class T>
 837     REALLY_INLINE void RCList<T>::gcTrace(MMgc::GC* gc)
 838     {
 839         m_list.gcTrace(gc);
 840     }
 841
 842
 843     // ----------------------------
 844
 845     template<class T>
 846     REALLY_INLINE UnmanagedPointerList<T>::UnmanagedPointerList(MMgc::GC* gc, uint32_t capacity, const T* args)
 847         : m_list(gc, capacity, (const UnmanagedPointer*)args)
 848     {
 849         // We must not be a GC/RCObject.
 850         MMGC_STATIC_ASSERT(TypeSniffer<T>::isGCObject::value == false &&
 851                             TypeSniffer<T>::isGCFinalizedObject::value == false &&
 852                             TypeSniffer<T>::isRCObject::value == false &&
 853                             TypeSniffer<T>::isGCTraceableObject::value == false);
 854
 855         // BUT we MUST be a pointer type.
 856         MMGC_STATIC_ASSERT(TypeSniffer<T>::isNonPointer::value == false);
 857     }
 858
 859     template<class T>
 860     REALLY_INLINE bool UnmanagedPointerList<T>::isEmpty() const
 861     {
 862         return m_list.isEmpty();
 863     }
 864
 865     template<class T>
 866     REALLY_INLINE uint32_t UnmanagedPointerList<T>::length() const
 867     {
 868         return m_list.length();
 869     }
 870
 871     template<class T>
 872     REALLY_INLINE uint32_t UnmanagedPointerList<T>::capacity() const
 873     {
 874         return m_list.capacity();
 875     }
 876
 877     template<class T>
 878     REALLY_INLINE T UnmanagedPointerList<T>::get(uint32_t index) const
 879     {
 880         return (T)m_list.get(index);
 881     }
 882
 883     template<class T>
 884     REALLY_INLINE T UnmanagedPointerList<T>::first() const
 885     {
 886         return (T)m_list.first();
 887     }
 888
 889     template<class T>
 890     REALLY_INLINE T UnmanagedPointerList<T>::last() const
 891     {
 892         return (T)m_list.last();
 893     }
 894
 895     template<class T>
 896     REALLY_INLINE void UnmanagedPointerList<T>::replace(uint32_t index, T value)
 897     {
 898         m_list.replace(index, (UnmanagedPointer)value);
 899     }
 900
 901     template<class T>
 902     REALLY_INLINE void UnmanagedPointerList<T>::set(uint32_t index, T value)
 903     {
 904         m_list.set(index, (UnmanagedPointer)value);
 905     }
 906
 907     template<class T>
 908     REALLY_INLINE void UnmanagedPointerList<T>::add(T value)
 909     {
 910         m_list.add((UnmanagedPointer)value);
 911     }
 912
 913     template<class T>
 914     REALLY_INLINE void UnmanagedPointerList<T>::add(const UnmanagedPointerList<T>& that)
 915     {
 916         m_list.add(*(const LIST*)&that);
 917     }
 918
 919     template<class T>
 920     REALLY_INLINE void UnmanagedPointerList<T>::insert(uint32_t index, T value, uint32_t count)
 921     {
 922         m_list.insert(index, (UnmanagedPointer)value, count);
 923     }
 924
 925     template<class T>
 926     REALLY_INLINE void UnmanagedPointerList<T>::insert(uint32_t index, const T* args, uint32_t argc)
 927     {
 928         m_list.insert(index, args, argc);
 929     }
 930
 931     template<class T>
 932     REALLY_INLINE void UnmanagedPointerList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const T* args)
 933     {
 934         m_list.splice(insertPoint, insertCount, deleteCount, args);
 935     }
 936
 937     template<class T>
 938     REALLY_INLINE void UnmanagedPointerList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const UnmanagedPointerList<T>& args, uint32_t argsOffset)
 939     {
 940         m_list.splice(insertPoint, insertCount, deleteCount, args, argsOffset);
 941     }
 942
 943     template<class T>
 944     REALLY_INLINE void UnmanagedPointerList<T>::reverse()
 945     {
 946         m_list.reverse();
 947     }
 948
 949     template<class T>
 950     REALLY_INLINE void UnmanagedPointerList<T>::clear()
 951     {
 952         m_list.clear();
 953     }
 954
 955     template<class T>
 956     REALLY_INLINE int32_t UnmanagedPointerList<T>::indexOf(T value) const
 957     {
 958         return m_list.indexOf((UnmanagedPointer)value);
 959     }
 960
 961     template<class T>
 962     REALLY_INLINE int32_t UnmanagedPointerList<T>::lastIndexOf(T value) const
 963     {
 964         return m_list.lastIndexOf((UnmanagedPointer)value);
 965     }
 966
 967     template<class T>
 968     REALLY_INLINE T UnmanagedPointerList<T>::removeAt(uint32_t index)
 969     {
 970         return (T)m_list.removeAt(index);
 971     }
 972
 973     template<class T>
 974     REALLY_INLINE T UnmanagedPointerList<T>::removeFirst()
 975     {
 976         return (T)m_list.removeFirst();
 977     }
 978
 979     template<class T>
 980     REALLY_INLINE T UnmanagedPointerList<T>::removeLast()
 981     {
 982         return (T)m_list.removeLast();
 983     }
 984
 985     template<class T>
 986     REALLY_INLINE T UnmanagedPointerList<T>::operator[](uint32_t index) const
 987     {
 988         return (T)m_list[index];
 989     }
 990
 991     template<class T>
 992     REALLY_INLINE void UnmanagedPointerList<T>::ensureCapacity(uint32_t cap)
 993     {
 994         m_list.ensureCapacity(cap);
 995     }
 996
 997     template<class T>
 998     REALLY_INLINE uint64_t UnmanagedPointerList<T>::bytesUsed() const
 999     {
1000         return m_list.bytesUsed();
1001     }
1002
1003     template<class T>
1004     REALLY_INLINE void UnmanagedPointerList<T>::skipDestructor()
1005     {
1006         m_list.skipDestructor();
1007     }
1008
1009     template<class T>
1010     REALLY_INLINE void UnmanagedPointerList<T>::gcTrace(MMgc::GC* gc)
1011     {
1012         m_list.gcTrace(gc);
1013     }
1014
1015     // ----------------------------
1016
1017     template<class T>
1018     REALLY_INLINE WeakRefList<T>::WeakRefList(MMgc::GC* gc, uint32_t capacity, const TYPE* args)
1019         : m_list(gc, capacity, (MMgc::GCObject* const*)args)
1020     {
1021         MMGC_STATIC_ASSERT(TypeSniffer<T>::isGCObject::value ||
1022                             TypeSniffer<T>::isGCFinalizedObject::value ||
1023                             TypeSniffer<T>::isRCObject::value ||
1024                             TypeSniffer<T>::isGCTraceableObject::value);
1025         MMGC_STATIC_ASSERT(TypeSniffer<T>::isNonPointer::value == true);
1026     }
1027
1028     template<class T>
1029     REALLY_INLINE bool WeakRefList<T>::isEmpty() const
1030     {
1031         return m_list.isEmpty();
1032     }
1033
1034     template<class T>
1035     REALLY_INLINE uint32_t WeakRefList<T>::length() const
1036     {
1037         return m_list.length();
1038     }
1039
1040     template<class T>
1041     REALLY_INLINE uint32_t WeakRefList<T>::capacity() const
1042     {
1043         return m_list.capacity();
1044     }
1045
1046     template<class T>
1047     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::get(uint32_t index) const
1048     {
1049         return reinterpret_cast<TYPE>(m_list.get(index));
1050     }
1051
1052     template<class T>
1053     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::first() const
1054     {
1055         return reinterpret_cast<TYPE>(m_list.first());
1056     }
1057
1058     template<class T>
1059     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::last() const
1060     {
1061         return reinterpret_cast<TYPE>(m_list.last());
1062     }
1063
1064     template<class T>
1065     REALLY_INLINE void WeakRefList<T>::replace(uint32_t index, TYPE value)
1066     {
1067         m_list.replace(index, to_gc(value));
1068     }
1069
1070     template<class T>
1071     REALLY_INLINE void WeakRefList<T>::set(uint32_t index, TYPE value)
1072     {
1073         m_list.set(index, reinterpret_cast<MMgc::GCObject*>(value));
1074     }
1075
1076     template<class T>
1077     REALLY_INLINE void WeakRefList<T>::add(TYPE value)
1078     {
1079         m_list.add(reinterpret_cast<MMgc::GCObject*>(value));
1080     }
1081
1082     template<class T>
1083     REALLY_INLINE void WeakRefList<T>::add(const WeakRefList<T>& that)
1084     {
1085         m_list.add(*(const LIST*)&that);
1086     }
1087
1088     template<class T>
1089     REALLY_INLINE void WeakRefList<T>::insert(uint32_t index, TYPE value, uint32_t count)
1090     {
1091         m_list.insert(index, reinterpret_cast<MMgc::GCObject*>(value), count);
1092     }
1093
1094     template<class T>
1095     REALLY_INLINE void WeakRefList<T>::insert(uint32_t index, const TYPE* args, uint32_t argc)
1096     {
1097         m_list.insert(index, args, argc);
1098     }
1099
1100     template<class T>
1101     REALLY_INLINE void WeakRefList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const TYPE* args)
1102     {
1103         m_list.splice(insertPoint, insertCount, deleteCount, args);
1104     }
1105
1106     template<class T>
1107     REALLY_INLINE void WeakRefList<T>::splice(uint32_t insertPoint, uint32_t insertCount, uint32_t deleteCount, const WeakRefList<T>& args, uint32_t argsOffset)
1108     {
1109         m_list.splice(insertPoint, insertCount, deleteCount, args, argsOffset);
1110     }
1111
1112     template<class T>
1113     REALLY_INLINE void WeakRefList<T>::reverse()
1114     {
1115         m_list.reverse();
1116     }
1117
1118     template<class T>
1119     REALLY_INLINE void WeakRefList<T>::clear()
1120     {
1121         m_list.clear();
1122     }
1123
1124     template<class T>
1125     REALLY_INLINE int32_t WeakRefList<T>::indexOf(TYPE value) const
1126     {
1127         return m_list.indexOf(reinterpret_cast<MMgc::GCObject*>(value));
1128     }
1129
1130     template<class T>
1131     REALLY_INLINE int32_t WeakRefList<T>::lastIndexOf(TYPE value) const
1132     {
1133         return m_list.lastIndexOf(reinterpret_cast<MMgc::GCObject*>(value));
1134     }
1135
1136     template<class T>
1137     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::removeAt(uint32_t index)
1138     {
1139         return reinterpret_cast<TYPE>(m_list.removeAt(index));
1140     }
1141
1142     template<class T>
1143     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::removeFirst()
1144     {
1145         return reinterpret_cast<TYPE>(m_list.removeFirst());
1146     }
1147
1148     template<class T>
1149     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::removeLast()
1150     {
1151         return reinterpret_cast<TYPE>(m_list.removeLast());
1152     }
1153
1154     template<class T>
1155     REALLY_INLINE typename WeakRefList<T>::TYPE WeakRefList<T>::operator[](uint32_t index) const
1156     {
1157         return reinterpret_cast<TYPE>(m_list[index]);
1158     }
1159
1160     template<class T>
1161     REALLY_INLINE void WeakRefList<T>::ensureCapacity(uint32_t cap)
1162     {
1163         m_list.ensureCapacity(cap);
1164     }
1165
1166     template<class T>
1167     REALLY_INLINE uint64_t WeakRefList<T>::bytesUsed() const
1168     {
1169         return m_list.bytesUsed();
1170     }
1171
1172     template<class T>
1173     REALLY_INLINE void WeakRefList<T>::skipDestructor()
1174     {
1175         m_list.skipDestructor();
1176     }
1177
1178     template<class T>
1179     REALLY_INLINE uint32_t WeakRefList<T>::removeCollectedItems()
1180     {
1181         return m_list.removeNullItems();
1182     }
1183
1184     template<class T>
1185     REALLY_INLINE void WeakRefList<T>::gcTrace(MMgc::GC* gc)
1186     {
1187         m_list.gcTrace(gc);
1188     }
1189
1190     // ----------------------------
1191
1192     template<class T>
1193     REALLY_INLINE DataList<T>::DataList(MMgc::GC* gc, uint32_t capacity, const T* args)
1194         : ListImpl< T, DataListHelper<T> >(gc, capacity, args)
1195     {
1196         // We must not be a pointer type.
1197         MMGC_STATIC_ASSERT(TypeSniffer<T>::isNonPointer::value == true);
1198
1199         // If you make a NonGCObject list that holds GC/RCObjects, you are almost
1200         // certainly making a mistake. (Redundant to the above check, but left in
1201         // for emphasis.)
1202         MMGC_STATIC_ASSERT(TypeSniffer<T>::isGCObject::value == false &&
1203                            TypeSniffer<T>::isGCFinalizedObject::value == false &&
1204                            TypeSniffer<T>::isRCObject::value == false &&
1205                            TypeSniffer<T>::isGCTraceableObject::value == false);
1206     }
1207
1208     // ----------------------------
1209
1210     template<class T>
1211     REALLY_INLINE DataListAccessor<T>::DataListAccessor(DataList<T>* v) : m_list(v)
1212     {
1213     }
1214
1215     template<class T>
1216     REALLY_INLINE T* DataListAccessor<T>::addr()
1217     {
1218         return (m_list != NULL) ? m_list->m_data->entries : (T*)NULL;
1219     }
1220
1221     template<class T>
1222     REALLY_INLINE uint32_t DataListAccessor<T>::length()
1223     {
1224         return (m_list != NULL) ? m_list->length() : 0;
1225     }
1226
1227     // ----------------------------
1228
1229     template<class T>
1230     REALLY_INLINE HeapList<T>::HeapList(MMgc::GC* gc, uint32_t capacity, const typename T::TYPE* args)
1231         : list(gc, capacity, args)
1232     {
1233     }
1234 }
1235
1236 #endif /* __avmplus_List_inlines__ */