1 /*

     2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

     8  * 1.  Redistributions of source code must retain the above copyright

     9  *     notice, this list of conditions and the following disclaimer.

    10  * 2.  Redistributions in binary form must reproduce the above copyright

    11  *     notice, this list of conditions and the following disclaimer in the

    12  *     documentation and/or other materials provided with the distribution.

    13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    14  *     its contributors may be used to endorse or promote products derived

    15  *     from this software without specific prior written permission.

    16  *

    17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    27  */

    28 

    29 #ifndef JSPropertyNameIterator_h

    30 #define JSPropertyNameIterator_h

    31 

    32 #include "JSObject.h"

    33 #include "JSString.h"

    34 #include "Operations.h"

    35 #include "PropertyNameArray.h"

    36 

    37 namespace JSC {

    38 

    39     class Identifier;

    40     class JSObject;

    41 

    42     class JSPropertyNameIterator : public JSCell {

    43         friend class JIT;

    44 

    45     public:

    46         static JSPropertyNameIterator* create(ExecState*, JSObject*);

    47         

    48         static PassRefPtr<Structure> createStructure(JSValue prototype)

    49         {

    50             return Structure::create(prototype, TypeInfo(CompoundType, OverridesMarkChildren), AnonymousSlotCount);

    51         }

    52         

    53         virtual ~JSPropertyNameIterator();

    54 

    55         virtual bool isPropertyNameIterator() const { return true; }

    56 

    57         virtual void markChildren(MarkStack&);

    58 

    59         bool getOffset(size_t i, int& offset)

    60         {

    61             if (i >= m_numCacheableSlots)

    62                 return false;

    63             offset = i;

    64             return true;

    65         }

    66 

    67         JSValue get(ExecState*, JSObject*, size_t i);

    68         size_t size() { return m_jsStringsSize; }

    69 

    70         void setCachedStructure(Structure* structure)

    71         {

    72             ASSERT(!m_cachedStructure);

    73             ASSERT(structure);

    74             m_cachedStructure = structure;

    75         }

    76         Structure* cachedStructure() { return m_cachedStructure.get(); }

    77 

    78         void setCachedPrototypeChain(NonNullPassRefPtr<StructureChain> cachedPrototypeChain) { m_cachedPrototypeChain = cachedPrototypeChain; }

    79         StructureChain* cachedPrototypeChain() { return m_cachedPrototypeChain.get(); }

    80 

    81     private:

    82         JSPropertyNameIterator(ExecState*, PropertyNameArrayData* propertyNameArrayData, size_t numCacheableSlot);

    83 

    84         RefPtr<Structure> m_cachedStructure;

    85         RefPtr<StructureChain> m_cachedPrototypeChain;

    86         uint32_t m_numCacheableSlots;

    87         uint32_t m_jsStringsSize;

    88         OwnArrayPtr<JSValue> m_jsStrings;

    89     };

    90 

    91     inline void Structure::setEnumerationCache(JSPropertyNameIterator* enumerationCache)

    92     {

    93         ASSERT(!isDictionary());

    94         m_enumerationCache = enumerationCache;

    95     }

    96 

    97     inline void Structure::clearEnumerationCache(JSPropertyNameIterator* enumerationCache)

    98     {

    99         m_enumerationCache.clear(enumerationCache);

   100     }

   101 

   102     inline JSPropertyNameIterator* Structure::enumerationCache()

   103     {

   104         return m_enumerationCache.get();

   105     }

   106 

   107 } // namespace JSC

   108 

   109 #endif // JSPropertyNameIterator_h