LCOV - app.info - js/src/jsarray.h

LCOV - code coverage report
| Current view: | directory - js/src - jsarray.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 10 | 10 | 100.0 %
| Date: | 2012-04-07 | Functions: | 1 | 1 | 100.0 %

           1                 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  *
           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 Mozilla Communicator client code, released
          17                 :  * March 31, 1998.
          18                 :  *
          19                 :  * The Initial Developer of the Original Code is
          20                 :  * Netscape Communications Corporation.
          21                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          22                 :  * the Initial Developer. All Rights Reserved.
          23                 :  *
          24                 :  * Contributor(s):
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or 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 jsarray_h___
          41                 : #define jsarray_h___
          42                 : /*
          43                 :  * JS Array interface.
          44                 :  */
          45                 : #include "jscntxt.h"
          46                 : #include "jsprvtd.h"
          47                 : #include "jspubtd.h"
          48                 : #include "jsatom.h"
          49                 : #include "jsobj.h"
          50                 :
          51                 : /* Small arrays are dense, no matter what. */
          52                 : const unsigned MIN_SPARSE_INDEX = 256;
          53                 :
          54                 : namespace js {
          55                 : /* 2^32-2, inclusive */
          56                 : const uint32_t MAX_ARRAY_INDEX = 4294967294u;
          57                 : }
          58                 :
          59                 : inline JSBool
          60        48570564 : js_IdIsIndex(jsid id, uint32_t *indexp)
          61                 : {
          62        48570564 :     if (JSID_IS_INT(id)) {
          63        16627335 :         int32_t i = JSID_TO_INT(id);
          64        16627335 :         if (i < 0)
          65            2253 :             return JS_FALSE;
          66        16625082 :         *indexp = (uint32_t)i;
          67        16625082 :         return JS_TRUE;
          68                 :     }
          69                 :
          70        31943229 :     if (JS_UNLIKELY(!JSID_IS_STRING(id)))
          71             361 :         return JS_FALSE;
          72                 :
          73        31942868 :     return js::StringIsArrayIndex(JSID_TO_ATOM(id), indexp);
          74                 : }
          75                 :
          76                 : /*
          77                 :  * Dense arrays are not native -- aobj->isNative() for a dense array aobj
          78                 :  * results in false, meaning aobj->map does not point to a js::Shape.
          79                 :  *
          80                 :  * But Array methods are called via aobj.sort(), e.g., and the interpreter and
          81                 :  * the trace recorder must consult the property cache in order to perform well.
          82                 :  * The cache works only for native objects.
          83                 :  *
          84                 :  * Therefore the interpreter (js_Interpret in JSOP_GETPROP and JSOP_CALLPROP)
          85                 :  * and js_GetPropertyHelper use this inline function to skip up one link in the
          86                 :  * prototype chain when obj is a dense array, in order to find a native object
          87                 :  * (to wit, Array.prototype) in which to probe for cached methods.
          88                 :  *
          89                 :  * Note that setting aobj.__proto__ for a dense array aobj turns aobj into a
          90                 :  * slow array, avoiding the neede to skip.
          91                 :  *
          92                 :  * Callers of js_GetProtoIfDenseArray must take care to use the original object
          93                 :  * (obj) for the |this| value of a getter, setter, or method call (bug 476447).
          94                 :  */
          95                 : inline JSObject *
          96                 : js_GetProtoIfDenseArray(JSObject *obj);
          97                 :
          98                 : extern JSObject *
          99                 : js_InitArrayClass(JSContext *cx, JSObject *obj);
         100                 :
         101                 : extern bool
         102                 : js_InitContextBusyArrayTable(JSContext *cx);
         103                 :
         104                 : namespace js {
         105                 :
         106                 : /* Create a dense array with no capacity allocated, length set to 0. */
         107                 : extern JSObject * JS_FASTCALL
         108                 : NewDenseEmptyArray(JSContext *cx, JSObject *proto=NULL);
         109                 :
         110                 : /* Create a dense array with length and capacity == 'length', initialized length set to 0. */
         111                 : extern JSObject * JS_FASTCALL
         112                 : NewDenseAllocatedArray(JSContext *cx, uint32_t length, JSObject *proto=NULL);
         113                 :
         114                 : /*
         115                 :  * Create a dense array with length, capacity and initialized length == 'length', and filled with holes.
         116                 :  * This is a kludge, as the tracer doesn't yet track/update initialized length when initializing
         117                 :  * array elements.
         118                 :  */
         119                 : extern JSObject * JS_FASTCALL
         120                 : NewDenseAllocatedEmptyArray(JSContext *cx, uint32_t length, JSObject *proto=NULL);
         121                 :
         122                 : /*
         123                 :  * Create a dense array with a set length, but without allocating space for the
         124                 :  * contents. This is useful, e.g., when accepting length from the user.
         125                 :  */
         126                 : extern JSObject * JS_FASTCALL
         127                 : NewDenseUnallocatedArray(JSContext *cx, uint32_t length, JSObject *proto=NULL);
         128                 :
         129                 : /* Create a dense array with a copy of vp. */
         130                 : extern JSObject *
         131                 : NewDenseCopiedArray(JSContext *cx, uint32_t length, const Value *vp, JSObject *proto = NULL);
         132                 :
         133                 : /* Create a sparse array. */
         134                 : extern JSObject *
         135                 : NewSlowEmptyArray(JSContext *cx);
         136                 :
         137                 : } /* namespace js */
         138                 :
         139                 : extern JSBool
         140                 : js_GetLengthProperty(JSContext *cx, JSObject *obj, uint32_t *lengthp);
         141                 :
         142                 : extern JSBool
         143                 : js_SetLengthProperty(JSContext *cx, JSObject *obj, double length);
         144                 :
         145                 : namespace js {
         146                 :
         147                 : extern JSBool
         148                 : array_defineElement(JSContext *cx, JSObject *obj, uint32_t index, const Value *value,
         149                 :                     PropertyOp getter, StrictPropertyOp setter, unsigned attrs);
         150                 :
         151                 : extern JSBool
         152                 : array_deleteElement(JSContext *cx, JSObject *obj, uint32_t index, Value *rval, JSBool strict);
         153                 :
         154                 : /*
         155                 :  * Copy 'length' elements from aobj to vp.
         156                 :  *
         157                 :  * This function assumes 'length' is effectively the result of calling
         158                 :  * js_GetLengthProperty on aobj.
         159                 :  */
         160                 : extern bool
         161                 : GetElements(JSContext *cx, JSObject *aobj, uint32_t length, js::Value *vp);
         162                 :
         163                 : /* Natives exposed for optimization by the interpreter and JITs. */
         164                 :
         165                 : extern JSBool
         166                 : array_sort(JSContext *cx, unsigned argc, js::Value *vp);
         167                 :
         168                 : extern JSBool
         169                 : array_push(JSContext *cx, unsigned argc, js::Value *vp);
         170                 :
         171                 : extern JSBool
         172                 : array_pop(JSContext *cx, unsigned argc, js::Value *vp);
         173                 :
         174                 : extern JSBool
         175                 : array_concat(JSContext *cx, unsigned argc, js::Value *vp);
         176                 :
         177                 : extern JSBool
         178                 : array_shift(JSContext *cx, unsigned argc, js::Value *vp);
         179                 :
         180                 : } /* namespace js */
         181                 :
         182                 : #ifdef DEBUG
         183                 : extern JSBool
         184                 : js_ArrayInfo(JSContext *cx, unsigned argc, jsval *vp);
         185                 : #endif
         186                 :
         187                 : /*
         188                 :  * Append the given (non-hole) value to the end of an array.  The array must be
         189                 :  * a newborn array -- that is, one which has not been exposed to script for
         190                 :  * arbitrary manipulation.  (This method optimizes on the assumption that
         191                 :  * extending the array to accommodate the element will never make the array
         192                 :  * sparse, which requires that the array be completely filled.)
         193                 :  */
         194                 : extern JSBool
         195                 : js_NewbornArrayPush(JSContext *cx, JSObject *obj, const js::Value &v);
         196                 :
         197                 : JSBool
         198                 : js_PrototypeHasIndexedProperties(JSContext *cx, JSObject *obj);
         199                 :
         200                 : /*
         201                 :  * Utility to access the value from the id returned by array_lookupProperty.
         202                 :  */
         203                 : JSBool
         204                 : js_GetDenseArrayElementValue(JSContext *cx, JSObject *obj, jsid id,
         205                 :                              js::Value *vp);
         206                 :
         207                 : /* Array constructor native. Exposed only so the JIT can know its address. */
         208                 : JSBool
         209                 : js_Array(JSContext *cx, unsigned argc, js::Value *vp);
         210                 :
         211                 : #endif /* jsarray_h___ */

Generated by: LCOV version 1.7