2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
*
|
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is Mozilla Communicator client code, released
|
|
|
|
* March 31, 1998.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
|
|
#ifndef jsfun_h___
|
|
|
|
#define jsfun_h___
|
|
|
|
/*
|
|
|
|
* JS function definitions.
|
|
|
|
*/
|
|
|
|
#include "jsprvtd.h"
|
|
|
|
#include "jspubtd.h"
|
2008-04-02 00:46:12 -07:00
|
|
|
#include "jsobj.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
JS_BEGIN_EXTERN_C
|
|
|
|
|
2007-11-27 00:38:47 -08:00
|
|
|
typedef struct JSLocalNameMap JSLocalNameMap;
|
|
|
|
|
2008-03-23 03:04:38 -07:00
|
|
|
/*
|
|
|
|
* Depending on the number of arguments and variables in the function their
|
|
|
|
* names and attributes are stored either as a single atom or as an array of
|
|
|
|
* tagged atoms (when there are few locals) or as a hash-based map (when there
|
|
|
|
* are many locals). In the first 2 cases the lowest bit of the atom is used
|
|
|
|
* as a tag to distinguish const from var. See jsfun.c for details.
|
|
|
|
*/
|
|
|
|
typedef union JSLocalNames {
|
|
|
|
jsuword taggedAtom;
|
|
|
|
jsuword *array;
|
|
|
|
JSLocalNameMap *map;
|
|
|
|
} JSLocalNames;
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
struct JSFunction {
|
2008-08-21 03:47:33 -07:00
|
|
|
JSObject object; /* GC'ed object header */
|
|
|
|
uint16 nargs; /* maximum number of specified arguments,
|
|
|
|
reflected as f.length/f.arity */
|
|
|
|
uint16 flags; /* flags, see JSFUN_* below and in jsapi.h */
|
2008-03-29 03:34:29 -07:00
|
|
|
union {
|
|
|
|
struct {
|
2008-08-21 03:47:33 -07:00
|
|
|
uint16 extra; /* number of arg slots for local GC roots */
|
|
|
|
uint16 spare; /* reserved for future use */
|
|
|
|
JSNative native; /* native method pointer or null */
|
2009-03-03 22:53:27 -08:00
|
|
|
JSClass *clasp; /* class of objects constructed
|
|
|
|
by this function */
|
|
|
|
JSTraceableNative *trcinfo; /* tracer metadata; can be first
|
|
|
|
element of array */
|
2008-03-29 03:34:29 -07:00
|
|
|
} n;
|
|
|
|
struct {
|
2008-08-21 03:47:33 -07:00
|
|
|
uint16 nvars; /* number of local variables */
|
|
|
|
uint16 nupvars; /* number of upvars (computable from script
|
|
|
|
but here for faster access) */
|
|
|
|
JSScript *script; /* interpreted bytecode descriptor or null */
|
|
|
|
JSLocalNames names; /* argument and variable names */
|
2008-03-29 03:34:29 -07:00
|
|
|
} i;
|
|
|
|
} u;
|
2008-08-21 03:47:33 -07:00
|
|
|
JSAtom *atom; /* name for diagnostics and decompiling */
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
2008-10-08 15:08:33 -07:00
|
|
|
#define JSFUN_TRACEABLE 0x2000 /* can trace across calls to this native
|
|
|
|
function; use FUN_TRCINFO if set,
|
|
|
|
FUN_CLASP if unset */
|
2007-05-29 18:49:42 -07:00
|
|
|
#define JSFUN_EXPR_CLOSURE 0x4000 /* expression closure: function(x)x*x */
|
2008-03-29 03:34:29 -07:00
|
|
|
#define JSFUN_INTERPRETED 0x8000 /* use u.i if set, u.n if unset */
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
#define JSFUN_SCRIPT_OR_FAST_NATIVE (JSFUN_INTERPRETED | JSFUN_FAST_NATIVE)
|
2007-08-01 21:33:52 -07:00
|
|
|
|
2008-04-02 00:46:12 -07:00
|
|
|
#define FUN_OBJECT(fun) (&(fun)->object)
|
2008-03-29 03:34:29 -07:00
|
|
|
#define FUN_INTERPRETED(fun) ((fun)->flags & JSFUN_INTERPRETED)
|
|
|
|
#define FUN_SLOW_NATIVE(fun) (!((fun)->flags & JSFUN_SCRIPT_OR_FAST_NATIVE))
|
|
|
|
#define FUN_SCRIPT(fun) (FUN_INTERPRETED(fun) ? (fun)->u.i.script : NULL)
|
|
|
|
#define FUN_NATIVE(fun) (FUN_SLOW_NATIVE(fun) ? (fun)->u.n.native : NULL)
|
|
|
|
#define FUN_FAST_NATIVE(fun) (((fun)->flags & JSFUN_FAST_NATIVE) \
|
|
|
|
? (JSFastNative) (fun)->u.n.native \
|
|
|
|
: NULL)
|
|
|
|
#define FUN_MINARGS(fun) (((fun)->flags & JSFUN_FAST_NATIVE) \
|
2008-08-08 09:02:50 -07:00
|
|
|
? 0 \
|
2008-03-29 03:34:29 -07:00
|
|
|
: (fun)->nargs)
|
2008-10-08 15:08:33 -07:00
|
|
|
#define FUN_CLASP(fun) (JS_ASSERT(!FUN_INTERPRETED(fun)), \
|
2009-03-03 22:53:27 -08:00
|
|
|
fun->u.n.clasp)
|
2008-10-08 15:08:33 -07:00
|
|
|
#define FUN_TRCINFO(fun) (JS_ASSERT(!FUN_INTERPRETED(fun)), \
|
|
|
|
JS_ASSERT((fun)->flags & JSFUN_TRACEABLE), \
|
2009-03-03 22:53:27 -08:00
|
|
|
fun->u.n.trcinfo)
|
2008-10-08 15:08:33 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Traceable native. This expands to a JSFunctionSpec initializer (like JS_FN
|
|
|
|
* in jsapi.h). fastcall is a JSFastNative; trcinfo is a JSTraceableNative *.
|
|
|
|
*/
|
|
|
|
#ifdef JS_TRACER
|
|
|
|
/* MSVC demands the intermediate (void *) cast here. */
|
|
|
|
# define JS_TN(name,fastcall,nargs,flags,trcinfo) \
|
2009-02-19 00:33:37 -08:00
|
|
|
{name, JS_DATA_TO_FUNC_PTR(JSNative, trcinfo), nargs, \
|
2008-10-08 15:08:33 -07:00
|
|
|
(flags) | JSFUN_FAST_NATIVE | JSFUN_STUB_GSOPS | JSFUN_TRACEABLE, 0}
|
|
|
|
#else
|
|
|
|
# define JS_TN(name,fastcall,nargs,flags,trcinfo) \
|
|
|
|
JS_FN(name, fastcall, nargs, flags)
|
|
|
|
#endif
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
extern JSClass js_ArgumentsClass;
|
2007-12-12 15:02:25 -08:00
|
|
|
extern JS_FRIEND_DATA(JSClass) js_CallClass;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/* JS_FRIEND_DATA so that VALUE_IS_FUNCTION is callable from the shell. */
|
|
|
|
extern JS_FRIEND_DATA(JSClass) js_FunctionClass;
|
|
|
|
|
2008-04-02 00:46:12 -07:00
|
|
|
#define HAS_FUNCTION_CLASS(obj) (STOBJ_GET_CLASS(obj) == &js_FunctionClass)
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/*
|
|
|
|
* NB: jsapi.h and jsobj.h must be included before any call to this macro.
|
|
|
|
*/
|
|
|
|
#define VALUE_IS_FUNCTION(cx, v) \
|
2008-04-02 00:46:12 -07:00
|
|
|
(!JSVAL_IS_PRIMITIVE(v) && HAS_FUNCTION_CLASS(JSVAL_TO_OBJECT(v)))
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-03-28 15:27:36 -07:00
|
|
|
/*
|
|
|
|
* Macro to access the private slot of the function object after the slot is
|
|
|
|
* initialized.
|
|
|
|
*/
|
|
|
|
#define GET_FUNCTION_PRIVATE(cx, funobj) \
|
2008-04-02 00:46:12 -07:00
|
|
|
(JS_ASSERT(HAS_FUNCTION_CLASS(funobj)), \
|
2008-03-28 15:27:36 -07:00
|
|
|
(JSFunction *) OBJ_GET_PRIVATE(cx, funobj))
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
extern JSObject *
|
|
|
|
js_InitFunctionClass(JSContext *cx, JSObject *obj);
|
|
|
|
|
|
|
|
extern JSObject *
|
|
|
|
js_InitArgumentsClass(JSContext *cx, JSObject *obj);
|
|
|
|
|
|
|
|
extern JSObject *
|
|
|
|
js_InitCallClass(JSContext *cx, JSObject *obj);
|
|
|
|
|
|
|
|
extern JSFunction *
|
|
|
|
js_NewFunction(JSContext *cx, JSObject *funobj, JSNative native, uintN nargs,
|
|
|
|
uintN flags, JSObject *parent, JSAtom *atom);
|
|
|
|
|
2007-11-19 03:38:08 -08:00
|
|
|
extern void
|
2008-03-29 03:34:29 -07:00
|
|
|
js_TraceFunction(JSTracer *trc, JSFunction *fun);
|
2007-11-18 06:10:28 -08:00
|
|
|
|
2007-08-04 00:00:43 -07:00
|
|
|
extern void
|
2008-03-29 03:34:29 -07:00
|
|
|
js_FinalizeFunction(JSContext *cx, JSFunction *fun);
|
2007-08-04 00:00:43 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
extern JSObject *
|
2008-04-02 00:46:12 -07:00
|
|
|
js_CloneFunctionObject(JSContext *cx, JSFunction *fun, JSObject *parent);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
extern JSBool
|
|
|
|
js_LinkFunctionObject(JSContext *cx, JSFunction *fun, JSObject *object);
|
|
|
|
|
|
|
|
extern JSFunction *
|
2007-03-22 10:30:00 -07:00
|
|
|
js_DefineFunction(JSContext *cx, JSObject *obj, JSAtom *atom, JSNative native,
|
|
|
|
uintN nargs, uintN flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flags for js_ValueToFunction and js_ReportIsNotFunction. We depend on the
|
|
|
|
* fact that JSINVOKE_CONSTRUCT (aka JSFRAME_CONSTRUCTING) is 1, and test that
|
|
|
|
* with #if/#error in jsfun.c.
|
|
|
|
*/
|
|
|
|
#define JSV2F_CONSTRUCT JSINVOKE_CONSTRUCT
|
|
|
|
#define JSV2F_ITERATOR JSINVOKE_ITERATOR
|
|
|
|
#define JSV2F_SEARCH_STACK 0x10000
|
|
|
|
|
|
|
|
extern JSFunction *
|
|
|
|
js_ValueToFunction(JSContext *cx, jsval *vp, uintN flags);
|
|
|
|
|
|
|
|
extern JSObject *
|
|
|
|
js_ValueToFunctionObject(JSContext *cx, jsval *vp, uintN flags);
|
|
|
|
|
|
|
|
extern JSObject *
|
|
|
|
js_ValueToCallableObject(JSContext *cx, jsval *vp, uintN flags);
|
|
|
|
|
|
|
|
extern void
|
|
|
|
js_ReportIsNotFunction(JSContext *cx, jsval *vp, uintN flags);
|
|
|
|
|
|
|
|
extern JSObject *
|
2009-02-18 23:57:24 -08:00
|
|
|
js_GetCallObject(JSContext *cx, JSStackFrame *fp);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2008-01-28 15:07:29 -08:00
|
|
|
extern JS_FRIEND_API(JSBool)
|
2007-03-22 10:30:00 -07:00
|
|
|
js_PutCallObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
|
|
|
|
extern JSBool
|
2008-03-29 08:48:41 -07:00
|
|
|
js_GetCallArg(JSContext *cx, JSObject *obj, jsid id, jsval *vp);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
extern JSBool
|
2008-03-29 08:48:41 -07:00
|
|
|
js_GetCallVar(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
extern JSBool
|
|
|
|
js_GetArgsValue(JSContext *cx, JSStackFrame *fp, jsval *vp);
|
|
|
|
|
|
|
|
extern JSBool
|
2007-06-14 00:07:01 -07:00
|
|
|
js_GetArgsProperty(JSContext *cx, JSStackFrame *fp, jsid id, jsval *vp);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
extern JSObject *
|
|
|
|
js_GetArgsObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
|
2008-01-28 15:07:29 -08:00
|
|
|
extern JS_FRIEND_API(JSBool)
|
2007-03-22 10:30:00 -07:00
|
|
|
js_PutArgsObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
|
|
|
|
extern JSBool
|
|
|
|
js_XDRFunction(JSXDRState *xdr, JSObject **objp);
|
|
|
|
|
2007-11-19 09:15:45 -08:00
|
|
|
typedef enum JSLocalKind {
|
|
|
|
JSLOCAL_NONE,
|
|
|
|
JSLOCAL_ARG,
|
|
|
|
JSLOCAL_VAR,
|
2008-08-21 03:47:33 -07:00
|
|
|
JSLOCAL_CONST,
|
|
|
|
JSLOCAL_UPVAR
|
2007-11-19 09:15:45 -08:00
|
|
|
} JSLocalKind;
|
|
|
|
|
2008-08-21 03:47:33 -07:00
|
|
|
#define JS_UPVAR_LOCAL_NAME_START(fun) ((fun)->nargs + (fun)->u.i.nvars)
|
|
|
|
#define JS_GET_LOCAL_NAME_COUNT(fun) (JS_UPVAR_LOCAL_NAME_START(fun) + \
|
|
|
|
(fun)->u.i.nupvars)
|
2008-02-08 16:01:45 -08:00
|
|
|
|
2007-11-19 09:15:45 -08:00
|
|
|
extern JSBool
|
2008-03-29 03:34:29 -07:00
|
|
|
js_AddLocal(JSContext *cx, JSFunction *fun, JSAtom *atom, JSLocalKind kind);
|
2007-11-19 09:15:45 -08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up an argument or variable name returning its kind when found or
|
|
|
|
* JSLOCAL_NONE when no such name exists. When indexp is not null and the name
|
|
|
|
* exists, *indexp will receive the index of the corresponding argument or
|
|
|
|
* variable.
|
|
|
|
*/
|
|
|
|
extern JSLocalKind
|
2008-03-29 03:34:29 -07:00
|
|
|
js_LookupLocal(JSContext *cx, JSFunction *fun, JSAtom *atom, uintN *indexp);
|
2007-11-19 09:15:45 -08:00
|
|
|
|
|
|
|
/*
|
2008-02-08 16:01:45 -08:00
|
|
|
* Functions to work with local names as an array of words.
|
2007-11-19 09:15:45 -08:00
|
|
|
*
|
2008-08-21 03:47:33 -07:00
|
|
|
* js_GetLocalNameArray returns the array, or null if we are out of memory.
|
|
|
|
* This function must not be called when JS_GET_LOCAL_NAME_COUNT(fun) is zero.
|
2007-11-19 09:15:45 -08:00
|
|
|
*
|
2008-08-21 03:47:33 -07:00
|
|
|
* The supplied pool is used to allocate the returned array, so the caller is
|
|
|
|
* obligated to mark and release to free it.
|
|
|
|
*
|
|
|
|
* The elements of the array with index less than fun->nargs correspond to the
|
|
|
|
* names of function formal parameters. An index >= fun->nargs addresses a var
|
|
|
|
* binding. Use JS_LOCAL_NAME_TO_ATOM to convert array's element to an atom
|
|
|
|
* pointer. This pointer can be null when the element is for a formal parameter
|
|
|
|
* corresponding to a destructuring pattern.
|
|
|
|
*
|
|
|
|
* If nameWord does not name a formal parameter, use JS_LOCAL_NAME_IS_CONST to
|
|
|
|
* check if nameWord corresponds to the const declaration.
|
2007-11-19 09:15:45 -08:00
|
|
|
*/
|
2008-02-08 16:01:45 -08:00
|
|
|
extern jsuword *
|
2008-05-09 00:40:10 -07:00
|
|
|
js_GetLocalNameArray(JSContext *cx, JSFunction *fun, struct JSArenaPool *pool);
|
2008-02-08 16:01:45 -08:00
|
|
|
|
|
|
|
#define JS_LOCAL_NAME_TO_ATOM(nameWord) \
|
|
|
|
((JSAtom *) ((nameWord) & ~(jsuword) 1))
|
|
|
|
|
|
|
|
#define JS_LOCAL_NAME_IS_CONST(nameWord) \
|
|
|
|
((((nameWord) & (jsuword) 1)) != 0)
|
2007-11-19 09:15:45 -08:00
|
|
|
|
2007-11-27 00:38:47 -08:00
|
|
|
extern void
|
2008-03-29 03:34:29 -07:00
|
|
|
js_FreezeLocalNames(JSContext *cx, JSFunction *fun);
|
2007-11-19 09:15:45 -08:00
|
|
|
|
2009-01-30 15:40:05 -08:00
|
|
|
extern JS_REQUIRES_STACK JSBool
|
2008-10-29 23:59:19 -07:00
|
|
|
js_fun_apply(JSContext *cx, uintN argc, jsval *vp);
|
|
|
|
|
2009-01-30 15:40:05 -08:00
|
|
|
extern JS_REQUIRES_STACK JSBool
|
2008-10-29 23:59:19 -07:00
|
|
|
js_fun_call(JSContext *cx, uintN argc, jsval *vp);
|
|
|
|
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_END_EXTERN_C
|
|
|
|
|
|
|
|
#endif /* jsfun_h___ */
|