34     template <HeapType heapType> class CollectorHeapIterator {

    34     class CollectorHeapIterator {

    36         CollectorHeapIterator(CollectorBlock** block, CollectorBlock** endBlock);

    36         bool operator!=(const CollectorHeapIterator& other);

    37 

    38         bool operator!=(const CollectorHeapIterator<heapType>& other) { return m_block != other.m_block || m_cell != other.m_cell; }

    39         CollectorHeapIterator<heapType>& operator++();

    42     private:

    39     protected:

    43         typedef typename HeapConstants<heapType>::Block Block;

    40         CollectorHeapIterator(CollectorHeap&, size_t startBlock, size_t startCell);

    44         typedef typename HeapConstants<heapType>::Cell Cell;

    41         void advance(size_t max);

    46         Block** m_block;

    43         CollectorHeap& m_heap;

    47         Block** m_endBlock;

    44         size_t m_block;

    48         Cell* m_cell;

    45         size_t m_cell;

    49         Cell* m_endCell;

    52     template <HeapType heapType> 

    48     class LiveObjectIterator : public CollectorHeapIterator {

    53     CollectorHeapIterator<heapType>::CollectorHeapIterator(CollectorBlock** block, CollectorBlock** endBlock)

    49     public:

    54         : m_block(reinterpret_cast<Block**>(block))

    50         LiveObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);

    55         , m_endBlock(reinterpret_cast<Block**>(endBlock))

    51         LiveObjectIterator& operator++();

    56         , m_cell(m_block == m_endBlock ? 0 : (*m_block)->cells)

    52     };

    57         , m_endCell(m_block == m_endBlock ? 0 : (*m_block)->cells + HeapConstants<heapType>::cellsPerBlock)

    53 

    54     class DeadObjectIterator : public CollectorHeapIterator {

    55     public:

    56         DeadObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);

    57         DeadObjectIterator& operator++();

    58     };

    59 

    60     class ObjectIterator : public CollectorHeapIterator {

    61     public:

    62         ObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);

    63         ObjectIterator& operator++();

    64     };

    65 

    66     inline CollectorHeapIterator::CollectorHeapIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)

    67         : m_heap(heap)

    68         , m_block(startBlock)

    69         , m_cell(startCell)

    63     template <HeapType heapType> 

    73     inline bool CollectorHeapIterator::operator!=(const CollectorHeapIterator& other)

    64     CollectorHeapIterator<heapType>& CollectorHeapIterator<heapType>::operator++()

    66         do {

    75         return m_block != other.m_block || m_cell != other.m_cell;

    67             for (++m_cell; m_cell != m_endCell; ++m_cell)

    76     }

    68                 if (m_cell->u.freeCell.zeroIfFree != 0) {

    69                     return *this;

    70                 }

    72             if (++m_block != m_endBlock) {

    78     inline JSCell* CollectorHeapIterator::operator*() const

    73                 m_cell = (*m_block)->cells;

    79     {

    74                 m_endCell = (*m_block)->cells + HeapConstants<heapType>::cellsPerBlock;

    80         return reinterpret_cast<JSCell*>(m_heap.blocks[m_block]->cells + m_cell);

    75             }

    81     }

    76         } while(m_block != m_endBlock);

    82     

    83     // Iterators advance up to the next-to-last -- and not the last -- cell in a

    84     // block, since the last cell is a dummy sentinel.

    85     inline void CollectorHeapIterator::advance(size_t max)

    86     {

    87         ++m_cell;

    88         if (m_cell == max) {

    89             m_cell = 0;

    90             ++m_block;

    91         }

    92     }

    78         m_cell = 0;

    94     inline LiveObjectIterator::LiveObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)

    95         : CollectorHeapIterator(heap, startBlock, startCell - 1)

    96     {

    97         ++(*this);

    98     }

    99 

   100     inline LiveObjectIterator& LiveObjectIterator::operator++()

   101     {

   102         advance(HeapConstants::cellsPerBlock - 1);

   103         if (m_block < m_heap.nextBlock || (m_block == m_heap.nextBlock && m_cell < m_heap.nextCell))

   104             return *this;

   105 

   106         while (m_block < m_heap.usedBlocks && !m_heap.blocks[m_block]->marked.get(m_cell))

   107             advance(HeapConstants::cellsPerBlock - 1);

    82     template <HeapType heapType> 

   111     inline DeadObjectIterator::DeadObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)

    83     JSCell* CollectorHeapIterator<heapType>::operator*() const

   112         : CollectorHeapIterator(heap, startBlock, startCell - 1)

    85         return reinterpret_cast<JSCell*>(m_cell);

   114         ++(*this);

   115     }

   116 

   117     inline DeadObjectIterator& DeadObjectIterator::operator++()

   118     {

   119         do {

   120             advance(HeapConstants::cellsPerBlock - 1);

   121             ASSERT(m_block > m_heap.nextBlock || (m_block == m_heap.nextBlock && m_cell >= m_heap.nextCell));

   122         } while (m_block < m_heap.usedBlocks && m_heap.blocks[m_block]->marked.get(m_cell));

   123         return *this;

   124     }

   125 

   126     inline ObjectIterator::ObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)

   127         : CollectorHeapIterator(heap, startBlock, startCell - 1)

   128     {

   129         ++(*this);

   130     }

   131 

   132     inline ObjectIterator& ObjectIterator::operator++()

   133     {

   134         advance(HeapConstants::cellsPerBlock - 1);

   135         return *this;