core/VectorClass-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
  41 #ifndef __avmplus_VectorClass_inlines__
  42 #define __avmplus_VectorClass_inlines__
  43
  44 namespace avmplus
  45 {
  46     // For some hand-written tracers that are used by generated tracers.
  47
  48 #define avmplus_TypedVectorClassXDoubleVectorObjectX_isExactInterlock 1
  49 #define avmplus_TypedVectorClassXIntVectorObjectX_isExactInterlock 1
  50 #define avmplus_TypedVectorClassXUIntVectorObjectX_isExactInterlock 1
  51 #define avmplus_TypedVectorClassXObjectVectorObjectX_isExactInterlock 1
  52 #define avmplus_TypedVectorObjectXDataListXdoubleXX_isExactInterlock 1
  53 #define avmplus_TypedVectorObjectXDataListXint32_tXX_isExactInterlock 1
  54 #define avmplus_TypedVectorObjectXDataListXuint32_tXX_isExactInterlock 1
  55 #define avmplus_TypedVectorObjectXAtomListX_isExactInterlock 1
  56
  57     // ----------------------------
  58
  59     REALLY_INLINE TypedVectorClassBase::TypedVectorClassBase(VTable* vtable)
  60         : ClassClosure(vtable)
  61     {
  62     }
  63
  64     REALLY_INLINE Traits* TypedVectorClassBase::getTypeTraits() const
  65     {
  66         return m_typeTraits;
  67     }
  68
  69     // ----------------------------
  70
  71     template<>
  72     REALLY_INLINE OpaqueAtom TypedVectorConstants<OpaqueAtom>::nullValue()
  73     {
  74         return (OpaqueAtom)nullObjectAtom;
  75     }
  76     template<>
  77     REALLY_INLINE OpaqueAtom TypedVectorConstants<OpaqueAtom>::undefinedValue()
  78     {
  79         return (OpaqueAtom)undefinedAtom;
  80     }
  81
  82     template<class T>
  83     REALLY_INLINE T TypedVectorConstants<T>::nullValue()
  84     {
  85         return 0;
  86     }
  87     template<class T>
  88     REALLY_INLINE T TypedVectorConstants<T>::undefinedValue()
  89     {
  90         return 0;
  91     }
  92
  93     // ----------------------------
  94
  95     REALLY_INLINE bool VectorBaseObject::get_fixed() const
  96     {
  97         return m_fixed;
  98     }
  99
 100     REALLY_INLINE void VectorBaseObject::set_fixed(bool f)
 101     {
 102         m_fixed = f;
 103     }
 104
 105     REALLY_INLINE void VectorBaseObject::checkFixed() const
 106     {
 107         if (m_fixed)
 108             throwFixedError();
 109     }
 110
 111     REALLY_INLINE Traits* VectorBaseObject::getTypeTraits() const
 112     {
 113         return m_vecClass->getTypeTraits();
 114     }
 115
 116     REALLY_INLINE void VectorBaseObject::atomToValue(Atom atom, int32_t& value)
 117     {
 118         value = AvmCore::integer(atom);
 119     }
 120
 121     REALLY_INLINE Atom VectorBaseObject::valueToAtom(const int32_t& value) const
 122     {
 123         return core()->intToAtom(value);
 124     }
 125
 126     REALLY_INLINE void VectorBaseObject::atomToValue(Atom atom, uint32_t& value)
 127     {
 128         value = AvmCore::toUInt32(atom);
 129     }
 130
 131     REALLY_INLINE Atom VectorBaseObject::valueToAtom(const uint32_t& value) const
 132     {
 133         return core()->uintToAtom(value);
 134     }
 135
 136     REALLY_INLINE void VectorBaseObject::atomToValue(Atom atom, double& value)
 137     {
 138         value = AvmCore::number(atom);
 139     }
 140
 141     REALLY_INLINE Atom VectorBaseObject::valueToAtom(const double& value) const
 142     {
 143         return core()->doubleToAtom(value);
 144     }
 145
 146     REALLY_INLINE void VectorBaseObject::atomToValue(Atom atom, OpaqueAtom& value)
 147     {
 148         AvmAssert(m_vecClass != NULL);
 149         atom = avmplus::coerce(toplevel(), atom, m_vecClass->getTypeTraits());
 150         value = (OpaqueAtom)atom;
 151     }
 152
 153     REALLY_INLINE Atom VectorBaseObject::valueToAtom(const OpaqueAtom& value) const
 154     {
 155         return (Atom)value;
 156     }
 157
 158     // ----------------------------
 159
 160     template<class TLIST>
 161     REALLY_INLINE typename TLIST::TYPE TypedVectorObject<TLIST>::getUintPropertyFast(uint32_t index) const
 162     {
 163         return m_list.get(index);
 164     }
 165
 166     template<class TLIST>
 167     REALLY_INLINE void TypedVectorObject<TLIST>::setUintPropertyFast(uint32_t index, typename TLIST::TYPE value)
 168     {
 169         m_list.set(index, value);
 170     }
 171
 172     template<class TLIST>
 173     REALLY_INLINE uint32_t TypedVectorObject<TLIST>::get_length() const
 174     {
 175         return m_list.length();
 176     }
 177
 178     template<class TLIST>
 179     REALLY_INLINE void TypedVectorObject<TLIST>::_reverse()
 180     {
 181         m_list.reverse();
 182     }
 183
 184     template<class TLIST>
 185     REALLY_INLINE bool TypedVectorObject<TLIST>::hasUintProperty(uint32_t index) const
 186     {
 187         return _hasUintProperty(index);
 188     }
 189
 190     template<class TLIST>
 191     REALLY_INLINE Atom TypedVectorObject<TLIST>::getUintProperty(uint32_t index) const
 192     {
 193         return _getUintProperty(index);
 194     }
 195
 196     template<class TLIST>
 197     REALLY_INLINE void TypedVectorObject<TLIST>::setUintProperty(uint32_t index, Atom value)
 198     {
 199         _setUintProperty(index, value);
 200     }
 201
 202 #ifdef DEBUGGER
 203     template<class TLIST>
 204     REALLY_INLINE uint64_t TypedVectorObject<TLIST>::bytesUsed() const
 205     {
 206         return ScriptObject::bytesUsed() + m_list.bytesUsed();
 207     }
 208 #endif
 209
 210     template<class TLIST>
 211     REALLY_INLINE uint32_t TypedVectorObject<TLIST>::checkReadIndex_u(uint32_t index) const
 212     {
 213         uint32_t const limit = m_list.length();
 214         if (index >= limit)
 215             throwRangeError(index);
 216         return index;
 217     }
 218
 219     template<class TLIST>
 220     REALLY_INLINE uint32_t TypedVectorObject<TLIST>::checkWriteIndex_u(uint32_t index) const
 221     {
 222         // If we are 'fixed', we can't write past the end.
 223         // If we are not 'fixed', legal to write exactly 1 past the end, growing as needed.
 224         uint32_t const limit = m_list.length() + 1 - uint32_t(m_fixed);
 225         if (index >= limit)
 226             throwRangeError(index);
 227         return index;
 228     }
 229
 230     // ----------------------------
 231
 232     template<class TLIST>
 233     REALLY_INLINE VectorAccessor<TLIST>::VectorAccessor(TypedVectorObject<TLIST>* v) : m_vector(v)
 234     {
 235     }
 236
 237     template<class TLIST>
 238     REALLY_INLINE typename TLIST::TYPE* VectorAccessor<TLIST>::addr()
 239     {
 240         return (m_vector != NULL) ? m_vector->m_list.m_data->entries : (typename TLIST::TYPE*)NULL;
 241     }
 242
 243     template<class TLIST>
 244     REALLY_INLINE uint32_t VectorAccessor<TLIST>::length()
 245     {
 246         return (m_vector != NULL) ? m_vector->m_list.length() : 0;
 247     }
 248 }
 249
 250 #endif /* __avmplus_VectorClass__ */