/[jscoverage]/trunk/js/jsarray.h
ViewVC logotype

Contents of /trunk/js/jsarray.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 507 - (show annotations)
Sun Jan 10 07:23:34 2010 UTC (9 years, 10 months ago) by siliconforks
File MIME type: text/plain
File size: 8644 byte(s)
Update SpiderMonkey from Firefox 3.6rc1.

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 "jsprvtd.h"
46 #include "jspubtd.h"
47 #include "jsobj.h"
48
49 JS_BEGIN_EXTERN_C
50
51 #define ARRAY_CAPACITY_MIN 7
52
53 extern JSBool
54 js_IdIsIndex(jsval id, jsuint *indexp);
55
56 extern JSClass js_ArrayClass, js_SlowArrayClass;
57
58 static JS_INLINE JSBool
59 js_IsDenseArray(JSObject *obj)
60 {
61 return STOBJ_GET_CLASS(obj) == &js_ArrayClass;
62 }
63
64 #define OBJ_IS_DENSE_ARRAY(cx, obj) js_IsDenseArray(obj)
65
66 #define OBJ_IS_ARRAY(cx,obj) (OBJ_IS_DENSE_ARRAY(cx, obj) || \
67 OBJ_GET_CLASS(cx, obj) == &js_SlowArrayClass)
68
69 /*
70 * Dense arrays are not native (OBJ_IS_NATIVE(cx, aobj) for a dense array aobj
71 * results in false, meaning aobj->map does not point to a JSScope).
72 *
73 * But Array methods are called via aobj.sort(), e.g., and the interpreter and
74 * the trace recorder must consult the property cache in order to perform well.
75 * The cache works only for native objects.
76 *
77 * Therefore the interpreter (js_Interpret in JSOP_GETPROP and JSOP_CALLPROP)
78 * and js_GetPropertyHelper use this inline function to skip up one link in the
79 * prototype chain when obj is a dense array, in order to find a native object
80 * (to wit, Array.prototype) in which to probe for cached methods.
81 *
82 * Note that setting aobj.__proto__ for a dense array aobj turns aobj into a
83 * slow array, avoiding the neede to skip.
84 *
85 * Callers of js_GetProtoIfDenseArray must take care to use the original object
86 * (obj) for the |this| value of a getter, setter, or method call (bug 476447).
87 */
88 #ifdef __cplusplus /* Allow inclusion from LiveConnect C files. */
89 static JS_INLINE JSObject *
90 js_GetProtoIfDenseArray(JSContext *cx, JSObject *obj)
91 {
92 return OBJ_IS_DENSE_ARRAY(cx, obj) ? OBJ_GET_PROTO(cx, obj) : obj;
93 }
94 #endif
95
96 extern JSObject *
97 js_InitArrayClass(JSContext *cx, JSObject *obj);
98
99 #ifdef __cplusplus /* Allow inclusion from LiveConnect C files. */
100 extern bool
101 #else
102 extern JSBool
103 #endif
104 js_InitContextBusyArrayTable(JSContext *cx);
105
106 #ifdef __cplusplus /* Allow inclusion from LiveConnect C files. */
107 extern JSObject *
108 js_NewArrayObject(JSContext *cx, jsuint length, jsval *vector,
109 JSBool holey = JS_FALSE);
110 #else
111 extern JSObject *
112 js_NewArrayObject(JSContext *cx, jsuint length, jsval *vector,
113 JSBool holey);
114 #endif
115
116 /* Create an array object that starts out already made slow/sparse. */
117 extern JSObject *
118 js_NewSlowArrayObject(JSContext *cx);
119
120 extern JSBool
121 js_MakeArraySlow(JSContext *cx, JSObject *obj);
122
123 #define JSSLOT_ARRAY_LENGTH JSSLOT_PRIVATE
124 #define JSSLOT_ARRAY_COUNT (JSSLOT_ARRAY_LENGTH + 1)
125 #define JSSLOT_ARRAY_UNUSED (JSSLOT_ARRAY_COUNT + 1)
126
127 static JS_INLINE uint32
128 js_DenseArrayCapacity(JSObject *obj)
129 {
130 JS_ASSERT(js_IsDenseArray(obj));
131 return obj->dslots ? (uint32) obj->dslots[-1] : 0;
132 }
133
134 static JS_INLINE void
135 js_SetDenseArrayCapacity(JSObject *obj, uint32 capacity)
136 {
137 JS_ASSERT(js_IsDenseArray(obj));
138 JS_ASSERT(obj->dslots);
139 obj->dslots[-1] = (jsval) capacity;
140 }
141
142 extern JSBool
143 js_GetLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp);
144
145 extern JSBool
146 js_SetLengthProperty(JSContext *cx, JSObject *obj, jsdouble length);
147
148 extern JSBool
149 js_HasLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp);
150
151 extern JSBool JS_FASTCALL
152 js_IndexToId(JSContext *cx, jsuint index, jsid *idp);
153
154 /*
155 * Test whether an object is "array-like". Currently this means whether obj
156 * is an Array or an arguments object. We would like an API, and probably a
157 * way in the language, to bless other objects as array-like: having indexed
158 * properties, and a 'length' property of uint32 value equal to one more than
159 * the greatest index.
160 */
161 extern JSBool
162 js_IsArrayLike(JSContext *cx, JSObject *obj, JSBool *answerp, jsuint *lengthp);
163
164 /*
165 * JS-specific merge sort function.
166 */
167 typedef JSBool (*JSComparator)(void *arg, const void *a, const void *b,
168 int *result);
169 /*
170 * NB: vec is the array to be sorted, tmp is temporary space at least as big
171 * as vec. Both should be GC-rooted if appropriate.
172 *
173 * The sorted result is in vec. vec may be in an inconsistent state if the
174 * comparator function cmp returns an error inside a comparison, so remember
175 * to check the return value of this function.
176 */
177 extern JSBool
178 js_MergeSort(void *vec, size_t nel, size_t elsize, JSComparator cmp,
179 void *arg, void *tmp);
180
181 #ifdef DEBUG_ARRAYS
182 extern JSBool
183 js_ArrayInfo(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval);
184 #endif
185
186 extern JSBool JS_FASTCALL
187 js_ArrayCompPush(JSContext *cx, JSObject *obj, jsval v);
188
189 /*
190 * Fast dense-array-to-buffer conversion for use by canvas.
191 *
192 * If the array is a dense array, fill [offset..offset+count] values into
193 * destination, assuming that types are consistent. Return JS_TRUE if
194 * successful, otherwise JS_FALSE -- note that the destination buffer may be
195 * modified even if JS_FALSE is returned (e.g. due to finding an inappropriate
196 * type later on in the array). If JS_FALSE is returned, no error conditions
197 * or exceptions are set on the context.
198 *
199 * This method succeeds if each element of the array is an integer or a double.
200 * Values outside the 0-255 range are clamped to that range. Double values are
201 * converted to integers in this range by clamping and then rounding to
202 * nearest, ties to even.
203 */
204
205 JS_FRIEND_API(JSBool)
206 js_CoerceArrayToCanvasImageData(JSObject *obj, jsuint offset, jsuint count,
207 JSUint8 *dest);
208
209 JSBool
210 js_PrototypeHasIndexedProperties(JSContext *cx, JSObject *obj);
211
212 /*
213 * Utility to access the value from the id returned by array_lookupProperty.
214 */
215 JSBool
216 js_GetDenseArrayElementValue(JSContext *cx, JSObject *obj, JSProperty *prop,
217 jsval *vp);
218
219 /* Array constructor native. Exposed only so the JIT can know its address. */
220 JSBool
221 js_Array(JSContext* cx, JSObject* obj, uintN argc, jsval* argv, jsval* rval);
222
223 /*
224 * Friend api function that allows direct creation of an array object with a
225 * given capacity. Non-null return value means allocation of the internal
226 * buffer for a capacity of at least |capacity| succeeded. A pointer to the
227 * first element of this internal buffer is returned in the |vector| out
228 * parameter. The caller promises to fill in the first |capacity| values
229 * starting from that pointer immediately after this function returns and
230 * without triggering GC (so this method is allowed to leave those
231 * uninitialized) and to set them to non-JSVAL_HOLE values, so that the
232 * resulting array has length and count both equal to |capacity|.
233 */
234 JS_FRIEND_API(JSObject *)
235 js_NewArrayObjectWithCapacity(JSContext *cx, jsuint capacity, jsval **vector);
236
237 JS_END_EXTERN_C
238
239 #endif /* jsarray_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24