Skip to content

/ mORMot

Permalink
master
Switch branches/tags

mORMot/SynSMAPI.pas

Go to file
 
 
Cannot retrieve contributors at this time
4896 lines (4164 sloc) 214 KB
Raw Blame
/// SpiderMonkey *.h header port to Delphi
// - this unit is a part of the freeware Synopse mORMot framework,
// licensed under a MPL/GPL/LGPL tri-license; version 1.18
unit SynSMAPI;
{
This file is part of Synopse framework.
Synopse framework. Copyright (C) 2021 Arnaud Bouchez
Synopse Informatique - https://synopse.info
Scripting support for mORMot Copyright (C) 2021 Pavel Mashlyakovsky
pavel.mash at gmail.com
Some ideas taken from
http://code.google.com/p/delphi-javascript
http://delphi.mozdev.org/javascript_bridge/
*** 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 Initial Developer of the Original Code is
Pavel Mashlyakovsky.
Portions created by the Initial Developer are Copyright (C) 2021
the Initial Developer. All Rights Reserved.
Contributor(s):
- Arnaud Bouchez
- Vadim Orel
Alternatively, the contents of this file may be used under the terms of
either 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 *****
---------------------------------------------------------------------------
Download the SpiderMonkey library at https://synopse.info/files/synsm.7z !
---------------------------------------------------------------------------
Version 1.18
- initial release. Use SpiderMonkey 24
https://developer.mozilla.org/en-US/docs/SpiderMonkey/24
and Modify jsapi.h for possibility import from Delphi
and jsapi.cpp for possibility use JS_NumberValue
- add JSString.ToJSVal method
- change JS_ARGV macro result type to PjsvalVector
- add debugger support functions
road map:
write Tjsval - object (record) wraper for jsval with methods Is* To* As*
migrate to IonMonkey
compile mozjs without nspr
enable ctypes? for byte array work #ifdef JS_HAS_CTYPES JS_InitCTypesClass
}
{$I Synopse.inc} // define HASINLINE CPU32 CPU64 OWNNORMTOUPPER
{$I SynSM.inc} //define JS_THREADSAFE WITHASSERT
interface
uses
{$ifdef MSWINDOWS}
Windows,
{$endif}
Variants,
SynCommons;
const
{$ifdef MSWINDOWS}
{$ifdef CPU64}
SpiderMonkeyLib = 'mozjs64.dll';
{$else}
SpiderMonkeyLib = 'mozjs-24.dll';
NSPRLib = 'libnspr4.dll';
{$endif}
{$endif}
{$ifdef LINUX} // for Kylix/FPC (not tested yet)
SpiderMonkeyLib = 'mozjs.so';
{$endif}
type
{$ifndef UNICODE}
/// 8 bit signed integer type for C APIs
int8 = ShortInt;
/// 8 bit unsigned integer type for C APIs
uint8 = Byte;
/// 16 bit signed integer type for C APIs
int16 = Smallint;
/// 16 bit unsigned integer type for C APIs
uint16 = Word;
/// 32 bit signed integer type for C APIs
int32 = Integer;
/// 32 bit unsigned integer type for C APIs
uint32 = Cardinal;
{$endif}
/// define SpiderMonkey dedicated text buffer type
// - in SM 1.8.5 exist mode JS_CSringAreUTF8, so it is possibe to use our
// RawUTF8 strings (in all cases internaly in SM it will be converted to
// Unicode - so need to test if SynCommons conversion faster or not -
// - but in SM 1.8.8 JS_CSringAreUTF8 removed, and all API may have to
// switch to jschar ( = Word/WideChar ) ?
PCChar = PAnsiChar;
/// 8 bit signed integer type for SMAPI
JSInt8 = ShortInt;
/// 16 bit signed integer type for SMAPI
JSInt16 = SmallInt;
/// 32 bit signed integer type for SMAPI
JSInt32 = Integer;
/// 8 bit unsigned integer type for SMAPI
JSUint8 = Byte;
/// 16 bit unsigned integer type for SMAPI
JSUint16 = Word;
/// 32 bit unsigned integer type for SMAPI
JSUInt32 = Cardinal;
/// 64 bit signed integer type for SMAPI
JSInt64 = Int64;
/// 64 bit unsigned integer type for SMAPI
JSUInt64 = QWord;
{$ifndef FPC}
/// variable type used to store a buffer size (in bytes) for SMAPI
size_t = PtrUInt;
{$endif}
/// jschar is the type of JavaScript "characters", the 16 bits elements
// that make up JavaScript strings (maybe not truly valid UTF-16)
// - It is a 16-bit unsigned integer type
// - As required by the ECMAScript standard, ECMA 262-3 §4.3.16, JavaScript
// strings are arbitrary sequences of 16-bit values
// - A string may contain unmatched surrogates, which are not valid UTF-16
// - It may also contain zeroes (0)
// - so we did not define it as WideChar, but as abstract Word element
jschar = Word;
/// pointer to a sequence of JavaScript "characters", i.e. some 16 bits
// elements that make up JavaScript strings (maybe not truly valid UTF-16)
// - As required by the ECMAScript standard, ECMA 262-3 §4.3.16, JavaScript
// strings are arbitrary sequences of 16-bit values
// - A string may contain unmatched surrogates, which are not valid UTF-16
// - It may also contain zeroes (0)
Pjschar = ^jschar;
/// pointer to a pointer of JavaScript "characters"
// - is mostly used for arrays of JavaScript strings
PPjschar = ^Pjschar;
/// jsdouble is the internal type of numbers, i.e. floating-point values
// - jsdouble is obsolete since JavaScript 1.8.7+ - instead we must use C double
// so let's do it for future now
// - in all cases see JSFloat64 - NSPR's floating point type is always 64 bits.
jsdouble = Double;
/// Pointer to JSScript structure defined if jsscript.h
// - we do not directly use of this structure, so we define just a pointer
PJSScript = type Pointer;
/// type appropriate for most signed integer variables for SMAPI
// - They are guaranteed to be at least 16 bits, though various architectures
// may define them to be wider (e.g., 32 or even 64 bits). These types are
// never valid for fields of a structure.
JSIntn = PtrInt;
/// type appropriate for most unsigned integer variables for SMAPI
// - They are guaranteed to be at least 16 bits, though various architectures
// may define them to be wider (e.g., 32 or even 64 bits). These types are
// never valid for fields of a structure.
JSUintn = PtrUInt;
/// type appropriate for most flag set variables
// - They are guaranteed to be at least 16 bits, though various architectures
// may define them to be wider (e.g., 32 or even 64 bits). These types are
// never valid for fields of a structure.
uintn = PtrUInt;
/// pointer to a flag set variable
puintN = ^uintn;
/// internal type of numbers, i.e. floating-point values for SMAPI
// - NSPR's floating point type is always 64 bits.
JSFloat64 = Double;
/// a type for representing the size of objects for SMAPI
JSSize = size_t;
/// type for pointer arithmetic difference
// - Variables of this type are suitable for storing a pointer or pointer sutraction
ptrdiff_t = PtrInt;
/// type for pointer arithmetic difference for SMAPI
// - Variables of this type are suitable for storing a pointer or pointer sutraction
JSPtrdiff = ptrdiff_t;
/// ordinal type used for pointer arithmetic
// - Variables of this type are suitable for storing a pointer or pointer sutraction
JSUIntPtr = PtrUInt;
/// pointer on an ordinal type used for pointer arithmetic
PJSuintptr = ^JSuintptr;
/// ordinal type used for pointer arithmetic
// - Variables of this type are suitable for storing a pointer or pointer sutraction
JSUptrdiff = JSUintPtr ;
/// boolean type for variables and parameter types for SMAPI
// - Use JS_FALSE and JS_TRUE constants for clarity of target type in assignments
JSBool = JSIntn;
/// pointer to boolean type for variables and parameter types for SMAPI
PJSBool = ^JSBool;
const
/// boolean TRUE value for variables and parameter types for SMAPI
JS_TRUE = JSBool(1);
/// boolean FALSE value for variables and parameter types for SMAPI
JS_FALSE = JSBool(0);
/// packed boolean type for variables and parameter types for SMAPI
// - use JSPackedBool within structs where bitfields are not desireable
// but minimum and consistent overhead matters.
type
JSPackedBool = JSUint8;
/// a JSWord is a signed integer that is the same size as a pointer
JSWord = PtrInt;
/// a JSWord is an unsigned integer that is the same size as a pointer
JSUword = PtrUInt;
{ jsbuiltins.h conversion - "object" types }
/// available options for JS Objects
TJSOption = (
jsoExtraWarning, jsoWError, jsoVarObjFix, jsoPrivateIsNSISupports, jsoCompileNGo,
jsoUnused5, jsoUnused6, jsoUnused7, jsoDontReportUncaught, jsoUnused9,
jsoUnused10, jsoUnused11, jsoNoScriptRVal, jsoUnrootedGlobal,
jsoBaseLine, jsoPcCount, jsoTypeInference, jsoStrictMode, jsoIon, jsoAsmJS);
/// set of available options for JS Objects
TJSOptions = set of TJSOption;
/// available options for JS Objects Properties
TJSPropertyAttr = (
jspEnumerate, jspReadOnly, jspPermanent, jspUnused, jspGetter,
jspSetter, jspShared, jspIndex, sjpShortID);
/// set of available options for JS Objects Properties
TJSPropertyAttrs = set of TJSPropertyAttr;
/// pointer to a JS Runtime instance
PJSRuntime = ^JSRuntime;
/// pointer to a JS String instance
PJSString = ^JSString;
/// pointer to a JS Object instance
PJSObject = ^JSObject;
/// map a generic JavaScript value internal representation
// - a variable of type jsval can hold exactly the same values as a JavaScript
// var or property: string, number, object, boolean, null, or undefined
// (including Arrays, functions, and Errors are all objects)
// - jsval is a variant type whose exact representation varies by architecture.
// - you should never use this value internals, but pjsval and its TSMValue
// wrapper, as defined in SynSM.pas unit, for a given TSMEngine execution
// context - see
// https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JSval
jsval = type QWord;
/// pointer to a jsval JavaScript value
pjsval = ^jsval;
/// an abstract array of jsval JavaScript values
TjsvalVector = array[0..(MaxInt div sizeof(jsval))-1] of jsval;
/// map an array of jsval JavaScript values
PjsvalVector = ^TjsvalVector;
/// used to store a JavaScript version
JSVersion = Integer;
/// JavaScript execution context
// - this object does not store anything, but just provide some helper methods
// to access a PPJSContext value via JS_*Context*(..) API functions
JSContext = object
private
function GetVersion: JSVersion;
// JS_SetVersion is not supported now Use CompartmentOptions in JS_NewGlobalObject
function GetPrivate: Pointer;
{$ifdef HASINLINE}inline;{$endif}
procedure SetPrivate(const Value: Pointer);
{$ifdef FIXBUGXE3}
public
{$endif}
function GetOptions: TJSOptions;
procedure SetOptions(const Value: TJSOptions);
public
/// wrapper to JS_DestroyContext(@self)
procedure Destroy;
/// wrapper to JS_GetRuntime(@self)
function Runtime: PJSRuntime;
/// wrapper to JS_InitStandardClasses(@self,global)
function InitStandardClasses(global: PJSObject): boolean;
{$ifndef FIXBUGXE3}
/// wrapper to JS_GetOptions()/JS_SetOptions()
// - due to a XE3 bug, you should use the GetOptions/SetOptions methods
// instead of this property, under this compiler revision
property Options: TJSOptions read GetOptions write SetOptions;
{$endif}
/// wrapper to JS_GetVersion()/JS_SetVersion()
property Version: JSVersion read GetVersion;
/// wrapper to JS_GetVersion() and string conversion
function VersionToString: RawUTF8;
/// wrapper to JS_GetContextPrivate()/JS_SetContextPrivate()
property PrivateData: Pointer read GetPrivate write SetPrivate;
public
/// create a new JavaScript string instance from a given UTF-8 text
function NewJSString(const Value: RawUTF8): PJSString; overload;
/// create a new JavaScript string instance from a given UTF-16 text
function NewJSString(const Value: SynUnicode): PJSString; overload;
/// create a new JavaScript string instance from a given UTF-16 text buffer
function NewJSString(TextWide: PWideChar; TextLen: integer): PJSString; overload;
/// create a new JavaScript string instance from a given Ansi text buffer
// - will use the specified Ansi code page for the conversion
// - if CodePage is 0, will use the CurrentAnsiCodePage value
function NewJSString(TextAnsi: PAnsiChar; TextLen, CodePage: integer): PJSString; overload;
end;
/// pointer to JavaScript execution context
// - allows convenient access of JSContext wrapper methods
PJSContext = ^JSContext;
/// pointer to a pointer of JavaScript execution context
PPJSContext = ^PJSContext;
/// JavaScript execution runtime
// - this object does not store anything, but just provide some helper methods
// to access a PJSRuntime value via JS_*Runtime*(..) API functions
JSRuntime = object
private
function GetPrivate: Pointer;
procedure SetPrivate(const Value: Pointer);
public
/// wrapper to JS_LockRuntime(@self)
procedure Lock;
/// wrapper to JS_UnLockRuntime(@self)
procedure Unlock;
/// wrapper to JS_DestroyRuntime(@self)
procedure Destroy;
/// wrapper to JS_GetRuntimePrivate()/JS_SetRuntimePrivate()
property PrivateData: Pointer read GetPrivate write SetPrivate;
end;
/// points to a JavaScript execution compartment
// - allows convenient access of JSCompartment wrapper methods
PJSCompartment = ^JSCompartment;
/// JavaScript execution compartment
// - this object does not store anything, but just provide some helper methods
// to access a PJSRuntime value via JS_*Runtime*(..) API functions
JSCompartment = object
private
fcx: PJSContext;
public
/// initialize and enter a JavaScript execution compartment
function EnterCompartment(cx: PJSContext; target: PJSObject): PJSCompartment;
/// leave a JavaScript execution compartment
procedure Destroy;
end;
/// JavaScript string instance
// - this object does not store anything, but just provide some helper methods
// to access a PPJSString value via JS_*String*(..) API functions
// - use function JSContext.NewJSString() to create a new instance for a given
// execution context
// - to understand string in SpiderMonkey good point is comments in vm\String.h
// in short this is C structure:
// $struct Data
// $ {
// $ size_t lengthAndFlags; /* JSString */
// $ union {
// $ const jschar *chars; /* JSLinearString */
// $ JSString *left; /* JSRope */
// $ } u1;
// $ union {
// $ jschar inlineStorage[NUM_INLINE_CHARS]; /* JS(Inline|Short)String */
// $ struct {
// $ union {
// $ JSLinearString *base; /* JSDependentString */
// $ JSString *right; /* JSRope */
// $ size_t capacity; /* JSFlatString (extensible) */
// $ size_t externalType; /* JSExternalString */
// $ } u2;
// $ union {
// $ JSString *parent; /* JSRope (temporary) */
// $ void *externalClosure; /* JSExternalString */
// $ size_t reserved; /* may use for bug 615290 */
// $ } u3;
// $ } s;
// $ };
// $ } d;
// but in API there is no need to use this structure, only pointer to it, and
// high-level access to the SpiderMonkey API via this JSString wrapper
JSString = object
public
/// get the UTF-8 text corresponding to this string, for a given
// runtime execution context
function ToUTF8(cx: PJSContext): RawUTF8; overload;
/// get the UTF-8 text corresponding to this string, for a given
// runtime execution context
// - slightly faster overloaded method (avoid string assignment)
procedure ToUTF8(cx: PJSContext; var result: RawUTF8); overload;
/// Add UTF-8 text corresponding to this string to writer,
// without escaping
procedure ToUTF8(cx: PJSContext; W: TTextWriter); overload;
/// get the UTF-16 text corresponding to this string, for a given
// runtime execution context
function ToSynUnicode(cx: PJSContext): SynUnicode;
/// get the UTF-16 text corresponding to this string, for a given
// runtime execution context
function ToWideString(cx: PJSContext): WideString;
/// get the UTF-16 text corresponding to this string as a variant,
// for a given runtime execution context
// - will store a SynUnicode value into the variant instance
procedure ToVariant(cx: PJSContext; var Value: Variant);
/// get the Delphi string text corresponding to this string, for a given
// runtime execution context
function ToString(cx: PJSContext): string;
/// get the text encoded as a UTF-8 JSON string
procedure ToJSONString(cx: PJSContext; W: TTextWriter);
/// get a jsval corresponding to this string
function ToJSVal: jsval;
end;
/// pointer to a pointer of JavaScript string
PPJSString = ^PJSString;
/// JSObject is the type of JavaScript objects in the JSAPI
// - this object does not store anything, but just provide some helper methods
// to access a PJSObject value via low-level API functions
JSObject = object
public
/// get a jsval corresponding to this object
function ToJSValue: jsval; {$ifdef HASINLINE}inline;{$endif}
end;
/// pointer to a pointer of JavaScript object
PPJSObject = ^PJSObject;
/// abstract pointer to a JavaScript function
PJSFunction = type Pointer;
/// jsid is a generic identifier for any JavaScript object property of method
// - a jsid is an identifier for a property or method of an object which is
// either a 31-bit signed integer, internal string or object. If XML is
// enabled, there is an additional singleton jsid value; see
// JS_DEFAULT_XML_NAMESPACE_ID below. Finally, there is an additional jsid
// value, JSID_VOID, which does not occur in JS scripts but may be used to
// indicate the absence of a valid jsid.
jsid = size_t;
/// pointer to a JavaScript object property of method identifier
pjsid = ^jsid;
/// abstract array to JavaScript object property of method identifiers
// - set to -2 instead of -1 to allow JSIdArray record compilation
TjsidVector = array[0..(MaxInt div sizeof(jsid))-2] of jsid;
/// map an array to JavaScript object property of method identifiers
PjsidVector = ^TjsidVector;
{ jspubtd.h conversion - public types }
const
/// Run-time version enumeration corresponding to 1.0
JSVERSION_1_0 = 100;
/// Run-time version enumeration corresponding to 1.1
JSVERSION_1_1 = 110;
/// Run-time version enumeration corresponding to 1.2
JSVERSION_1_2 = 120;
/// Run-time version enumeration corresponding to 1.3
JSVERSION_1_3 = 130;
/// Run-time version enumeration corresponding to 1.4
JSVERSION_1_4 = 140;
/// Run-time version enumeration corresponding to ECMA standard 3, i.e. 1.4.8
JSVERSION_ECMA_3 = 148;
/// Run-time version enumeration corresponding to 1.5
JSVERSION_1_5 = 150;
/// Run-time version enumeration corresponding to 1.6
JSVERSION_1_6 = 160;
/// Run-time version enumeration corresponding to 1.7
JSVERSION_1_7 = 170;
/// Run-time version enumeration corresponding to 1.8
JSVERSION_1_8 = 180;
/// Run-time version enumeration corresponding to ECMA standard 5, i.e. 1.8.5
JSVERSION_ECMA_5 = 185;
/// Run-time version enumeration corresponding to default version
JSVERSION_DEFAULT = 0;
/// Run-time version enumeration corresponding to an identified version
JSVERSION_UNKNOWN = -1;
/// Run-time version enumeration corresponding to the latest available
// - that is, ECMA standard 5, i.e. 1.8.5
JSVERSION_LATEST = JSVERSION_ECMA_5;
type
/// Result of typeof operator enumeration
JSType = (
JSTYPE_VOID, { undefined }
JSTYPE_OBJECT, { object }
JSTYPE_FUNCTION, { function }
JSTYPE_STRING, { string }
JSTYPE_NUMBER, { number }
JSTYPE_BOOLEAN, { boolean }
JSTYPE_NULL, { null }
// JSTYPE_XML is not supported now
JSTYPE_LIMIT
);
/// js_CheckAccess mode enumeration
JSAccessMode = (
JSACC_PROTO = 0, { XXXbe redundant w.r.t. id }
{
* enum value #1 formerly called JSACC_PARENT,
* gap preserved for ABI compatibility.
}
{
* enum value #2 formerly called JSACC_IMPORT,
* gap preserved for ABI compatibility.
}
JSACC_WATCH = 3, { a watchpoint on object foo for id 'bar' }
JSACC_READ = 4, { a "get" of foo.bar }
JSACC_WRITE = 8, { a "set" of foo.bar = baz }
JSACC_LIMIT = 9
);
/// This enum type is used to control the behavior of a JSObject property
// iterator function that has type JSNewEnumerate.
// - JSENUMERATE_INIT
// A new, opaque iterator state should be allocated and stored in *statep.
// (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
// The number of properties that will be enumerated should be returned as
// an integer jsval in *idp, if idp is non-null, and provided the number of
// enumerable properties is known. If idp is non-null and the number of
// enumerable properties can't be computed in advance, *idp should be set
// to JSVAL_ZERO.
// - JSENUMERATE_INIT_ALL
// Used identically to JSENUMERATE_INIT, but exposes all properties of the
// object regardless of enumerability.
// - JSENUMERATE_NEXT
// A previously allocated opaque iterator state is passed in via statep.
// Return the next jsid in the iteration using *idp. The opaque iterator
// state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
// if there are no properties left to enumerate.
// - JSENUMERATE_DESTROY
// Destroy the opaque iterator state previously allocated in *statep by a
// call to this function when enum_op was JSENUMERATE_INIT or
// JSENUMERATE_INIT_ALL.
JSIterateOp = (
//* Create new iterator state over enumerable properties. */
JSENUMERATE_INIT,
//* Create new iterator state over all properties. */
JSENUMERATE_INIT_ALL,
//* Iterate once. */
JSENUMERATE_NEXT,
//* Destroy iterator state. */
JSENUMERATE_DESTROY
);
// JSClass (and js::ObjectOps where appropriate) function pointer typedefs
/// JSClass method prototype to add, or get a property named by id in obj
// - note the jsid id type -- id may be a string (Unicode property identifier)
// or an int (element index)
// - the vp out parameter, on success, is the new property value after
// an add or get. After a successful delete, *vp is JSVAL_FALSE iff
// obj[id] can't be deleted (because it's permanent)
JSPropertyOp = function(cx: PJSContext; var obj: PJSObject; var id: jsid;
vp: pjsval): JSBool; cdecl;
/// JSClass method prototype to delete a property named by id in obj
// - note the jsid id type -- id may be a string (Unicode property identifier)
// or an int (element index)
// - the *succeeded out parameter, on success, is the JSVAL_TRUE. *succeeded is
// JSVAL_FALSE if obj[id] can't be deleted (because it's permanent)
JSDeletePropertyOp = function(cx: PJSContext; var obj: PJSObject; var id: jsid;
succeeded: PJSBool):JSBool; cdecl;
/// JSClass method prototype to set a property named by id in obj, treating
// the assignment as strict mode code if strict is true
// - note the jsid id type -- id may be a string (Unicode property identifier)
// or an int (element index)
// - the vp out parameter, on success, is the new property value after the set
JSStrictPropertyOp = function(cx: PJSContext; var obj: PJSObject; var id: jsid;
strict: JSBool; vp: pjsval): JSBool; cdecl;
/// function prototype used for callbacks that enumerate the properties of
// a JSObject
// - The behavior depends on the value of enum_op
// -The return value is used to indicate success, with a value of JS_FALSE
// indicating failure.
JSNewEnumerateOp = function(cx: PJSContext; var obj: PJSObject; enum_op: JSIterateOp;
statep: pjsval; idp: pjsid): JSBool; cdecl;
/// The old-style JSClass.enumerate op should define all lazy properties not
// yet reflected in obj.
JSEnumerateOp = function(cx: PJSContext; var obj: PJSObject): JSBool; cdecl;
/// function prototype used to resolve a lazy property named by id in obj
// by defining it directly in obj
// - Lazy properties are those reflected from some peer native property space
// (e.g., the DOM attributes for a given node reflected as obj) on demand.
// - JS looks for a property in an object, and if not found, tries to resolve
// the given id. If resolve succeeds, the engine looks again in case resolve
// defined obj[id]. If no such property exists directly in obj, the process
// is repeated with obj's prototype, etc.
// - NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
JSResolveOp = function(cx: PJSContext; var obj: PJSObject;
var id: jsid): JSBool; cdecl;
/// function prototype used to resolve a lazy property named by id in obj
// by defining it directly in obj
// - Like JSResolveOp, but flags provide contextual information as follows:
// ! JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
// ! JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
// ! JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
// ! JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
// ! JSRESOLVE_CLASSNAME class name used when constructing
// - The *objp out parameter, on success, should be null to indicate that id
// was not resolved; and non-null, referring to obj or one of its prototypes,
// if id was resolved.
// - This hook instead of JSResolveOp is called via the JSClass.resolve member
// if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
// - Setting JSCLASS_NEW_RESOLVE and JSCLASS_NEW_RESOLVE_GETS_START further
// extends this hook by passing in the starting object on the prototype chain
// via *objp. Thus a resolve hook implementation may define the property id
// being resolved in the object in which the id was first sought, rather than
// in a prototype object whose class led to the resolve hook being called.
// - When using JSCLASS_NEW_RESOLVE_GETS_START, the resolve hook must therefore
// null *objp to signify "not resolved". With only JSCLASS_NEW_RESOLVE and no
// JSCLASS_NEW_RESOLVE_GETS_START, the hook can assume *objp is null on entry.
// This is not good practice, but enough existing hook implementations count
// on it that we can't break compatibility by passing the starting object in
// *objp without a new JSClass flag.
JSNewResolveOp = function(cx: PJSContext; var obj: PJSObject; var id: jsid; flags: uintN;
var objp: PPJSObject): JSBool; cdecl;
// Convert obj to the given type, returning true with the resulting value in
// vp on success, and returning false on error or exception.
JSConvertOp = function(cx: PJSContext; var obj: PJSObject; typ: JSType;
vp: pjsval): JSBool; cdecl;
/// callback used to delegate typeof to an object so it can cloak a
// primitive or another object
JSTypeOfOp = function(cx: PJSContext; var obj: PJSObject): JSType; cdecl;
/// Finalize obj, which the garbage collector has determined to be unreachable
// from other live objects or from GC roots. Obviously, finalizers must never
// store a reference to obj.
JSFinalizeOp = procedure(cx: PJSContext; obj: PJSObject); cdecl;
/// callback used by JS_AddExternalStringFinalizer and JS_RemoveExternalStringFinalizer
// to extend and reduce the set of string types finalized by the GC.
JSStringFinalizeOp = procedure(cx: PJSContext; var obj: PJSString); cdecl;
/// JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
// returning false on error/exception, true on success with obj[id]'s last-got
// value in *vp, and its attributes in *attrsp. As for JSPropertyOp above, id
// is either a string or an int jsval.
JSCheckAccessOp = function(cx: PJSContext; var obj: PJSObject; var id: jsid;
mode: JSAccessMode; vp: Pjsval): JSBool; cdecl;
/// state value as expected by JSXDRObjectOp() prototype
PJSXDRState = type Pointer;
/// Encode or decode an object, given an XDR state record representing external data
JSXDRObjectOp = function(xdr: PJSXDRState; var objp: PJSObject): JSBool; cdecl;
/// callback used to check whether v is an instance of obj or not
// - Return false on error or exception, true on success with JS_TRUE in bp
// if v is an instance of obj, JS_FALSE in bp otherwise.
JSHasInstanceOp = function(cx: PJSContext; obj: PJSObject; const v: Pjsval;
var bp: JSBool): JSBool; cdecl;
// here we miss trace and debug-only function defenition
/// callback typedef for native functions called by the JS VM
// - cx is the execution context
// - argc is the number of supplied arguments
// - vp[0] is the callee - see JS_CALLEE()
// - vp[1] is the object instance - see JS_THIS()
// - vp[2]..vp[argc+1] are the supplied arguments - see JS_ARGV_PTR()
JSNative = function(cx: PJSContext; argc: uintN; vp: Pjsval): JSBool; cdecl;
/// callback used for trace operation of a given class
// - enumerate all traceable things reachable from obj's private data structure.
// - For each such thing, a trace implementation must call one of the
// JS_Call*Tracer variants on the thing.
// - JSTraceOp implementation can assume that no other threads mutates object
// state. It must not change state of the object or corresponding native
// structures. The only exception for this rule is the case when the embedding
// needs a tight integration with GC. In that case the embedding can check if
// the traversal is a part of the marking phase through calling
// JS_IsGCMarkingTracer and apply a special code like emptying caches or
// marking its native structures.
JSTraceOp = procedure(cx: PJSContext; argc: uintN; vp: Pjsval); cdecl;
/// a JavaScript tracer instance
PJSTracer = Pointer;
/// flag used for JSContextCallback() argument
// - JSCONTEXT_NEW: JS_NewContext successfully created a new JSContext
// instance. The callback can initialize the instance as
// required. If the callback returns false, the instance
// will be destroyed and JS_NewContext returns null. In
// this case the callback is not called again.
// - JSCONTEXT_DESTROY: One of JS_DestroyContext* methods is called. The
// callback may perform its own cleanup and must always
// return true.
// - Any other value: For future compatibility the callback must do nothing
// and return true in this case.
JSContextOp = (
JSCONTEXT_NEW,
JSCONTEXT_DESTROY
);
/// callback prototype for a given runtime context
// - the possible values for contextOp when the runtime calls the callback
// are defined by JSContextOp
JSContextCallback = function(cx: PJSContext; contextOp: uintN): JSBool; cdecl;
/// flag used for callback for a given runtime context garbage collection
JSGCStatus = (
JSGC_BEGIN,
JSGC_END
);
/// callback prototype for a given runtime context garbage collection
JSGCCallback = function(cx: PJSContext; status: JSGCStatus): JSBool; cdecl;
/// generic operaiton callback prototype for a given runtime context
JSOperationCallback = function(cx: PJSContext): JSBool; cdecl;
/// Security protocol
PJSPrincipals = Pointer;
/// internal structure used to report JavaScript errors
JSErrorReport = record
/// source file name, URL, etc., or null
filename: PCChar;
/// see 'originPrincipals' comment above
originPrincipals: PJSPrincipals;
/// source line number
lineno: uintN;
/// offending source line without final #13
linebuf: PCChar;
/// pointer to error token in linebuf
tokenptr: PCChar;
/// unicode (original) line buffer
uclinebuf: Pjschar;
/// unicode (original) token pointer
uctokenptr: Pjschar;
/// error/warning, etc.
flags: uintN;
/// the error number, e.g. see js.msg
errorNumber: uintN;
/// the (default) error message
ucmessage: Pjschar;
/// arguments for the error message
messageArgs: PPjschar;
/// One of the JSExnType constants
exnType: int16;
/// zero-based column index in line
column: uintN;
end;
/// map an internal structure used to report JavaScript errors
PJSErrorReport = ^JSErrorReport;
/// callback prototype for reporting error for a given runtime context
JSErrorReporter = procedure(cx: PJSContext; _message: PCChar; report: PJSErrorReport); cdecl;
/// Possible exception types
// -These types are part of a JSErrorFormatString structure
// - They define which error to throw in case of a runtime error
// - JSEXN_NONE marks an unthrowable error
JSExnType = (
JSEXN_NONE = -1,
JSEXN_ERR,
JSEXN_INTERNALERR,
JSEXN_EVALERR,
JSEXN_RANGEERR,
JSEXN_REFERENCEERR,
JSEXN_SYNTAXERR,
JSEXN_TYPEERR,
JSEXN_URIERR,
JSEXN_LIMIT
);
/// used by JSErrorCallback() callback
JSErrorFormatString = record
/// The error format string (UTF-8 if js_CStringsAreUTF8)
format: PCChar;
/// The number of arguments to expand in the formatted error message
argCount: uint16;
/// One of the JSExnType constants above
exnType: int16;
end;
/// pointer used by JSErrorCallback() callback
PJSErrorFormatString = ^JSErrorFormatString;
/// callback prototype for returning an execution error
JSErrorCallback = function(userRef: Pointer; const locale: PCChar;
const errorNumber: uintN): PJSErrorFormatString; cdecl;
// here we miss *Principals* functions - we do not use it for now
{ jsval.h conversion - extended types }
const
{$ifdef CPU64}
JSVAL_TAG_SHIFT = 47;
{$define JS_BITS_PER_WORD_IS64}
{$else}
{$define JS_BITS_PER_WORD_IS32}
{$endif}
{$ifdef CPU64}
JS_BYTES_PER_DOUBLE = 8;
JS_BYTES_PER_WORD = 8;
JS_BITS_PER_WORD_LOG2 = 6;
JS_ALIGN_OF_POINTER = 8;
{$else}
JS_BYTES_PER_DOUBLE = 8;
JS_BYTES_PER_WORD = 4;
JS_BITS_PER_WORD_LOG2 = 5;
JS_ALIGN_OF_POINTER = 4;
{$endif}
// JSValueType
type
JSValueType = Byte;
const
JSVAL_TYPE_DOUBLE = Byte($00);
JSVAL_TYPE_INT32 = Byte($01);
JSVAL_TYPE_UNDEFINED= Byte($02);
JSVAL_TYPE_BOOLEAN = Byte($03);
JSVAL_TYPE_MAGIC = Byte($04);
JSVAL_TYPE_STRING = Byte($05);
JSVAL_TYPE_NULL = Byte($06);
JSVAL_TYPE_OBJECT = Byte($07);
//JSValueTag
{$IFDEF CPU32}
type
JSValueTag = Cardinal;
const
JSVAL_TAG_CLEAR = Cardinal($FFFFFF80);
JSVAL_TAG_INT32 = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_INT32);
JSVAL_TAG_UNDEFINED = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_UNDEFINED);
JSVAL_TAG_STRING = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_STRING);
JSVAL_TAG_BOOLEAN = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_BOOLEAN);
JSVAL_TAG_MAGIC = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_MAGIC);
JSVAL_TAG_NULL = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_NULL);
JSVAL_TAG_OBJECT = Cardinal(JSVAL_TAG_CLEAR or JSVAL_TYPE_OBJECT);
{$ELSE} //CPU64
type
JSValueTag = Cardinal;
const
JSVAL_TAG_MAX_DOUBLE= Cardinal($0001FFF0);
JSVAL_TAG_INT32 = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_INT32);
JSVAL_TAG_UNDEFINED = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_UNDEFINED);
JSVAL_TAG_STRING = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_STRING);
JSVAL_TAG_BOOLEAN = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_BOOLEAN);
JSVAL_TAG_MAGIC = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_MAGIC);
JSVAL_TAG_NULL = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_NULL);
JSVAL_TAG_OBJECT = Cardinal(JSVAL_TAG_MAX_DOUBLE or JSVAL_TYPE_OBJECT);
type
JSValueShiftedTag = QWord;
const
JSVAL_SHIFTED_TAG_MAX_DOUBLE = (QWord(JSVAL_TAG_MAX_DOUBLE) shl JSVAL_TAG_SHIFT) or $FFFFFFFF;
JSVAL_SHIFTED_TAG_INT32 = QWord(JSVAL_TAG_INT32) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_UNDEFINED = QWord(JSVAL_TAG_UNDEFINED) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_STRING = QWord(JSVAL_TAG_STRING) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_BOOLEAN = QWord(JSVAL_TAG_BOOLEAN) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_MAGIC = QWord(JSVAL_TAG_MAGIC) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_NULL = QWord(JSVAL_TAG_NULL) shl JSVAL_TAG_SHIFT;
JSVAL_SHIFTED_TAG_OBJECT = QWord(JSVAL_TAG_OBJECT) shl JSVAL_TAG_SHIFT;
{$ENDIF}
JSVAL_LOWER_INCL_TYPE_OF_OBJ_OR_NULL_SET = JSVAL_TYPE_NULL;
JSVAL_UPPER_EXCL_TYPE_OF_PRIMITIVE_SET = JSVAL_TYPE_OBJECT;
JSVAL_UPPER_INCL_TYPE_OF_NUMBER_SET = JSVAL_TYPE_INT32;
JSVAL_LOWER_INCL_TYPE_OF_PTR_PAYLOAD_SET = JSVAL_TYPE_MAGIC;
{$ifdef CPU32}
//#define JSVAL_TYPE_TO_TAG(type) ((JSValueTag)(JSVAL_TAG_CLEAR | (type)))
JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET = JSVAL_TAG_NULL;
JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET = JSVAL_TAG_OBJECT;
JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET = JSVAL_TAG_INT32;
JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET = JSVAL_TAG_STRING;
{$else} // CPU64
JSVAL_PAYLOAD_MASK : QWord = $00007FFFFFFFFFFF;
JSVAL_TAG_MASK : QWord = $FFFF800000000000;
JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET = JSVAL_SHIFTED_TAG_NULL;
JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET = JSVAL_SHIFTED_TAG_OBJECT;
JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET = JSVAL_SHIFTED_TAG_UNDEFINED;
JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET = JSVAL_SHIFTED_TAG_STRING;
{$endif}
type
JSWhyMagic = (
JS_ELEMENTS_HOLE, // a hole in a native object's elements
JS_NATIVE_ENUMERATE, // indicates that a custom enumerate hook forwarded
// to JS_EnumerateState, which really means the object can be
// enumerated like a native object.
JS_NO_ITER_VALUE, // there is not a pending iterator value
JS_GENERATOR_CLOSING, // exception value thrown when closing a generator
JS_NO_CONSTANT, // compiler sentinel value
JS_THIS_POISON, // used in debug builds to catch tracing errors
JS_ARG_POISON, // used in debug builds to catch tracing errors
JS_SERIALIZE_NO_NODE, // an empty subnode in the AST serializer
JS_LAZY_ARGUMENTS, // lazy arguments value on the stack
JS_OPTIMIZED_ARGUMENTS, // optimized-away 'arguments' value
JS_IS_CONSTRUCTING, // magic value passed to natives to indicate construction
JS_OVERWRITTEN_CALLEE, // arguments.callee has been overwritten
JS_FORWARD_TO_CALL_OBJECT, // args object element stored in call object
JS_BLOCK_NEEDS_CLONE, // value of static block object slot
JS_HASH_KEY_EMPTY, // see class js::HashableValue
JS_ION_ERROR, // error while running Ion code
JS_ION_BAILOUT, // status code to signal EnterIon will OSR into Interpret
JS_GENERIC_MAGIC // for local use
);
// here must be jsval_layout struct defenition and *_IMPL functions
// but it moved to implementation part of unit, because used only internaly
//#if JS_BITS_PER_WORD == 32
//#define BUILD_JSVAL(tag, payload) ((((uint64)(uint32)(tag)) << 32) | (uint32)(payload))
//#elif JS_BITS_PER_WORD == 64
//#define BUILD_JSVAL(tag, payload) ((((uint64)(uint32)(tag)) << JSVAL_TAG_SHIFT) | (payload))
{ jsapi.h conversion - main SpiderMonkey unit }
const
CPU_SHIFT = {$ifdef CPU32}32{$else}JSVAL_TAG_SHIFT{$endif};
JSVAL_NULL : QWord = QWord((QWord(JSVAL_TAG_NULL) shl CPU_SHIFT) or 0);
JSVAL_ZERO : QWord = QWord((QWord(JSVAL_TAG_INT32) shl CPU_SHIFT) or 0);
JSVAL_ONE : QWord = QWord((QWord(JSVAL_TAG_INT32) shl CPU_SHIFT) or 1);
JSVAL_FALSE : QWord = QWord((QWord(JSVAL_TAG_BOOLEAN) shl CPU_SHIFT) or JS_FALSE);
JSVAL_TRUE : QWord = QWord((QWord(JSVAL_TAG_BOOLEAN) shl CPU_SHIFT) or JS_TRUE);
JSVAL_VOID : QWord = QWord((QWord(JSVAL_TAG_UNDEFINED) shl CPU_SHIFT) or 0);
type
jsint = JSInt32;
jsuint = JSUInt32;
//#define JSVAL_BITS(v) ((v).asBits)
//#define JSVAL_FROM_LAYOUT(l) (l)
//#define IMPL_TO_JSVAL(v) (v)
//#define JSID_BITS(id) ((id).asBits)
/// check if a jsval is NULL
function JSVAL_IS_NULL(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
/// check if jsval is VOID
function JSVAL_IS_VOID(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
/// check if jsval is a 32 bit integer
function JSVAL_IS_INT(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
/// convert a jsval into a 32 bit integer
// - there is no check that jsval is really a 32 bit integer: caller shall
// ensure this is the case (by using
function JSVAL_TO_INT(const v: jsval): jsint;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
const
JSVAL_INT_BITS = 32;
JSVAL_INT_MIN = jsint($80000000);
JSVAL_INT_MAX = jsint($7fffffff);
function INT_TO_JSVAL(i: int32): jsval;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_IS_DOUBLE(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_TO_DOUBLE(const v: jsval): Double;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function DOUBLE_TO_JSVAL(d: double): jsval;
{$ifdef HASINLINE}inline;{$endif}
function UINT_TO_JSVAL(i: uint32): jsval;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_IS_NUMBER(const v: jsval): boolean;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function JSVAL_IS_STRING(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_TO_STRING(const v: jsval): PJSString;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function STRING_TO_JSVAL(str: PJSString): jsval;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function JSVAL_IS_OBJECT(const v: jsval): Boolean;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function JSVAL_TO_OBJECT(const v: jsval): PJSObject;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function OBJECT_TO_JSVAL(obj: PJSObject): jsval;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function JSVAL_IS_BOOLEAN(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_TO_BOOLEAN(const v: jsval): JSBool;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function BOOLEAN_TO_JSVAL(b: JSBool): jsval;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_IS_PRIMITIVE(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_IS_GCTHING(const v: jsval): Boolean;
{$ifdef HASINLINE}inline;{$endif}
function JSVAL_TO_GCTHING(const v: jsval): Pointer;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function PRIVATE_TO_JSVAL(ptr: Pointer): jsval;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
function JSVAL_TO_PRIVATE(const v: jsval): Pointer;
{$ifndef WITHASSERT}{$ifdef HASINLINE}inline;{$endif}{$endif}
// A jsid is an identifier for a property or method of an object which is
// either a 31-bit signed integer, interned string or object. If XML is
// enabled, there is an additional singleton jsid value; see
// JS_DEFAULT_XML_NAMESPACE_ID below. Finally, there is an additional jsid
// value, JSID_VOID, which does not occur in JS scripts but may be used to
// indicate the absence of a valid jsid.
//
// A jsid is not implicitly convertible to or from a jsval; JS_ValueToId or
// JS_IdToValue must be used instead.
const
JSID_TYPE_STRING = $0;
JSID_TYPE_INT = $1;
JSID_TYPE_VOID = $2;
JSID_TYPE_OBJECT = $4;
JSID_TYPE_MASK = $7;
//TODO make jsid macro conversion jsapi.h line 308-462
//#define JSVAL_LOCK(cx,v) (JSVAL_IS_GCTHING(v) \
// ? JS_LockGCThing(cx, JSVAL_TO_GCTHING(v)) \
// : JS_TRUE)
//#define JSVAL_UNLOCK(cx,v) (JSVAL_IS_GCTHING(v) \
// ? JS_UnlockGCThing(cx, JSVAL_TO_GCTHING(v)) \
// : JS_TRUE)
// Property attributes, set in JSPropertySpec and passed to API functions
JSPROP_ENUMERATE = $01; { property is visible to for/in loop }
JSPROP_READONLY = $02; { not settable: assignment is no-op }
JSPROP_PERMANENT = $04; { property cannot be deleted }
JSPROP_GETTER = $10; { property holds getter function }
JSPROP_SETTER = $20; { property holds setter function }
JSPROP_SHARED = $40; { don't allocate a value slot for this
property; don't copy the property on
set of the same-named property in an
object that delegates to a prototype
containing this property }
JSPROP_INDEX = $80; { name is actually (jsint) index }
JSPROP_SHORTID = $100; { set in JSPropertyDescriptor.attrs
if getters/setters use a shortid }
JSFUN_STUB_GSOPS = $200; { use JS_PropertyStub getter/setter
instead of defaulting to class gsops
for property holding function }
JSFUN_CONSTRUCTOR = $400; { native that can be called as a ctor }
{*
* Specify a generic native prototype methods, i.e., methods of a class
* prototype that are exposed as static methods taking an extra leading
* argument: the generic |this| parameter.
*
* If you set this flag in a JSFunctionSpec struct's flags initializer, then
* that struct must live at least as long as the native static method object
* created due to this flag by JS_DefineFunctions or JS_InitClass. Typically
* JSFunctionSpec structs are allocated in static arrays.
}
JSFUN_GENERIC_NATIVE =$800;
JSFUN_FLAGS_MASK =$e00; { | of all the JSFUN_* flags }
function JS_Now: int64; cdecl; external SpiderMonkeyLib;
function JS_GetNaNValue(cx: PJSContext): jsval; cdecl; external SpiderMonkeyLib;
function JS_GetNegativeInfinityValue(cx: PJSContext): jsval; cdecl; external SpiderMonkeyLib;
function JS_GetPositiveInfinityValue(cx: PJSContext): jsval; cdecl; external SpiderMonkeyLib;
function JS_GetEmptyStringValue(cx: PJSContext): jsval; cdecl; external SpiderMonkeyLib;
function JS_GetEmptyString(cx: PJSRuntime): PJSString; cdecl; external SpiderMonkeyLib;
/// Converts a series of JS values, passed in an argument array,
// to their corresponding JS types
// - Format is a string of the following characters (spaces are insignificant),
// specifying the tabulated type conversions:
// $ b JSBool Boolean
// $ c uint16/jschar ECMA uint16, Unicode char
// $ i int32 ECMA int32
// $ u uint32 ECMA uint32
// $ j int32 Rounded int32 (coordinate)
// $ d jsdouble IEEE double
// $ I jsdouble Integral IEEE double
// $ S JSString * Unicode string, accessed by a JSString pointer
// $ W jschar * Unicode character vector, 0-terminated (W for wide)
// $ o JSObject * Object reference
// $ f JSFunction * Function private
// $ v jsval Argument value (no conversion)
// $ * N/A Skip this argument (no vararg)
// $ / N/A End of required arguments
// The variable argument list after format must consist of &b, &c, &s, e.g.,
// where those variables have the types given above. For the pointer types
// char *, JSString *, and JSObject *, the pointed-at memory returned belongs
// to the JS runtime, not to the calling native code. The runtime promises
// to keep this memory valid so long as argv refers to allocated stack space
// (so long as the native function is active).
// - Fewer arguments than format specifies may be passed only if there is a /
// in format after the last required argument specifier and argc is at least
// the number of required arguments. More arguments than format specifies
// may be passed without error; it is up to the caller to deal with trailing
// unconverted arguments.
// NOTE: we did not include this function yet, since it uses C varargs
// function JS_ConvertArguments(cx: PJSContext; argc: uintN; argv: pjsval;
// const format: PCChar): JSBool; varargs; cdecl; external SpiderMonkeyLib;
//!!!!!!!!!!!!!!!!!!TODO!!!!!!!!!!!!!!!!
// wery important to provide similiar but for Delphi!!
//TODO JS_Convert(Push)Arguments - provide conversation to(from) array of TVarRec?
/// JS_ConvertValue converts a JavaScript value, v, to the specified type
// - On success, the converted value is stored in *vp. Typically users of this
// function set vp to point to v, so that if conversion is successful, v now
// contains the converted value.
// - JS_ConvertValue calls other, type-specific conversion routines based
// on the type argument
// - Converting any value to JSTYPE_VOID always succeeds. The result is JSVAL_VOID.
// - Converting to JSTYPE_OBJECT works exactly like JS_ValueToObject.
// - Converting to JSTYPE_FUNCTION works like JS_ValueToFunction, but better:
// the result is a function object that has not been stripped of its lexical scope.
// It is safe to call the result (e.g. using JS_CallFunctionValue).
// - Converting to JSTYPE_STRING works exactly like JS_ValueToString.
// - Converting to JSTYPE_NUMBER works exactly like JS_ValueToNumber.
// - Converting to JSTYPE_BOOLEAN works exactly like JS_ValueToBoolean.
// - On success, JS_ConvertValue stores the converted value in *vp and returns JS_TRUE.
// - On error or exception, it returns JS_FALSE, and the value left in *vp is undefined
function JS_ConvertValue(cx: PJSContext; v: jsval; _type: JSType;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_ValueToObject converts a specified JavaScript value, v, to an object
// - On success, this function stores either NULL or a pointer to the resulting
// object in objp and returns JS_TRUE. Otherwise it returns JS_FALSE and
// the value left in objp is unspecified.
// - If v is JSVAL_NULL or JSVAL_VOID, the result is NULL.
// - If v is a boolean value, a number, or a string, the result is a new wrapper
// object of type Boolean, Number, or String.
// - Otherwise v is an object, and the result depends on the object. If v is a
// native JavaScript Object, this calls the object's valueOf method, if any. In
// any case, the result is not guaranteed to be the same object as v.
// (Implementation note: the object's JSObjectOps.defaultValue method is called
// with hint=JSTYPE_OBJECT.)
// - The resulting object is subject to garbage collection unless the variable
// objp is protected by a local root scope, an object property, or the
// JS_AddRoot function. Note that a local root scope is not sufficient to
// protect the resulting object in some cases involving the valueOf method!
function JS_ValueToObject(cx: PJSContext; v: jsval;
var objp: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// convert a jsval to a JSFunction
// - If v is a Function object, this returns the associated JSFunction.
// - If v is null, undefined, a boolean, a number, or a string, a TypeError
// is reported and JS_ValueToFunction returns nil
// - Otherwise, v is an object. The JavaScript engine attempts to convert it
// to a function, which can be pretty unsafe! You have been warned!
function JS_ValueToFunction(cx: PJSContext; v: jsval): PJSFunction;
cdecl; external SpiderMonkeyLib;
/// JS_ValueToString converts a specified JavaScript value, v, to a string.
// - It implements the ToString operator specified in ECMA 262-3 §9.8
// - The result is like the JavaScript expression ""+v.
// - If v is already a string, conversion succeeds.
// - If v is true, false, null, or undefined, conversion succeeds, and the
// result is the string "true", "false", "null", or "undefined", accordingly.
// - If v is a number, conversion succeeds, and the result is a
// string representation of that number as specified in ECMA 262-3 §9.8.1.
// This might be "NaN", "Infinity", or "-Infinity". Otherwise the result is a
// decimal representation of the number, possibly using exponential notation.
// - Otherwise v is an object. JS_ValueToString uses the steps below to convert
// it to a string. If at any point an error or exception occurs, or conversion
// succeeds, the rest of the steps are skipped. (This behavior is implemented by
// v's JSObjectOps.defaultValue method, so host objects can override it all.)
// If v.toString() is a function, it is called. If that method returns a
// primitive value, the value is converted to a string as described above and
// conversion succeeds. Otherwise, the resulting object's JSClass.convert
// callback is called. For standard classes, this is JS_ConvertStub, which
// simply calls v.valueOf() if present. If the convert callback produces a
// primitive value, the value is converted to a string as described above and
// conversion succeeds. Otherwise conversion fails with a TypeError.
// - On success, JS_ValueToString returns a pointer to a string. On error or
// exception, it returns NULL. This happens, for example, if v is an object
// and v.toString() throws an exception.
// - The resulting JSString is subject to garbage collection. Protect it using
// a local root, an object property, or the JS_AddRoot function.
function JS_ValueToString(cx: PJSContext; v: jsval): PJSString;
cdecl; external SpiderMonkeyLib;
/// Convert any JavaScript value to its source representation
function JS_ValueToSource(cx: PJSContext; v: jsval): PJSString;
cdecl; external SpiderMonkeyLib;
/// Convert any JavaScript value to a floating-point number of type jsdouble.
function JS_ValueToNumber(cx: PJSContext; v: jsval;
var dp: jsdouble): JSBool; cdecl; external SpiderMonkeyLib;
/// Check if the given double is in fact a 31 bit signed integer
function JS_DoubleIsInt32(d: jsdouble;
var i: jsint): JSBool; cdecl; external SpiderMonkeyLib;
/// Convert a JavaScript value to an integer type as specified by the ECMAScript standard
function JS_ValueToECMAInt32(cx: PJSContext; v: jsval;
var i: int32): JSBool; cdecl; external SpiderMonkeyLib;
/// Convert a JavaScript value to an integer type as specified
// by the ECMAScript standard
function JS_ValueToECMAUint32(cx: PJSContext; v: jsval;
var ui: uint32): JSBool; cdecl; external SpiderMonkeyLib;
// JS_ValueToInt32 is obsolete
function JS_ValueToInt32(cx: PJSContext; v: jsval;
var i: int32): JSBool; cdecl; external SpiderMonkeyLib;
/// Convert a JavaScript value to a 16 bit integer
// - ECMA ToUint16, e.g. for mapping a jsval to a Unicode point.
function JS_ValueToUint16(cx: PJSContext; v: jsval;
var ui16: uint16): JSBool; cdecl; external SpiderMonkeyLib;
/// Convert a JavaScript value to a boolean
function JS_ValueToBoolean(cx: PJSContext; v: jsval;
var b: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Determines the JS data type of a JS value
function JS_TypeOfValue(cx: PJSContext;
v: jsval): JSType; cdecl; external SpiderMonkeyLib;
// Determines the JS data type name of a JS value
function JS_GetTypeName(cx: PJSContext;
_type: JSType): PCChar; cdecl; external SpiderMonkeyLib;
/// Determine whether two JavaScript values are equal in the sense of the === operator
function JS_StrictlyEqual(cx: PJSContext;
v1, v2: jsval; equal: PJSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Determines if two jsvals are the same, as determined by the SameValue
// algorithm in ECMAScript 262, 5th edition
// - SameValue slightly differs from strict equality (===) in that +0 and -0 are
// not the same and in that NaN is the same as NaN
function JS_SameValue(cx: PJSContext; v1, v2: jsval;
equal: PJSBool): JSBool; cdecl; external SpiderMonkeyLib;
{ Initialization, locking, contexts, and memory allocation }
// It is important that the first runtime and first context be created in a
// single-threaded fashion, otherwise the behavior of the library is undefined
// See http://developer.mozilla.org/en/docs/Category:JSAPI_Reference
// some aliases defined in SM:
// #define JS_NewRuntime JS_Init
// #define JS_DestroyRuntime JS_Finish
// #define JS_LockRuntime JS_Lock
// #define JS_UnlockRuntime JS_Unlock
type
/// defines how function JS_NewRuntime() instantiate its threading model
JSUseHelperThreads =
(JS_NO_HELPER_THREADS, JS_USE_HELPER_THREADS);
/// Initialize the JavaScript runtime
// - JS_NewRuntime initializes the JavaScript runtime environment.
// Call JS_NewRuntime before making any other API calls.
// - JS_NewRuntime allocates memory for the JSRuntime and initializes certain
// internal runtime structures. maxbytes specifies the number of allocated
// bytes after which garbage collection is run.
function JS_NewRuntime(maxbytes: uint32; useHelperThreads: JSUseHelperThreads): PJSRuntime;
cdecl; external SpiderMonkeyLib;
/// Release the JavaScript runtime
procedure JS_DestroyRuntime(rt: PJSRuntime); cdecl; external SpiderMonkeyLib;
/// Free all resources used by the JS engine, not associated with specific runtimes
procedure JS_ShutDown;
function JS_GetRuntimePrivate(rt: PJSRuntime): pointer; cdecl; external SpiderMonkeyLib;
procedure JS_SetRuntimePrivate(rt: PJSRuntime; data: pointer); cdecl; external SpiderMonkeyLib;
/// indicates to the JS engine that the calling thread is entering a region
// of code that may call into the JSAPI but does not block
procedure JS_BeginRequest(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// indicates to the JS engine that the calling thread is leaving a region
// of code that may call into the JSAPI but does not block
procedure JS_EndRequest(cx: PJSContext); cdecl; external SpiderMonkeyLib;
// OBSOLETE procedure JS_YieldRequest(cx: PJSContext); cdecl; external SpiderMonkeyLib;
//OBSOLETE type
//OBSOLETE jsrefcount = JSInt32;
//OBSOLETE function JS_SuspendRequest(cx: PJSContext): jsrefcount; cdecl; external SpiderMonkeyLib;
//OBSOLETE procedure JS_ResumeRequest(cx: PJSContext; saveDepth: jsrefcount); cdecl; external SpiderMonkeyLib;
/// checked is is within a code region protected by JS_BeginRequest()
function JS_IsInRequest(cx: PJSContext): JSBool; cdecl; external SpiderMonkeyLib;
procedure JS_LockRuntime(rt: PJSRuntime); cdecl; external SpiderMonkeyLib name 'JS_Lock';
procedure JS_UnlockRuntime(rt: PJSRuntime); cdecl; external SpiderMonkeyLib name 'JS_Unlock';
/// Specifies a callback function that is automatically called whenever
// a JSContext is created or destroyed
function JS_SetContextCallback(rt: PJSRuntime; cxCallback: JSContextCallback): JSContextCallback;
cdecl; external SpiderMonkeyLib;
/// Create a new JSContext
function JS_NewContext(rt: PJSRuntime; stackChunkSize: size_t): PJSContext;
cdecl; external SpiderMonkeyLib;
/// Release a new JSContext
procedure JS_DestroyContext(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// Release a new JSContext without performing garbage collection
procedure JS_DestroyContextNoGC(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// Release a new JSContext with potential garbage collection
// - this function may or may not perform garbage collection: the engine makes
// an educated guess as to whether enough memory would be reclaimed to justify the work
procedure JS_DestroyContextMaybeGC(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// read access to a JSContext field for application-specific data
function JS_GetContextPrivate(cx: PJSContext): Pointer;
cdecl; external SpiderMonkeyLib;
/// write access to a JSContext field for application-specific data
procedure JS_SetContextPrivate(cx: PJSContext; data: Pointer);
cdecl; external SpiderMonkeyLib;
/// retrieves a pointer to the JSRuntime with which a specified JSContext,
// is associated
function JS_GetRuntime(cx: PJSContext): PJSRuntime; cdecl; external SpiderMonkeyLib;
/// cycles through the JS contexts associated with a particular JSRuntime
function JS_ContextIterator(rt: PJSRuntime; iterp: PPJSContext): PJSContext;
cdecl; external SpiderMonkeyLib;
/// retrieve the JavaScript version number used within a specified executable script context
function JS_GetVersion(cx: PJSContext): JSVersion;
cdecl; external SpiderMonkeyLib;
// JS_SetVersion is not supported now Use CompartmentOptions in JS_NewGlobalObject
/// retrieve the JavaScript version text used within a specified executable script context
function JS_VersionToString(version: JSVersion): PCChar;
cdecl; external SpiderMonkeyLib;
/// configure a JSContext to use a specific version of the JavaScript language
function JS_StringToVersion(_string: PCChar): JSVersion; cdecl; external SpiderMonkeyLib;
const
JSOPTION_EXTRA_WARNINGS = 1 shl 0; { warn on dubious practice }
JSOPTION_WERROR = 1 shl 1; { convert warning to error }
JSOPTION_VAROBJFIX = 1 shl 2; { make JS_EvaluateScript use
the last object on its 'obj'
params scope chain as the
ECMA 'variables object' }
JSOPTION_PRIVATE_IS_NSISUPPORTS = 1 shl 3; { context private data points
to an nsISupports subclass }
JSOPTION_COMPILE_N_GO = 1 shl 4; { caller of JS_Compile*Script
promises to execute compiled
script once only; enables
compile-time scope chain
resolution of consts. }
{ = 1 shl 5 is currently unused. }
{ = 1 shl 6 is currently unused. }
{ = 1 shl 7 is currently unused. }
JSOPTION_DONT_REPORT_UNCAUGHT = 1 shl 8; { When returning from the
outermost API call, prevent
uncaught exceptions from
being converted to error
reports }
{ = 1 shl 9 is currently unused. }
{ = 1 shl 10 is currently unused. }
{ = 1 shl 11 is currently unused. }
JSOPTION_NO_SCRIPT_RVAL = 1 shl 12; { A promise to the compiler
that a null rval out-param
will be passed to each call
to JS_ExecuteScript. }
JSOPTION_UNROOTED_GLOBAL = 1 shl 13; { The GC will not root the
contexts' global objects
(see JS_GetGlobalObject),
leaving that up to the
embedding. }
JSOPTION_BASELINE = 1 shl 14; { Baseline compiler. }
JSOPTION_PCCOUNT = 1 shl 15; { Collect per-op execution counts }
JSOPTION_TYPE_INFERENCE = 1 shl 16; { Perform type inference. }
JSOPTION_STRICT_MODE = 1 shl 17; { Provides a way to force
strict mode for all code
without requiring
"use strict" annotations. }
JSOPTION_ION = 1 shl 18; { IonMonkey }
JSOPTION_ASMJS = 1 shl 19; { optimizingasm.js compiler }
JSOPTION_MASK = 1 shl 20 - 1;
function JS_GetOptions(cx: PJSContext): uint32; cdecl; external SpiderMonkeyLib;
function JS_SetOptions(cx: PJSContext; options: uint32): uint32; cdecl; external SpiderMonkeyLib;
function JS_ToggleOptions(cx: PJSContext; options: uint32): uint32; cdecl; external SpiderMonkeyLib;
function JS_GetImplementationVersion: PCChar; cdecl; external SpiderMonkeyLib ;
// here is some *Compartment* functions - Compartment is obsolete, so we do not import them
// osolete
// extern JS_PUBLIC_API(JSObject *)
// JS_GetGlobalObject(JSContext *cx);
//
// extern JS_PUBLIC_API(void)
// JS_SetGlobalObject(JSContext *cx, JSObject *obj);
/// initializes the built-in JavaScript global properties.
// - These include all the standard ECMAScript global properties defined in
// ECMA 262-3 §15: Array, Boolean, Date, decodeURI, decodeURIComponent,
// encodeURI, encodeURIComponent, Error, eval, EvalError, Function, Infinity,
// isNaN, isFinite, Math, NaN, Number, Object, parseInt, parseFloat, RangeError,
// ReferenceError, RegExp, String, SyntaxError, TypeError, undefined, and URIError
// - and set obj as a global object for cx!
function JS_InitStandardClasses(cx: PJSContext; obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Resolve id, which must contain either a string or an int, to a standard
// class name in obj if possible, defining the class's constructor and/or
// prototype and storing true in resolved
// - If id does not name a standard
// class or a top-level property induced by initializing a standard class,
// store false in *resolved and just return true. Return false on error,
// as usual for JSBool result-typed API entry points.
// - This API can be called directly from a global object class's resolve op,
// to define standard classes lazily. The class's enumerate op should call
// JS_EnumerateStandardClasses(cx, obj), to define eagerly during for..in
// loops any classes not yet resolved lazily.
function JS_ResolveStandardClass(cx: PJSContext; obj: PJSObject; id: jsid;
var resolved: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
function JS_EnumerateStandardClasses(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
type
JSIdArray = record
length: jsint;
vector: TjsidVector; //* actually, length jsid words */
end;
PJSIdArray = ^JSIdArray;
/// Enumerate any already-resolved standard class ids into ida, or into a new
// JSIdArray if ida is null
// - Return the augmented array on success, null on failure with ida
// (if it was non-null on entry) destroyed
function JS_EnumerateResolvedStandardClasses(cx: PJSContext; obj: PJSObject;
ida: PJSIdArray): PJSIdArray; cdecl; external SpiderMonkeyLib;
//extern JS_PUBLIC_API(JSBool)
//JS_GetClassObject(JSContext *cx, JSObject *obj, JSProtoKey key,
// JSObject **objp);
//
//extern JS_PUBLIC_API(JSObject *)
//JS_GetScopeChain(JSContext *cx);
//
//extern JS_PUBLIC_API(JSObject *)
//JS_GetGlobalForObject(JSContext *cx, JSObject *obj);
//
//extern JS_PUBLIC_API(JSObject *)
//JS_GetGlobalForScopeChain(JSContext *cx);
// here is #ifdef JS_HAS_CTYPES - currently not shure we can use it.
/// return the callee function of a JSNative callback
function JS_CALLEE(cx: PJSContext; vp: Pjsval): jsval;
{$IFDEF HASINLINE}inline;{$ENDIF}
/// return the this object of a JSNative callback
function JS_THIS(cx: PJSContext; vp: Pjsval): jsval;
{$IFDEF HASINLINE}inline;{$ENDIF}
/// return the this object of a JSNative callback
function JS_THIS_OBJECT(cx: PJSContext; vp: Pjsval): PJSObject;
{$IFDEF HASINLINE}inline;{$ENDIF}
/// points to the first argument of a JSNative callback
function JS_ARGV(cx: PJSContext; vp: Pjsval): PjsvalVector;
{$IFDEF HASINLINE}inline;{$ENDIF}
/// get the return value of a JSNative callback
function JS_RVAL(cx: PJSContext; vp: Pjsval): jsval;
{$IFDEF HASINLINE}inline;{$ENDIF}
/// set the return value of a JSNative callback
procedure JS_SET_RVAL(cx: PJSContext; vp: Pjsval; v: jsval);
{$IFDEF HASINLINE}inline;{$ENDIF}
/// low-level API used by JS_THIS() macro
function JS_ComputeThis(cx: PJSContext; vp: Pjsval): jsval; cdecl; external SpiderMonkeyLib;
function JS_malloc(cx: PJSContext; nbytes: size_t): Pointer;
cdecl; external SpiderMonkeyLib;
function JS_realloc(cx: PJSContext; p: Pointer; nbytes: size_t): Pointer;
cdecl; external SpiderMonkeyLib;
procedure JS_free(cx: PJSContext; p: Pointer);
cdecl; external SpiderMonkeyLib;
procedure JS_updateMallocCounter(cx: PJSContext; nbytes: size_t);
cdecl; external SpiderMonkeyLib;
function JS_strdup(cx: PJSContext; s: PCChar): PCChar;
cdecl; external SpiderMonkeyLib;
//JS_NewNumberValue Obsolete since JavaScript mozjs17 use JS_NumberValue instead
//https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_NewNumberValue
function JS_NumberValue(d: double): jsval;
cdecl; external SpiderMonkeyLib name 'JS_NumberValue_';
/// The JS_Add*Root functions add a C/C++ variable to the garbage collector's root set,
// the set of variables used as starting points each time the collector checks
// to see what memory is reachable
// - The garbage collector aggressively collects
// and recycles memory that it deems unreachable, so roots are often necessary
// to protect data from being prematurely collected.
// - vp/spp/opp/rp is the address of a C/C++ variable (or field, or array element)
// of type JSString *, JSObject *, or jsval. This variable must already be initialized.
// (For example, it must not be an uninitialized local variable. That could cause
// sporadic crashes during garbage collection, which can be hard to debug.)
// The variable must remain in memory until the balancing call to JS_RemoveRoot.
// Note that this means that if the root is meant to live past the end of a function,
// the address of a local (stack-based) variable may not be used for rp.
// If JS_Add*Root succeeds, then as long as this variable points to a JavaScript
// value or pointer to GC-thing, that value/GC-thing is protected from garbage collection.
// If the variable points to an object, then any memory reachable from its properties
// is automatically protected from garbage collection, too.
// - JS_AddGCThingRoot allows the caller to have a single root that may hold
// either strings or objects. A jsval is not a GC-thing (it has tag bits and
// may be a different size altogether) and thus the address of a jsval
// variable must not be passed to JS_AddGCThingRoot.
// - Do not pass a pointer to a JS string or object to any of these functions—rp
// must point to a variable, the location of the pointer itself, and not an object or string.
function JS_AddValueRoot(cx: PJSContext; vp: Pjsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// add a JSString variable to the garbage collector's root set
// - similar to JS_AddValueRoot(), but with a JSString value
function JS_AddStringRoot(cx: PJSContext; rp: PPJSString): JSBool;
cdecl; external SpiderMonkeyLib;
/// add a JSObject variable to the garbage collector's root set
// - similar to JS_AddValueRoot(), but with a JSObject value
function JS_AddObjectRoot(cx: PJSContext; rp: PPJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// remove a jsval variable from the garbage collector's root set
function JS_RemoveValueRoot(cx: PJSContext; vp: Pjsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// remove a JSString variable from the garbage collector's root set
function JS_RemoveStringRoot(cx: PJSContext; rp: PPJSString): JSBool;
cdecl; external SpiderMonkeyLib;
/// remove a JSObject variable from the garbage collector's root set
function JS_RemoveObjectRoot(cx: PJSContext; rp: PPJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_AddGCThingRoot(cx: PJSContext; rp: PPointer): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_RemoveGCThingRoot(cx: PJSContext; rp: PPointer): JSBool;
cdecl; external SpiderMonkeyLib;
/// launch the GarbageCollection process of the given execution RunTime
procedure JS_GC(rt: PJSRuntime); cdecl; external SpiderMonkeyLib;
/// check if it would be worth it to launch the GarbageCollection process
// of the given execution RunTime, in the given context
// - this function is a no-op if there is nothing interesting to garbage
procedure JS_MaybeGC(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// defines a Garbage Collection call-back function
function JS_SetGCCallback(rt: PJSRuntime; cb: JSGCCallback): JSGCCallback;
cdecl; external SpiderMonkeyLib;
/// JS_IsAboutToBeFinalized() checks if the given object is going to be finalized
// at the end of the current GC
// - When called outside of the context of a GC, this function will return false
// - Typically this function is used on weak references, where the reference
// should be nulled out or destroyed if the given object is about to be finalized
// - The argument to JS_IsAboutToBeFinalized is an in-out param: when the
// function returns false, the object being referenced is still alive, but the
// garbage collector might have moved it. In this case, the reference passed
// to JS_IsAboutToBeFinalized will be updated to the object's new location
// - Callers of this method are responsible for updating any state that is
// dependent on the object's address. For example, if the object's address is
// used as a key in a hashtable, then the object must be removed and
// re-inserted with the correct hash
function JS_IsAboutToBeFinalized(obj: PPJSObject): JSBool; cdecl; external SpiderMonkeyLib;
type
JSGCParamKey = (
// Maximum nominal heap before last ditch GC.
JSGC_MAX_BYTES = 0,
// Number of JS_malloc bytes before last ditch GC.
JSGC_MAX_MALLOC_BYTES = 1,
// Obsolete since JSAPI 12 JSGC_STACKPOOL_LIFESPAN = 2,
// Obsolete since JSAPI 6 JSGC_TRIGGER_FACTOR = 3,
//* Amount of bytes allocated by the GC. */
JSGC_BYTES = 3,
//* Number of times when GC was invoked. */
JSGC_NUMBER = 4,
//* Max size of the code cache in bytes. */
JSGC_MAX_CODE_CACHE_BYTES = 5,
//* Select GC mode. */
JSGC_MODE = 6,
//* Number of GC chunks waiting to expire. */
JSGC_UNUSED_CHUNKS = 7,
//* Total number of allocated GC chunks. */
JSGC_TOTAL_CHUNKS = 8,
//* Max milliseconds to spend in an incremental GC slice. */
JSGC_SLICE_TIME_BUDGET = 9,
//* Maximum size the GC mark stack can grow to. */
JSGC_MARK_STACK_LIMIT = 10,
(*
* GCs less than this far apart in time will be considered 'high-frequency GCs'.
* See setGCLastBytes in jsgc.cpp.
*)
JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11,
(* Start of dynamic heap growth. *)
JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12,
(* End of dynamic heap growth. *)
JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13,
(* Upper bound of heap growth. *)
JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14,
(* Lower bound of heap growth. *)
JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15,
(* Heap growth for low frequency GCs. *)
JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16,
(*
* If false, the heap growth factor is fixed at 3. If true, it is determined
* based on whether GCs are high- or low- frequency.
*)
JSGC_DYNAMIC_HEAP_GROWTH = 17,
(* If true, high-frequency GCs will use a longer mark slice. *)
JSGC_DYNAMIC_MARK_SLICE = 18,
(* Number of megabytes of analysis data to allocate before purging. *)
JSGC_ANALYSIS_PURGE_TRIGGER = 19,
(* Lower limit after which we limit the heap growth. *)
JSGC_ALLOCATION_THRESHOLD = 20,
(*
* We decommit memory lazily. If more than this number of megabytes is
* available to be decommitted, then JS_MaybeGC will trigger a shrinking GC
* to decommit it.
*)
JSGC_DECOMMIT_THRESHOLD = 21
);
JSGCMode = (
//* Perform only global GCs. */
JSGC_MODE_GLOBAL = 0,
//* Perform per-compartment GCs until too much garbage has accumulated. */
JSGC_MODE_COMPARTMENT = 1,
//* Collect in short time slices rather than all at once. Implies
// * JSGC_MODE_COMPARTMENT.
JSGC_MODE_INCREMENTAL = 2
);
procedure JS_SetGCParameter(rt: PJSRuntime; key: JSGCParamKey; value: uint32);
cdecl; external SpiderMonkeyLib;
function JS_GetGCParameter(rt: PJSRuntime; key: JSGCParamKey): uint32;
cdecl; external SpiderMonkeyLib;
procedure JS_SetGCParameterForThread(cx: PJSContext; key: JSGCParamKey; value: uint32);
cdecl; external SpiderMonkeyLib;
function JS_GetGCParameterForThread(cx: PJSContext; key: JSGCParamKey): uint32;
cdecl; external SpiderMonkeyLib;
/// Set the size of the native stack that should not be exceeded
// - to disable stack size checking, just pass 0 as value
procedure JS_SetNativeStackQuota(tr: PJSRuntime; stackSize: size_t);
cdecl; external SpiderMonkeyLib;
/// Flush the code cache for the current thread
// - The operation might be delayed if the cache cannot be flushed currently
// because native code is currently executing.
procedure JS_FlushCaches(cx: PJSContext); cdecl; external SpiderMonkeyLib;
type
/// * Finalizes external strings created by JS_NewExternalString.
PJSStringFinalizer = ^JSStringFinalizer;
JSStringFinalizerOp = procedure(fin: PJSStringFinalizer; chars: Pjschar); cdecl;
JSStringFinalizer = record
finalize: JSStringFinalizerOp;
end;
/// Creates a new JSString whose characters are stored in external memory, i.e.,
// memory allocated by the application, not the JavaScript engine
// - Since the program allocated the memory, it will need to free it;
// this happens in an external string finalizer indicated by the type parameter.
// - chars is Pointer to the first element of an array of jschars.
// This array is used as the character buffer of the JSString to be created.
// The array must be populated with the desired character data before JS_NewExternalString
// is called, and the array must remain in memory, with its contents unchanged,
// for as long as the JavaScript engine needs to hold on to it.
// (Ultimately, the string will be garbage collected, and the JavaScript engine will
// call the string finalizer callback, allowing the application to free the array)
// - The text buffer array does not need to be zero-terminated.
function JS_NewExternalString(cx: PJSContext; chars: pjschar; length: size_t;
const fin: PJSStringFinalizer): PJSString; cdecl; external SpiderMonkeyLib;
/// Returns the external-string finalizer index for this string, or -1 if it is
// an "internal" (native to JS engine) string.
//TODO - in current compiled version there is no this functions. seems like a BUG!!!!!!!!
//JS_GetExternalStringGCType
//function JS_IsExternalString(rt: PJSRuntime; str: PJSString): intN; cdecl; external SpiderMonkeyLib;
// For detailed comments on the function pointer types, see jspubtd.h
type
JSClassInternal = procedure; cdecl;
PJSClass = ^JSClass;
JSClass = record
name: PCChar;
flags: uint32;
//* Mandatory non-null function pointer members. */
addProperty: JSPropertyOp;
delProperty: JSDeletePropertyOp;
getProperty: JSPropertyOp;
setProperty: JSStrictPropertyOp;
enumerate: pointer; //JSEnumerateOp; or JSNewEnumerateOp
resolve: JSResolveOp;
convert: JSConvertOp;
//* Optionally non-null members start here. */
finalize: JSFinalizeOp; {
in jsapi.h file comments finalize is Mandatory
but in real it is Optionally
in examles finalize is not assigned
}
checkAccess: JSCheckAccessOp;
call: JSNative;
hasInstance: JSHasInstanceOp;
construct: JSNative;
trace: JSTraceOp;
reserved: array [0..39] of pointer;
end;
const
/// JSClass instance objects have private slot
JSCLASS_HAS_PRIVATE = 1 shl 0;
/// JSClass instance has JSNewEnumerateOp hook
JSCLASS_NEW_ENUMERATE = 1 shl 1;
/// JSClass instance has JSNewResolveOp hook
JSCLASS_NEW_RESOLVE = 1 shl 2;
/// JSClass instance private is (nsISupports
JSCLASS_PRIVATE_IS_NSISUPPORTS = 1 shl 3;
/// JSClass instance objects are DOM
JSCLASS_IS_DOMJSCLASS = 1 shl 4;
/// Correctly implements GC read and write barriers
JSCLASS_IMPLEMENTS_BARRIERS = 1 shl 5;
/// JSClass instance objects of this class act like the value undefined,
// in some contexts
JSCLASS_EMULATES_UNDEFINED = 1 shl 6;
/// Reserved for embeddings.
JSCLASS_USERBIT1 = 1 shl 7;
/// JSClass instance room for 8 flags below
JSCLASS_RESERVED_SLOTS_SHIFT = 8;
/// JSClass instance and 16 above this field
JSCLASS_RESERVED_SLOTS_WIDTH = 8;
JSCLASS_RESERVED_SLOTS_MASK = (JSUint32(1) shl JSCLASS_RESERVED_SLOTS_WIDTH)-1;
JSCLASS_HIGH_FLAGS_SHIFT = (JSCLASS_RESERVED_SLOTS_SHIFT + JSCLASS_RESERVED_SLOTS_WIDTH);
JSCLASS_IS_ANONYMOUS = (1 shl (JSCLASS_HIGH_FLAGS_SHIFT+0));
JSCLASS_IS_GLOBAL = (1 shl (JSCLASS_HIGH_FLAGS_SHIFT+1));
JSCLASS_INTERNAL_FLAG2 = (1 shl (JSCLASS_HIGH_FLAGS_SHIFT+2));
JSCLASS_INTERNAL_FLAG3 = (1 shl (JSCLASS_HIGH_FLAGS_SHIFT+3));
// JSProto_LIMIT is length of #include "jsproto.tbl"
JSProto_LIMIT = 38;
JSCLASS_GLOBAL_SLOT_COUNT = (JSProto_LIMIT * 3 + 25);
JSCLASS_GLOBAL_FLAGS = JSCLASS_IS_GLOBAL or
(((JSCLASS_GLOBAL_SLOT_COUNT) and JSCLASS_RESERVED_SLOTS_MASK) shl JSCLASS_RESERVED_SLOTS_SHIFT);
procedure JS_DestroyIdArray(cx: PJSContext; ida: PJSIdArray);
cdecl; external SpiderMonkeyLib;
function JS_ValueToId(cx: PJSContext; v: jsval; var id: jsid): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_IdToValue(cx: PJSContext; id: jsid; var v: jsval): JSBool;
cdecl; external SpiderMonkeyLib;
const
/// used by JS_ResolveStub() callback: resolve a qualified property id
JSRESOLVE_QUALIFIED = $01;
/// used by JS_ResolveStub() callback: resolve on the left of assignment
JSRESOLVE_ASSIGNING = $02;
/// used by JS_ResolveStub() callback: 'if (o.p)...' or '(o.p) ?...:...'
JSRESOLVE_DETECTING = $04;
/// used by JS_ResolveStub() callback: var, const, or function prolog op
JSRESOLVE_DECLARING = $08;
/// used by JS_ResolveStub() callback: class name used when constructing
JSRESOLVE_CLASSNAME = $10;
/// used by JS_ResolveStub() callback: resolve inside a with statement
JSRESOLVE_WITH = $20;
/// default callback matching JSPropertyOp prototype of JSClass
function JS_PropertyStub(cx: PJSContext; var obj: PJSObject; var id: jsid; vp: pjsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// default callback matching JSStrictPropertyOp prototype of JSClass
function JS_StrictPropertyStub(cx: PJSContext; var obj: PJSObject; var id: jsid;
_strict: JSBool; vp: pjsval): JSBool; cdecl; external SpiderMonkeyLib;
/// default callback matching JSEnumerateOp prototype of JSClass
function JS_EnumerateStub(cx: PJSContext; var obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// default callback matching JSResolveOp prototype of JSClass
function JS_ResolveStub(cx: PJSContext; var obj: PJSObject; var id: jsid): JSBool;
cdecl; external SpiderMonkeyLib;
/// default callback matching JSConvertOp prototype of JSClass
function JS_ConvertStub(cx: PJSContext; var obj: PJSObject; _type: JSType; vp: pjsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// default callback matching JSDeletePropertyOp prototype of JSClass
function JS_DeletePropertyStub(cx: PJSContext; var obj: PJSObject; var id: jsid;
succeeded: PJSBool): JSBool; cdecl; external SpiderMonkeyLib;
type
/// JS object constant definition
JSConstDoubleSpec = record
dval: jsdouble;
name: PCChar;
flags: uint8;
spare: array[0..2] of uint8;
end;
PJSConstDoubleSpec = ^JSConstDoubleSpec;
TJSConstDoubleSpecArray = array of JSConstDoubleSpec;
/// JS object property defenition
PJSJitInfo = pointer;
/// Wrappers to replace StrictPropertyOp for JSPropertySpecs
// - This will allow us to pass one JSJitInfo per function with the property
// spec, without additional field overhead.
JSStrictPropertyOpWrapper = record
op: JSStrictPropertyOp;
info: PJSJitInfo;
end;
/// Wrappers to replace PropertyOp for JSPropertySpecs
// - This will allow us to pass one JSJitInfo per function with the property
// spec, without additional field overhead.
JSPropertyOpWrapper = record
op: JSPropertyOp;
info: PJSJitInfo;
end;
/// defines custom JSProperty
// - This will allow us to pass one JSJitInfo per function with the property
// spec, without additional field overhead.
JSPropertySpec = record
name: PCChar;
tinyid: int8;
flags: uint8;
getter: JSPropertyOpWrapper;
setter: JSStrictPropertyOpWrapper;
end;
PJSPropertySpec = ^JSPropertySpec;
TJSPropertySpecDynArray = array of JSPropertySpec;
/// Wrappers to replace JSNatives for JSFunctionSpecs
// - This will allow us to pass one JSJitInfo per function with the property
// spec, without additional field overhead.
JSNativeWrapper = record
op: JSNative;
info: PJSJitInfo;
end;
/// Defines a single function for an object
JSFunctionSpec = record
name: PCChar;
call: JSNativeWrapper;
nargs: uint16;
flags: uint16;
selfHostedName: PCChar;
end;
PJSFunctionSpec = ^JSFunctionSpec;
TJSFunctionSpecArray = array of JSFunctionSpec;
/// Make a JSClass accessible to JavaScript code by creating its prototype,
// constructor, properties, and functions.
// - see https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_InitClass
function JS_InitClass(cx: PJSContext; obj: PJSObject; parent_proto: PJSObject;
clasp: PJSClass; _constructor: JSNative; nargs: uintN;
ps: PJSPropertySpec; fs: PJSFunctionSpec;
static_ps: PJSPropertySpec; static_fs: PJSFunctionSpec): PJSObject;
cdecl; external SpiderMonkeyLib ;
/// retrieve the JSClass of a given object
// - JS_GetClass() expects only one parameter in every case
function JS_GetClass(obj: PJSObject): PJSClass;
cdecl; external SpiderMonkeyLib name 'JS_GetClass';
function JS_InstanceOf(cx: PJSContext; obj: PJSObject; clasp: PJSClass; argv: pjsval): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_HasInstance(cx: PJSContext; obj: PJSObject; v: jsval; bp: PJSBool): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_GetPrivate(obj: PJSObject): Pointer;
cdecl; external SpiderMonkeyLib;
procedure JS_SetPrivate(obj: PJSObject; data: Pointer);
cdecl; external SpiderMonkeyLib;
function JS_GetInstancePrivate(cx: PJSContext; obj: PJSObject; clasp: PJSClass; argv: pjsval): Pointer;
cdecl; external SpiderMonkeyLib;
function JS_GetPrototype(cx: PJSContext; obj: PJSObject; var protop: PJSObject):JSBool;
cdecl; external SpiderMonkeyLib;
function JS_SetPrototype(cx: PJSContext; obj: PJSObject; proto: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_GetParent(obj: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
function JS_SetParent(cx: PJSContext; obj: PJSObject; parent: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_GetConstructor(cx: PJSContext; proto: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Get a unique identifier for obj, good for the lifetime of obj (even if it
// is moved by a copying GC)
// - Return false on failure (likely out of memory), and true with idp
// containing the unique id on success
function JS_GetObjectId(cx: PJSContext; obj: PJSObject; idp: Pjsid): JSBool;
cdecl; external SpiderMonkeyLib;
type
ZoneSpecifier = JSuintptr;
const
zsFreshZone = JSuintptr(0);
zsSystemZone = JSuintptr(1);
zsSpecificZones = JSuintptr(2);
type
CompartmentOptions = record
zoneSpec: ZoneSpecifier;
hasVersion: boolean;
version: JSVersion;
end;
PCompartmentOptions = ^CompartmentOptions;
/// JS_NewGlobalObject creates a new global object based on the specified class
// - The new object has no parent. It initially has no prototype either,
// since it is typically the first object created;
// call JS_InitStandardClasses to create all the standard objects,
// including Object.prototype, and set the global object's prototype
function JS_NewGlobalObject(cx: PJSContext; clasp: PJSClass; principals: PJSPrincipals;
options: PCompartmentOptions): PJSObject; cdecl; external SpiderMonkeyLib;
/// declare entering a safe compartment of the specified object
// - NB: This API is infallible; a NULL return value does not indicate error
function JS_EnterCompartment(cx: PJSContext; target: PJSObject): PJSCompartment;
cdecl; external SpiderMonkeyLib;
/// declare leaving the safe compartment of the specified object
procedure JS_LeaveCompartment(cx: PJSContext; oldCompartment: PJSCompartment);
cdecl; external SpiderMonkeyLib;
/// JS_NewObject creates a new object based on a specified class, prototype,
// and parent object
// - cx is a pointer to a context associated with the runtime
// in which to establish the new object.
// - clasp is a pointer to an existing class to use for internal methods, such as finalize
// - proto is an optional pointer to the prototype object with which to associate the new object
// see https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_NewObject
function JS_NewObject(cx: PJSContext; clasp: PJSClass; proto: PJSObject; parent: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Queries the [[Extensible]] property of the object.
function JS_IsExtensible(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Unlike JS_NewObject, JS_NewObjectWithGivenProto does not compute a default
// proto if proto's actual parameter value is null
function JS_NewObjectWithGivenProto(cx: PJSContext; clasp: PJSClass;
proto: PJSObject; parent: PJSObject): PJSObject; cdecl; external SpiderMonkeyLib;
/// Freeze obj, and all objects it refers to, recursively
// - This will not recurse through non-extensible objects, on the assumption
// that those are already deep-frozen.
function JS_DeepFreezeObject(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// Freezes an object; see ES5's Object.freeze(obj) method
function JS_FreezeObject(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// As of SpiderMonkey 1.8.8, JS_ConstructObject and JS_ConstructObjectWithArguments
// have been removed from the JSAPI.
// The preferred alternative is to save a copy of the constructor function for the class,
// then to call it using JS_New.
// function JS_ConstructObject(cx: PJSContext; clasp: PJSClass; proto:
// PJSObject; parent: PJSObject): PJSObject; cdecl; external SpiderMonkeyLib;
// function JS_ConstructObjectWithArguments(cx: PJSContext; clasp: PJSClass; proto: PJSObject;
// parent: PJSObject; argc: uintN; argv: pjsval): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create an object as though by using the new keyword and a JavaScript function
// - for instance:
// ! JS_New(cx, ctor, argc, argv)
// is equivalent to the JavaScript expression
// ! new ctor(argv[0], argv[1], ... argv[argc-1]).
// If ctor is not an object that can be used as a constructor, a TypeError is raised.
function JS_New(cx: PJSContext; ctor: PJSObject; argc: uintN; argv: Pjsval): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create an object that is a property of another object
function JS_DefineObject(cx: PJSContext; obj: PJSObject; name: PCChar; clasp: PJSClass;
proto: PJSObject; attrs: uintN): PJSObject; cdecl; external SpiderMonkeyLib;
/// JS_DefineConstDoubles creates one or more properties for a specified object, obj,
// where each property consists of a double value.
//- Each property is automatically assigned attributes as specified in the flags
// field of the JSConstDoubleSpec structure pointed to by cds.
//- If flags is set to 0, the attributes for the property are automatically set
// to JSPROP_PERMANENT | JSPROP_READONLY
function JS_DefineConstDoubles(cx: PJSContext; obj: PJSObject; cds: PJSConstDoubleSpec): JSBool;
cdecl; external SpiderMonkeyLib ;
/// JS_DefineProperties creates properties on a specified object, obj.
// Each property is defined as though by calling JS_DefinePropertyWithTinyId
function JS_DefineProperties(cx: PJSContext; obj: PJSObject; ps: PJSPropertySpec): JSBool; cdecl; external SpiderMonkeyLib ;
/// JS_DefineProperty is the fundamental operation on which several more convenient,
// higher-level functions are based, including JS_DefineFunction, JS_DefineFunctions,
// JS_DefineProperties, JS_DefineConstDoubles, JS_DefineObject, and JS_InitClass.
// - It differs from JS_SetProperty in that:
// it does not behave like ordinary property assignment in the JavaScript language;
// it allows the application to specify additional details (getter, setter, and attrs)
// governing the new property's behavior;
// it never calls a setter;
// it can call the JSClass.addProperty callback when JS_SetProperty would not,
// because it can replace an existing property.
// - The parameters specify the new property's name, initial stored value, getter,
// setter, and property attributes (attrs).
function JS_DefineProperty(cx: PJSContext; obj: PJSObject; const name: PCChar;
value: jsval; getter: JSPropertyOp; setter: JSStrictPropertyOp; attrs: uintN): JSBool;
cdecl; external SpiderMonkeyLib;
/// JS_DefinePropertyById is the same as JS_DefineProperty but takes a jsid for the property name
function JS_DefinePropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
value: jsval; getter: JSPropertyOp; setter: JSStrictPropertyOp; attrs: uintN): JSBool;
cdecl; external SpiderMonkeyLib;
/// JS_DefineOwnProperty implements the ECMAScript defined function Object.defineProperty
// - So the same restrictions apply as for that function
// (e.g. it is not possible to change a non-configurable property).
// - descriptor is supposed to be a property descriptor, this means you need to
// create an object with properties such as value, writable, get or set.
// - See Object.defineProperty for a list of possible fields.
// - A getter or setter defined with this functions will be observable from JS code.
function JS_DefineOwnProperty(cx: PJSContext; obj: PJSObject; id: jsid;
descriptor: jsval; bp: PJSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Determine the attributes (JSPROP_* flags) of a property on a given object
//- If the object does not have a property by that name, *foundp will be
// JS_FALSE and the value of *attrsp is undefined.
function JS_GetPropertyAttributes(cx: PJSContext; obj: PJSObject;
const name: PCChar; var attrsp: uintN; var foundp: JSBool): JSBool;
cdecl; external SpiderMonkeyLib;
/// Set the attributes of a property on a given object
// - If the object does not have a property by that name, *foundp will be
// JS_FALSE and nothing will be altered.
function JS_SetPropertyAttributes(cx: PJSContext; obj: PJSObject; const name: PCChar;
attrs: uintN; var foundp: JSBool): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_DefinePropertyWithTinyId(cx: PJSContext; obj: PJSObject; const name: PCChar;
tinyid: int8; value: jsval; getter: JSPropertyOp; setter: JSStrictPropertyOp;
attrs: uintN): JSBool; cdecl; external SpiderMonkeyLib;
// JS_AliasProperty is Obsolete since JSAPI 8
//function JS_AliasProperty(cx: PJSContext; obj: PJSObject; name: PAnsiChar; alias: PAnsiChar): JSBool;
// cdecl; external SpiderMonkeyLib ;
/// Determine whether a property is already physically present on a JSObject
// - For native objects—objects whose properties are stored in the default data
// structure provided by SpiderMonkey, these functions simply check that data
// structure to see if the specified field is present.
// They do not search anywhere else for the property. This means that:
// - The prototype chain of obj is not searched.
// - The object's JSClass.resolve hook is not called, so lazily defined
// properties are not found. (This is the only API that can directly detect
// that a lazily resolved property has not yet been resolved.)
// - Shared, permanent, delegated properties are not found. (Such properties
// are an implementation detail of SpiderMonkey. They are meant to be a
// transparent optimization; this is the only API that breaks the abstraction)
function JS_AlreadyHasOwnProperty(cx: PJSContext; obj: PJSObject; const name: PCChar;
var found: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Determine whether a property is already physically present on a JSObject
// - this function will locate the property not by name, but by its jsid
function JS_AlreadyHasOwnPropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
var found: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_HasProperty searches an object, obj, and its prototype chain, for
// a property with the specified name
// - It behaves like the JavaScript expression name in obj
function JS_HasProperty(cx: PJSContext; obj: PJSObject; const name: PCChar;
var found: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_HasProperty searches an object, obj, and its prototype chain, for
// a property with the specified jsid
function JS_HasPropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
var found: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Determine if a specified property exists, according to its name
// - On success, *vp receives the stored value of the property, if any.
function JS_LookupProperty(cx: PJSContext; obj: PJSObject; name: PCChar;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Determine if a specified property exists, according to its jsid
function JS_LookupPropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
function JS_LookupPropertyWithFlags(cx: PJSContext; obj: PJSObject;
const name: PCChar; flags: uintN; var vp: jsval): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_LookupPropertyWithFlagsById(cx: PJSContext; obj: PJSObject;
id: jsid; flags: uintN; var objp: PJSObject; var vp: jsval): JSBool;
cdecl; external SpiderMonkeyLib;
type
JSPropertyDescriptor = record
obj: PJSObject;
attrs: uintN;
shortid: uintN;
getter: JSPropertyOp;
setter: JSStrictPropertyOp;
value: jsval;
end;
PJSPropertyDescriptor = ^JSPropertyDescriptor;
/// Finds a specified property of an object and gets a detailed description of that property
function JS_GetPropertyDescriptorById(cx: PJSContext; obj: PJSObject; id: jsid; flags: uintN;
objp: PPJSObject; desc: PJSPropertyDescriptor): JSBool; cdecl; external SpiderMonkeyLib;
/// Finds a specified property by name and retrieves its value
// - JS_GetProperty examines a specified JS object obj and its prototype chain
// for a property with the specified name
// - It behaves like the JavaScript expression obj[name].
function JS_GetProperty(cx: PJSContext; obj: PJSObject; const name: PCChar;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Finds a specified property by jsid and retrieves its value
// - JS_GetProperty examines a specified JS object obj and its prototype chain
// for a property with the specified jsid
function JS_GetPropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Finds a specified property by jsid and retrieves its value or a default value
function JS_GetPropertyByIdDefault(cx: PJSContext; obj: PJSObject; id: jsid;
def: jsval; var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
// The following functions behave like JS_GetProperty and
// JS_GetPropertyById except when operating on E4X XML objects
// extern JS_PUBLIC_API(JSBool) JS_GetMethodById(JSContext *cx,
// JSObject *obj, jsid id, JSObject **objp, jsval *vp);
// extern JS_PUBLIC_API(JSBool) JS_GetMethod(JSContext *cx,
// JSObject *obj, const char *name, JSObject **objp, jsval *vp);
/// JS_SetProperty assigns the value vp to the property name of the object obj
// - it behaves like the JavaScript expression obj[name] = v
// - it will create the property if it does not exist, but for details see
// https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_SetProperty
// - remark: in mozila description "sealed" object they talking about is OBSOLETE!
function JS_SetProperty(cx: PJSContext; obj: PJSObject; const name: PCChar;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_SetProperty assigns the value vp to the property jsid of the object obj
function JS_SetPropertyById(cx: PJSContext; obj: PJSObject; id: jsid;
vp: Pjsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Removes a specified property from an object
function JS_DeleteProperty(cx: PJSContext; obj: PJSObject;
const name: PCChar): JSBool; cdecl; external SpiderMonkeyLib;
/// Removes a specified property from an object and return the property value
function JS_DeleteProperty2(cx: PJSContext; obj: PJSObject; const name: PCChar;
var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Removes a specified property from an object
function JS_DeletePropertyById(cx: PJSContext; obj: PJSObject; id: jsid): JSBool;
cdecl; external SpiderMonkeyLib;
/// Removes a specified property from an object and return the property value
function JS_DeletePropertyById2(cx: PJSContext; obj: PJSObject; id: jsid; var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// define unicode property
// - see JS_DefineProperty for details
function JS_DefineUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; const value: jsval;
getter: JSPropertyOp; setter: JSStrictPropertyOp; attrs: uintN): JSBool;
cdecl; external SpiderMonkeyLib;
/// Determine the attributes (JSPROP_* flags) of a property on a given object
// - If the object does not have a property by that name, *foundp will be
// - JS_FALSE and the value of *attrsp is undefined.
function JS_GetUCPropertyAttributes(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t;
var attrsp: uintN; var foundp: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// Set the attributes of a property on a given object.
// - If the object does not have a property by that name, *foundp will be
// - JS_FALSE and nothing will be altered.
function JS_SetUCPropertyAttributes(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t;
attrs: uintN; var foundp: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
function JS_DefineUCPropertyWithTinyId(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; tinyid: int8; value: jsval;
getter: JSPropertyOp; setter: JSStrictPropertyOp; attrs: uintN): JSBool;
cdecl; external SpiderMonkeyLib;
/// Determine whether a property is already physically present on a JSObject
// - For native objects—objects whose properties are stored in the default
// data structure provided by SpiderMonkey, these functions simply check that
// data structure to see if the specified field is present. They do not search
// anywhere else for the property. This means that:
// The prototype chain of obj is not searched.
// The object's JSClass.resolve hook is not called, so lazily defined
// properties are not found.
// (This is the only API that can directly detect that a lazily resolved
// property has not yet been resolved.)
// Shared, permanent, delegated properties are not found.
// - (Such properties are an implementation detail of SpiderMonkey.
// They are meant to be a transparent optimization; this is the only API
// that breaks the abstraction)
function JS_AlreadyHasOwnUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; var foundp: JSBool): JSBool;
cdecl; external SpiderMonkeyLib;
/// same as JS_HasProperty but unicode
function JS_HasUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; var found: JSBool): JSBool;
cdecl; external SpiderMonkeyLib;
/// Determine if a specified property exists
// - On success, *vp receives the stored value of the property, if any.
function JS_LookupUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
function JS_GetUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; var vp : jsval): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_SetUCProperty(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; var vp : jsval): JSBool;
cdecl; external SpiderMonkeyLib;
function JS_DeleteUCProperty2(cx: PJSContext; obj: PJSObject;
const name: Pjschar; namelen: size_t; var rval: jsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// JS_NewArrayObject creates a new array object with the specified length.
// - If vector is non-null, then for each index i from 0 to length - 1,
// - JS_NewArrayObject defines an enumerable array element with the value
// vector[i] on the new array (This means that if length is nonzero and vector
// is null, the result is like the JavaScript expression new Array(length): i.e.
// the new array has the specified length, but it doesn't have any elements)
// - On success, JS_NewArrayObject returns the new array object.
// - Otherwise it reports an error as though by calling JS_ReportOutOfMemory
// and returns NULL.
// - IMPORTANT! It is often better to call JS_NewArrayObject(cx, 0, NULL),
// store the returned object in a GC root, and then populate its elements
// with JS_SetElement or JS_DefineElement: this avoids unrooted jsvals in
// vector from being subject to garbage collection until the new object
// has been populated
function JS_NewArrayObject(cx: PJSContext; length: jsint;
vector: PjsvalVector): PJSObject; cdecl; external SpiderMonkeyLib;
/// check if the supplied object is an array
function JS_IsArrayObject(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// retrieve the length of an object arrray
function JS_GetArrayLength(cx: PJSContext; obj: PJSObject;
var length: jsuint): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_SetArrayLength sets the length property of an object obj
// - length indicates the number of elements
// - JS_SetArrayLength(cx, obj, n) is exactly the same as setting the length
// property of obj to n using JS_SetProperty
// - This is true even if obj is not an Array object
// - You can call JS_SetArrayLength either to set the number of elements for an
// array object you created without specifying an initial number of elements,
// or to change the number of elements allocated for an array
// - If you set a shorter array length on an existing array, the elements
// that no longer fit in the array are destroyed
// - Setting the number of array elements does not initialize those elements
// - To initialize an element call JS_DefineElement
// - If you call JS_SetArrayLength on an existing array, and length
// is less than the highest index number for previously defined elements, all
// elements greater than or equal to length are automatically deleted
// - On success, JS_SetArrayLength returns JS_TRUE. Otherwise it returns JS_FALSE.
function JS_SetArrayLength(cx: PJSContext; obj: PJSObject; length: jsuint): JSBool;
cdecl; external SpiderMonkeyLib ;
/// JS_DefineElement defines a numeric property for a specified object, obj
// - Starting in SpiderMonkey 1.8.5, jsval can store a full 32-bit integer,
// so index is any 32-bit integer
function JS_DefineElement(cx: PJSContext; obj: PJSObject; index: jsint; value: jsval;
getter: JSPropertyOp; setter: JSPropertyOp; attrs: uintN): JSBool;
cdecl; external SpiderMonkeyLib;
// JS_AliasElement OBSOLETE
function JS_AlreadyHasOwnElement(cx: PJSContext; obj: PJSObject; index: jsint;
var foundp: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// check if an object array has an element at the supplied index
function JS_HasElement(cx: PJSContext; obj: PJSObject; index: jsint;
var foundp: JSBool): JSBool; cdecl; external SpiderMonkeyLib;
/// determine if a specified numeric property exists
// - examines a specified JavaScript object, obj, for a numeric property numbered index
// - On success, *vp receives the stored value of the property, if any.
function JS_LookupElement(cx: PJSContext; obj: PJSObject; index: jsint;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// find a specified numeric property of an object and return its current value
function JS_GetElement(cx: PJSContext; obj: PJSObject; index: jsint;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// assign a value to a numeric property of an object
function JS_SetElement(cx: PJSContext; obj: PJSObject; index: jsint;
var vp: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// removes a specified element or numeric property from an object
function JS_DeleteElement(cx: PJSContext; obj: PJSObject; index: jsint): JSBool;
cdecl; external SpiderMonkeyLib;
/// removes a specified element or numeric property from an object
// - this function also returns the deleted element
function JS_DeleteElement2(cx: PJSContext; obj: PJSObject; index: jsint;
var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
//JS_ClearScope - OBSOLETE
/// JS_Enumerate gets the ids of all own properties of the specified object, obj,
// - that have the JSPROP_ENUMERATE attribute. This calls obj's JSClass.enumerate hook.
// - On success, JS_Enumerate returns a pointer to the first element of an
// array of property IDs.
// - The application must free this array using JS_DestroyIdArray. On error
// or exception, JS_Enumerate returns NULL.
// - Warning: The property ids in the returned JSIdArray are subject to
// garbage collection.
// - Therefore a program that loops over the property ids must either root them
// all, ensure that the properties are not deleted (in a multithreaded program
// this requires even greater care), or ensure that garbage collection does not occur
function JS_Enumerate(cx: PJSContext; obj: PJSObject): PJSIdArray;
cdecl; external SpiderMonkeyLib;
/// Create an object to iterate over enumerable properties of obj, in arbitrary
// - property definition order. NB: This differs from longstanding for..in loop
// - order, which uses order of property definition in obj.
function JS_NewPropertyIterator(cx: PJSContext; obj: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Return true on success with *idp containing the id of the next enumerable
// - property to visit using iterobj, or JSID_IS_VOID if there is no such property
// - left to visit. Return false on error.
function JS_NextProperty(cx: PJSContext; iterobj: PJSObject; var idp: jsid): JSBool;
cdecl; external SpiderMonkeyLib;
/// Check whether a running script may access a given object property.
// - The access check proceeds as follows.
// - If obj has custom JSObjectOps, the access check is delegated to the
// JSObjectOps.checkAccess callback.
// - Otherwise, if obj's class has a non-null JSClass.checkAccess callback,
// then it is called to perform the check.
// - Otherwise, if a runtime-wide check-object-access callback has been
// installed by calling JS_SetCheckObjectAccessCallback, then that is called
// to perform the check.
// - Otherwise, access is granted.
// - On success, JS_CheckAccess returns JS_TRUE, *vp is set to the current
// value stored value, of the specified property, and *attrsp is set to the
// property's attributes.
// - On error or exception, including if access is denied, JS_CheckAccess
// returns JS_FALSE, and the values left in *vp and *attrsp are undefined
function JS_CheckAccess(cx: PJSContext; obj: PJSObject; id: jsid; mode: JSAccessMode;
var vp: jsval; var attrsp: uintN): JSBool; cdecl; external SpiderMonkeyLib;
/// read access an object's reserved slots
// - If a JSClass has JSCLASS_HAS_RESERVED_SLOTS(n) in its flags, with n > 0,
// or has a non-null JSClass.reserveSlots callback, then objects of that class
// have n reserved slots in which the application may store data.
// These fields are not directly exposed to scripts.
// - Reserved slots may contain any jsvalue, and the garbage collector will
// hold the value alive as long as the object itself is alive
// - Reserved slots may also contain private values to store pointer values
// (whose lowest bit is 0) or uint32_t, when non-JavaScript values must be stored;
// the garbage collector ignores such values when it sees them.
// - Note that private values must not be exposed directly to JavaScript.
// It's only legal to store and retrieve data from private values. They cannot
// be returned from functions, set as properties on objects, embedded in
// JavaScript arrays, and so on
// - New objects' reserved slots are initialized to undefined.
// - TODO - collision in MSDN no parameter vp: pjsval but in jsapi.h is!
function JS_GetReservedSlot(cx: PJSContext; obj: PJSObject; index: uint32;
vp: pjsval): JSBool; cdecl; external SpiderMonkeyLib;
/// write access an object's reserved slots
function JS_SetReservedSlot(cx: PJSContext; obj: PJSObject; index: uint32;
v: jsval): JSBool; cdecl; external SpiderMonkeyLib;
// here must be Security protocol (*Principals*) but we do not use it.
// Mozilla recomend to not use it
// see https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_User_Guide#The_best_security_is_no_security_(really)
{ Functions and scripts }
/// JS_NewFunction creates a new JavaScript function implemented in Delphi
// - To create a new function implemented in JavaScript, use JS_CompileFunction
// - call is a C/C++ function pointer that the new function wraps
// - nargs is the number of arguments the function expects
// - flags must be 0. parent may be used to specify the new function's parent;
// NULL is usually the right thing here.
// - name is the name to assign to the function. If name is NULL, the new function
// has no name. (JS_GetFunctionId, passed the new function, will return NULL)
// - On success, JS_NewFunction returns a pointer to the newly created function
// - Otherwise it reports an out-of-memory error and returns NULL
function JS_NewFunction(cx: PJSContext; call: JSNative; nargs: uintN; flags: uintN;
parent: PJSObject; const name: PCChar): PJSFunction; cdecl; external SpiderMonkeyLib;
/// Create the function with the name given by the id
// - JSID_IS_STRING(id) must be true.
function JS_NewFunctionById(cx: PJSContext; call: JSNative; nargs: uintN; flags: uintN;
parent: PJSObject; id: jsid): PJSFunction; cdecl; external SpiderMonkeyLib;
/// Retrieves the object for a specified function.
// - fun should be a native function or JSAPI-compiled function!
// (result of a call to JS_CompileFunction, JS_CompileUCFunction)
function JS_GetFunctionObject(fun: PJSFunction): PJSObject; cdecl; external SpiderMonkeyLib;
/// Return the function's identifier as a JSString, or null if fun is unnamed.
// - The returned string lives as long as fun, so you don't need to root a saved
// - reference to it if fun is well-connected or rooted, and provided you bound
// - the use of the saved reference by fun's lifetime.
function JS_GetFunctionId(fun: PJSFunction): PJSString; cdecl; external SpiderMonkeyLib;
/// Return JSFUN_* flags for a specified function
function JS_GetFunctionFlags(fun: PJSFunction): uintN; cdecl; external SpiderMonkeyLib;
/// Return the arity (params count) for a specified function
function JS_GetFunctionArity(fun: PJSFunction): uint16; cdecl; external SpiderMonkeyLib;
/// Test whether a given object is a Function
function JS_ObjectIsFunction(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// check is the supplied object is callable
function JS_ObjectIsCallable(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
/// JS_DefineFunctions creates zero or more functions and makes them properties
// (methods) of a specified object, obj, as if by calling JS_DefineFunction repeatedly
// - fs is a pointer to the first element of an array of JSFunctionSpec records
// - This array is usually defined as a static global, with each record
// initialized using JS_FS or JS_FN.
// - Each array element defines a single function: its name, the native Delphi
// implementation, the number of JavaScript arguments the function expects,
// and any function flags and property attributes.
// - The last element of the array must contain 0 values
function JS_DefineFunctions(cx: PJSContext; obj: PJSObject;
fs: PJSFunctionSpec): JSBool; cdecl; external SpiderMonkeyLib;
/// Create a native function and assign it as a property to a specified JS object
function JS_DefineFunction(cx: PJSContext; obj: PJSObject; name: PCChar;
call: JSNative; nargs: uintN; attrs: uintN): PJSFunction;
cdecl; external SpiderMonkeyLib;
/// Unicode version to create a native function
function JS_DefineUCFunction(cx: PJSContext; obj: PJSObject; name: Pjschar;
namelen: size_t; call: JSNative; nargs: uintN; attrs: uintN): PJSFunction;
cdecl; external SpiderMonkeyLib;
/// Create a native function and assign it as a property to a specified JS object
function JS_DefineFunctionById(cx: PJSContext; obj: PJSObject; id: jsid;
call: JSNative; nargs: uintN; attrs: uintN): PJSFunction;
cdecl; external SpiderMonkeyLib;
/// JS_CloneFunctionObject creates a new function object from funobj
// - The new object has the same code and argument list as funobj,
// but uses parent as its enclosing scope.
// - This can be helpful if funobj is an extant function that you wish to use as
// if it were enclosed by a newly-created global object
function JS_CloneFunctionObject(cx: PJSContext; funobj: PJSObject;
parent: PJSObject): PJSObject; cdecl; external SpiderMonkeyLib;
/// validate a JavaScript statement
// - Given a buffer, return JS_FALSE if the buffer might become a valid
// javascript statement with the addition of more lines
// - Otherwise return JS_TRUE. The intent is to support interactive compilation - accumulate
// - lines in a buffer until JS_BufferIsCompilableUnit is true, then pass it to
// the compiler.
function JS_BufferIsCompilableUnit(cx: PJSContext; obj: PJSObject;
bytes: PCChar; length: size_t): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_CompileScript compiles a script source, for execution
// - The script is associated with a JS object.
// - source is the string containing the text of the script.
// - length indicates the size of the text version of the script in characters.
// - filename is the name of the file (or URL) containing the script.
// - This information is included in error messages if an error occurs during
// compilation.
// - Similarly, lineno is used to report the line number of the script or file
// where an error occurred during compilation.
// - If the script is not part of a larger document, lineno should be 1 (as the
// first line of a file is universally considered to be line 1, not line 0).
// - On success, JS_CompileScript and JS_CompileUCScript return an object
// representing the newly compiled script.
// - Otherwise, they report an error and return NULL.
// - To compile a script from an external file source rather than passing the
// actual script as an argument, use JS_CompileFile instead of JS_CompileScript
function JS_CompileScript(cx: PJSContext; obj: PJSObject; bytes: PCChar;
length: size_t; filename: PCChar; lineno: uintN): PJSScript;
cdecl; external SpiderMonkeyLib ;
/// Unicode version to compiles a script
function JS_CompileUCScript(cx: PJSContext; obj: PJSObject;
chars: Pjschar; length: size_t; filename: PCChar; lineno: uintN): PJSScript;
cdecl; external SpiderMonkeyLib ;
type
TCStringVector = array[0..0] of PCChar;
PCStringVector = ^TCStringVector;
/// JS_CompileFunction compiles a function from a text string, bytes, and
// optionally associates it with a JS object, obj
// - name is the name to assign to the newly created function.
// - nargs is the number of arguments the function takes, and argnames
// is a pointer to the first element of an array of names to assign each argument.
// - The number of argument names should match the number of arguments specified
// in nargs.
// - body is a string containing the source code of the function.
// - length is the length of the source code in characters.
// - filename is the name of the file (or URL) containing the function. This
// information is used in error messages if an error occurs during compilation.
// - Similarly, lineno is used to report the line number where an error occurred
// during compilation.
// - If both obj and name are non-null, the new function becomes a method of obj
// (a new property is defined on obj with the given name and the new Function
// object as its value).
function JS_CompileFunction(cx: PJSContext; obj: PJSObject; name: PCChar;
nargs: uintN; argnames: PCStringVector; bytes: PCChar; length: size_t;
filename: PCChar; lineno: uintN): PJSFunction; cdecl; external SpiderMonkeyLib;
/// JS_CompileUCFunction() is the Unicode version of JS_CompileFunction() function
function JS_CompileUCFunction(cx: PJSContext; obj: PJSObject; name: PCChar;
nargs: uintN; argnames: PCStringVector;
chars: Pjschar; length: size_t;
filename: PCChar; lineno: uintN): PJSFunction; cdecl; external SpiderMonkeyLib;
/// decompiles a Script Object back into its JavaScript representation
function JS_DecompileScriptObject(cx: PJSContext; scriptObj: PJSObject;
name: PCChar; indent: uintN): PJSString; cdecl; external SpiderMonkeyLib;
const
/// API extension: OR this into indent to avoid pretty-printing the decompiled
// source resulting from JS_DecompileFunction{,Body}.
JS_DONT_PRETTY_PRINT: uintN = $8000;
/// generates the complete source code of a function declaration from a compiled function
function JS_DecompileFunction(cx: PJSContext; fun: PJSFunction; indent: uintN): PJSString;
cdecl; external SpiderMonkeyLib;
/// generate the source code representing the body of a function, minus the
// function keyword, name, parameters, and braces
function JS_DecompileFunctionBody(cx: PJSContext; fun: PJSFunction; indent: uintN): PJSString;
cdecl; external SpiderMonkeyLib;
/// Execute a compiled script.
// - On success, *rval receives the value from the last executed expression
// statement processed in the script
// - NB: JS_ExecuteScript and the JS_Evaluate*Script* quadruplets use the obj
// parameter as the initial scope chain header, the 'this' keyword value, and
// the variables object (ECMA parlance for where 'var' and 'function' bind
// names) of the execution context for script.
// - Using obj as the variables object is problematic if obj's parent (which is
// the scope chain link; see JS_SetParent and JS_NewObject) is not null: in
// this case, variables created by 'var x = 0', e.g., go in obj, but variables
// created by assignment to an unbound id, 'x = 0', go in the last object on
// the scope chain linked by parent.
// - ECMA calls that last scoping object the "global object", but note that many
// embeddings have several such objects. ECMA requires that "global code" be
// executed with the variables object equal to this global object. But these
// JS API entry points provide freedom to execute code against a "sub-global",
// i.e., a parented or scoped object, in which case the variables object will
// differ from the last object on the scope chain, resulting in confusing and
// non-ECMA explicit vs. implicit variable creation.
// - Caveat embedders: unless you already depend on this buggy variables object
// binding behavior, you should call JS_SetOptions(cx, JSOPTION_VAROBJFIX) or
// JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_VAROBJFIX) -- the latter if
// someone may have set other options on cx already -- for each context in the
// application, if you pass parented objects as the obj parameter, or may ever
// pass such objects in the future.
// - Why a runtime option? The alternative is to add six or so new API entry
// points with signatures matching the following six, and that doesn't seem
// worth the code bloat cost. Such new entry points would probably have less
// obvious names, too, so would not tend to be used. The JS_SetOption call,
// OTOH, can be more easily hacked into existing code that does not depend on
// the bug; such code can continue to use the familiar JS_EvaluateScript,
// etc., entry points.
function JS_ExecuteScript(cx: PJSContext; obj: PJSObject; scriptObj: PJSObject;
var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_EvaluateScript compiles and executes a script in the specified scope (obj)
// - Warning: this function perform conversion from Ansi to unicode (internaly
// SM is unicode), so for best performance convert your scripts from RawUTF8/Ansi
// to unicode using SynCommons Utf8DecodeToRawUnicode /
// WinAnsiConvert.AnsiToRawUnicode and use JS_EvaluateUCScript()
// - For details about scope see JS_ExecuteScript
// - We recomend to use JSOPTION_VAROBJFIX and some of quality tools like
// jslint/jshint - jshint is prefered, because it suppotr ECMA5 (let strict
// and so on), jslint - only ECMA3
// - to avoid declare variables in global use var x = 10 instead of x = 10
function JS_EvaluateScript(cx: PJSContext; obj: PJSObject;
bytes: PCChar; length: uintN; filename: PCChar; lineno: uintN;
var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Unicode version of JS_EvaluateScript
// - For details about scope see JS_ExecuteScript
// - remember length is "the length of src, in characters" not in bytes
// for pjschar = PRawUnicode use length = (length(RawUnicode) shr 1)
function JS_EvaluateUCScript(cx: PJSContext; obj: PJSObject;
chars: pjschar; length: uintN; filename: PCChar;
lineno: uintN; var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// JS_CallFunction calls a specified function, fun, on an object, obj
// - In terms of function execution, the object is treated as this
// - Warning: Calling JS_CallFunction is safe only if the fun argument could
// be passed to JS_GetFunctionObject safely: that is, it is a function
// implemented by a JSNative or JSFastNative or the result of a call
// to JS_CompileFunction, JS_CompileUCFunction, JS_CompileFunctionForPrincipals,
// or JS_CompileUCFunctionForPrincipals.
// - Passing any other JSFunction pointer can lead to a crash or worse
function JS_CallFunction(cx: PJSContext; this: PJSObject; fun: PJSFunction;
argc: uintN; argv: pjsval; var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Call a method of an object by name.
// - JS_CallFunctionName executes a function-valued property, name, belonging
// to a specified JS object, obj
function JS_CallFunctionName(cx: PJSContext; this: PJSObject; const name: PCChar;
argc: uintN; argv: Pjsval; var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
/// Calls a specified JS function
// - fval is function value
function JS_CallFunctionValue(cx: PJSContext; this: PJSObject; fval: jsval;
argc: uintn; argv: Pjsval; var rval: jsval): JSBool; cdecl; external SpiderMonkeyLib;
// These functions allow setting an operation callback that will be called
// from the thread the context is associated with some time after any thread
// triggered the callback using JS_TriggerOperationCallback(cx).
//
// In a threadsafe build the engine internally triggers operation callbacks
// under certain circumstances (i.e. GC and title transfer) to force the
// context to yield its current request, which the engine always
// automatically does immediately prior to calling the callback function.
// The embedding should thus not rely on callbacks being triggered through
// the external API only.
//
// Important note: Additional callbacks can occur inside the callback handler
// if it re-enters the JS engine. The embedding must ensure that the callback
// is disconnected before attempting such re-entry.
/// Set a callback function that is automatically called periodically while
// JavaScript code runs
// - cx is a Pointer to a JSContext in which this callback was installed.
// - The callback may use this context to call JSAPI functions, but it
// should first use JS_SetOperationCallback
// - to set the context's operation callback to NULL. Otherwise the
// engine may call the operation callback again, reentering it.
// - Provides request. In JS_THREADSAFE builds, the JavaScript engine calls
// this callback only from within an active request on cx.
// - The callback does not need to call JS_BeginRequest()
// - Some common uses for an operation callback are:
// To run garbage collection periodically, by calling JS_MaybeGC;
// To periodically take a break from script execution to update the UI (though
// note that Mozilla does not do this, by design);
// To enforce application limits on the amount of time a script may run.
// (In this case, the callback may terminate the script by returning JS_FALSE.)
function JS_SetOperationCallback(cx: PJSContext;
callback: JSOperationCallback): JSOperationCallback; cdecl; external SpiderMonkeyLib;
/// retrieve the callback function that is automatically called periodically while
// JavaScript code runs in the given execution context
function JS_GetOperationCallback(cx: PJSContext): JSOperationCallback;
cdecl; external SpiderMonkeyLib;
/// triggers a callback set using JS_SetOperationCallback
procedure JS_TriggerOperationCallback(rt: PJSRuntime); cdecl; external SpiderMonkeyLib;
/// determines if a script or function is currently executing in a specified
// JSContext, cx
// - If a script is executing, JS_IsRunning returns JS_TRUE
// - Otherwise it returns JS_FALSE.
function JS_IsRunning(cx: PJSContext): JSBool; cdecl; external SpiderMonkeyLib;
{ Strings process }
// NB: JS_NewUCString takes ownership of bytes on success, avoiding a copy;
// but on error (signified by null return), it leaves chars owned by the
// caller. So the caller must free bytes in the error case, if it has no use
// for them. In contrast, all the JS_New//StringCopy// functions do not take
// ownership of the character memory passed to them -- they copy it.
/// JS_NewStringCopyN allocates space for a JavaScript string and its underlying storage,
// and copies n characters from a C character array, s, into the new JSString.
// - JS_NewUCStringCopyN is the Unicode version of the function.
// The two functions differ only in the type of the character array s;
// both functions create ordinary JavaScript strings, and all
// JavaScript strings are made up of 16-bit characters.
// - If the array s contains more than n characters, the new string contains
// a truncated version of the original string. The string may contain null
// characters (#0). They are copied into the new string like any other character.
// - You can use JS_NewStringCopyN to copy binary data or to copy only
// a certain portion of a C string into a JavaScript string.
// - On success, JS_NewStringCopyN and JS_NewUCStringCopyN return a pointer
// to the new JS string.
// - Otherwise they return NULL.
function JS_NewStringCopyN(cx: PJSContext; s: PCChar; n: size_t): PJSString;
cdecl; external SpiderMonkeyLib;
/// Create a new JavaScript string based on a null-terminated C string
function JS_NewStringCopyZ(cx: PJSContext; s: PCChar): PJSString;
cdecl; external SpiderMonkeyLib;
/// get an interned string from a given text buffer
// — that is, a JSString that is protected from GC and automatically shared
// with other code that needs a JSString with the same value
// - JS_InternUCString and JS_InternUCStringN are the Unicode versions of the function.
// - Each JSRuntime keeps a table of all existing interned strings.
// If an interned string already exists with the desired value, these functions
// return the existing string. Otherwise a new string is created and added to the table.
// - Strings created with these functions are protected from garbage collection
// for the lifetime of the JSRuntime
// - On success, these functions return a pointer to the interned string.
// - Otherwise they report an error and return NULL.
function JS_InternString(cx: PJSContext; s: PCChar): PJSString;
cdecl; external SpiderMonkeyLib;
/// get an interned string from a given null-terminated C string
function JS_InternJSString(cx: PJSContext; str: PJSString): PJSString;
cdecl; external SpiderMonkeyLib;
/// Creates and returns a new string, using the memory starting at buf and
// ending at buf + length as the character storage.
// - The character array, buf, MUST be allocated on the heap using JS_malloc.
// - On success, the JavaScript engine adopts responsibility for memory
// management of this region.
// - The application must not read, write, or free the buffer.
// - This allows the JavaScript engine to avoid needless data copying.
// - On success, JS_NewUCString return a pointer to the new string.
// -On error or exception, they return NUL
// - !!!!! DO NOT USE THIS FUNCTION WITH DELPHI strings!!!!!!!!!
function JS_NewUCString(cx: PJSContext; s: pjschar; len: size_t): PJSString;
cdecl; external SpiderMonkeyLib;
/// unicode version of JS_NewStringCopyN
// - faster then JS_NewStringCopyN because no need to transform into unicode
function JS_NewUCStringCopyN(cx: PJSContext; s: pjschar; n: size_t): PJSString;
cdecl; external SpiderMonkeyLib;
/// unicode version of JS_NewStringCopyZ
function JS_NewUCStringCopyZ(cx: PJSContext; const s: pjschar): PJSString;
cdecl; external SpiderMonkeyLib;
/// unicode version of JS_InternString (faster)
function JS_InternUCStringN(cx: PJSContext; const s: pjschar; len: size_t): PJSString;
cdecl; external SpiderMonkeyLib;
function JS_InternUCString(cx: PJSContext; const s: pjschar): PJSString;
cdecl; external SpiderMonkeyLib;
/// Compares two JS strings, str1 and str2
// - If the strings are identical in content and length, JS_CompareStrings
// stores 0 in *result.
// - If str1 is less than str2, *result is less than 0.
// ( If str1 is greater than str2, *result is greater than 0.
// - On success the function returns JS_TRUE.
// - On error, it returns JS_FALSE and the value in result is unchanged.
// - This function imposes a total order on all JavaScript strings, the same
// order imposed by the JavaScript string comparison operators (<, <=, >, >=),
// as described in ECMA 262-3 § 11.8.5.
function JS_CompareStrings(cx: PJSContext; str1, str2: PJSString;
var res: int32): JSBool; cdecl; external SpiderMonkeyLib;
// TODO - no description provided in MSDN
// extern JS_PUBLIC_API(JSBool)
//JS_StringEqualsAscii(JSContext *cx, JSString *str, const char *asciiBytes, JSBool *match);
//
//extern JS_PUBLIC_API(size_t)
//JS_PutEscapedString(JSContext *cx, char *buffer, size_t size, JSString *str, char quote);
//
//extern JS_PUBLIC_API(JSBool)
//JS_FileEscapedString(FILE *fp, JSString *str, char quote);
/// Extracting string characters and length.
//
// - While getting the length of a string is infallible, getting the chars can
// fail. As indicated by the lack of a JSContext parameter, there are two
// special cases where getting the chars is infallible:
// - The first case is interned strings, i.e., strings from JS_InternString or
// JSID_TO_STRING(id), using JS_GetInternedStringChars//.
// - The second case is "flat" strings that have been explicitly prepared in a
// fallible context by JS_FlattenString. To catch errors, a separate opaque
// JSFlatString type is returned by JS_FlattenString and expected by
// JS_GetFlatStringChars. Note, though, that this is purely a syntactic
// distinction: the input and output of JS_FlattenString are the same actual
// GC-thing so only one needs to be rooted. If a JSString is known to be flat,
// JS_ASSERT_STRING_IS_FLAT can be used to make a debug-checked cast. Example:
// // in a fallible context
// JSFlatString *fstr = JS_FlattenString(cx, str);
// if (!fstr)
// return JS_FALSE;
// JS_ASSERT(fstr == JS_ASSERT_STRING_IS_FLAT(str));
//
// // in an infallible context, for the same 'str'
// const jschar *chars = JS_GetFlatStringChars(fstr)
// JS_ASSERT(chars);
//
// The CharsZ APIs guarantee that the returned array has a null character at
// chars[length]. This can require additional copying so clients should prefer
// APIs without CharsZ if possible. The infallible functions also return
// null-terminated arrays. (There is no additional cost or non-Z alternative
// for the infallible functions, so 'Z' is left out of the identifier.)
/// Reports the length, in 16-bit code units, of the string str.
// - This is the same as the length property of the string.
// - This is the same as the length of the array returned by JS_GetStringChars,
// in jschars (not bytes).
// - Because some Unicode characters are represented using two 16-bit code units,
// the result is not necessarily the same as the number of Unicode characters
// in the string.
function JS_GetStringLength(str: PJSString): size_t; cdecl; external SpiderMonkeyLib;
/// Retrieve a pointer to the 16-bit values that make up a given string.
// - The array is not necessarily null-terminated. To get the length
// of the string, use JS_GetStringLength.
// - The program must not modify the array. If it does, the behavior is undefined.
// - The content of a JS string is not guaranteed to be valid UTF-16. It may
// contain surrogate code units that aren't properly paired. It may also contain zeroes.
// - The array returned by this function remains valid as long as str is valid.
// (Eventually, str becomes unreachable, the garbage collector collects it,
// and the array is freed by the system.)
function JS_GetStringCharsAndLength(cx: PJSContext; str: PJSString;
var len: size_t): pjschar; cdecl; external SpiderMonkeyLib;
/// see JS_InternedString for details about what InternedString is.
function JS_GetInternedStringChars(str: PJSString): Pjschar;
cdecl; external SpiderMonkeyLib;
function JS_GetInternedStringCharsAndLength(str: PJSString; var len: size_t): Pjschar;
cdecl; external SpiderMonkeyLib;
// is the same as JS_GetStringChars except that it always returns either a
// null-terminated string or NULL, indicating out-of-memory
// - help provided at
// https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_GetStringChars
function JS_GetStringCharsZ(cx: PJSContext; str: PJSString): pjschar;
cdecl; external SpiderMonkeyLib;
function JS_GetStringCharsZAndLength(cx: PJSContext; str: PJSString; var len: size_t): pjschar;
cdecl; external SpiderMonkeyLib;
//TODO add JS_FlattenString related function (do not use now)
//TODO JS_Encode / DEcode functions. We do not need it - instead use Syn*
{ JSON functions }
type
/// used by JS_Stringify() method to incremently write the JSON content
JSONWriteCallback = function(const buf: Pjschar; len: uint32; data: pointer): JSBool; cdecl;
/// converts a value to JSON, optionally replacing values if a replacer
// function is specified, or optionally including only the specified properties
// if a replacer array is specified
function JS_Stringify(cx: PJSContext; vp: Pjsval; replacer: PJSObject;
space: jsval; callback: JSONWriteCallback; data: pointer): JSBool;
cdecl; external SpiderMonkeyLib;
/// parse a string using the JSON syntax described in ECMAScript 5 and
// return the corresponding value into vp
function JS_ParseJSON(cx: PJSContext; const chars: Pjschar;
len: uint32; vp: Pjsval): JSBool; cdecl; external SpiderMonkeyLib;
//TODO StructuredClone functions
{ Error reporting }
// Report an exception represented by the sprintf-like conversion of format
// and its arguments. This exception message string is passed to a pre-set
// JSErrorReporter function (set by JS_SetErrorReporter; see jspubtd.h for
// the JSErrorReporter typedef).
/// JSErrorReport flag values. These may be freely composed.
const
// JSErrorReport pseudo-flag for default case
JSREPORT_ERROR = 0;
// JSErrorReport reported via JS_ReportWarning
JSREPORT_WARNING = 1;
// JSErrorReport exception was thrown
JSREPORT_EXCEPTION = 2;
// JSErrorReport error or warning due to strict option
JSREPORT_STRICT = 4;
// JSErrorReport error or warning depending on strict mode
// - This condition is an error in strict mode code, a warning if
// JS_HAS_STRICT_OPTION(cx), and otherwise should not be reported at
// all. We check the strictness of the context's top frame's script;
// where that isn't appropriate, the caller should do the right checks
// itself instead of using this flag.
JSREPORT_STRICT_MODE_ERROR = 8;
/// JS_ReportError is the simplest JSAPI function for reporting errors
// - First it builds an error message from the given sprintf-style format string
// and any additional arguments passed after it. The resulting error message
// is passed to the context's JSErrorReporter callback, if any
// - If the caller is in a JSAPI callback, JS_ReportError also creates a new
// JavaScript Error object and sets it to be the pending exception on cx
// - The callback must then return JS_FALSE to cause the exception to be
// propagated to the calling script
// - An example is shown in the JSAPI Phrasebook
// - For internationalization, use JS_ReportErrorNumber instead
// - To report an out-of-memory error, use JS_ReportOutOfMemory
procedure JS_ReportError(cx: PJSContext; const format: PCChar);
cdecl; varargs; external SpiderMonkeyLib;
/// Report an error with an application-defined error code.
// - varargs is Additional arguments for the error message.
//- These arguments must be of type char*
// - The number of additional arguments required depends on the error
// message, which is determined by the errorCallback
procedure JS_ReportErrorNumber(cx: PJSContext; errorCallback: JSErrorCallback;
userRef: pointer; const erroNubmer: uintN); cdecl; varargs; external SpiderMonkeyLib;
/// Report an error with an application-defined error code.
// - varargs is Additional arguments for the error message.
//- These arguments must be of type jschar*
// - The number of additional arguments required depends on the error
// message, which is determined by the errorCallback
procedure JS_ReportErrorNumberUC(cx: PJSContext; errorCallback: JSErrorCallback;
userRef: pointer; const erroNubmer: uintN); cdecl; varargs; external SpiderMonkeyLib;
/// similar to JS_ReportError(), but report a warning instead of an error
// (JSREPORT_IS_WARNING(report.flags))
// - Return true if there was no error trying to issue the warning, and if the
// warning was not converted into an error due to the JSOPTION_WERROR option
// being set, false otherwise
procedure JS_ReportWarning(cx: PJSContext; const format: PCChar);
cdecl; varargs; external SpiderMonkeyLib;
function JS_ReportErrorFlagsAndNumber(cx: PJSContext; flags: uintN;
errorCallback: JSErrorCallback; userRef: Pointer; const errorNumber: uintN): JSBool;
varargs; cdecl; external SpiderMonkeyLib;
function JS_ReportErrorFlagsAndNumberUC(cx: PJSContext; flags: uintN;
errorCallback: JSErrorCallback; userRef: Pointer; const errorNumber: uintN): JSBool;
varargs; cdecl; external SpiderMonkeyLib;
/// Reports a memory allocation error
// - Call JS_ReportOutOfMemory to report that an operation failed because the
// system is out of memory
// - When the JavaScript engine tries to allocate memory and allocation fails,
// it reports an error as though by calling this function
procedure JS_ReportOutOfMemory(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// Call JS_ReportAllocationOverflow if an operation fails because it tries to
// use more memory (or more of some other resource) than the application is
// designed to handle
// - When a script tries to grow an array beyond 230-1 elements, for example,
// or concatenate strings such that the result is more than 229-1 characters long,
// the JavaScript engine reports an error as though by calling this function.
// - The main difference between these two functions is that JS_ReportOutOfMemory
// does not cause a JavaScript exception to be thrown.
// The error therefore cannot be caught by try…catch statements in scripts.
// JS_ReportAllocationOverflow throws an InternalError which scripts can catch.
procedure JS_ReportAllocationOverflow(cx: PJSContext); cdecl; external SpiderMonkeyLib;
/// Specify the error reporting mechanism for an application.
// - JS_SetErrorReporter enables you to define and use your own error
// reporting mechanism in your applications.
// - The reporter you define is automatically passed a JSErrorReport structure
// when an error occurs and has been parsed by JS_ReportError.
//- JS_SetErrorReporter returns the previous error reporting function of the
// context, or NULL if no such function had been set.
// - Typically, the error reporting mechanism you define should log the error
// where appropriate (such as to a log file), and display an error to the user
// of your application.
// - The error you log and display can make use of the information passed about
// the error condition in the JSErrorReport structure.
// - The error reporter callback must not reenter the JSAPI.
// - Like all other SpiderMonkey callbacks, the error reporter callback must not
// throw any Delphi exception.
function JS_SetErrorReporter(cx: PJSContext; er: JSErrorReporter): JSErrorReporter;
cdecl; external SpiderMonkeyLib;
{ Dates }
/// create a new JavaScript date object
function JS_NewDateObject(cx: PJSContext; year, mon, mday, hour, min, sec: int32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// create a new JavaScript date object from the Unix millisecond elapsed since EPOC
function JS_NewDateObjectMsec(cx: PJSContext; msec: jsdouble): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Infallible predicate to test whether obj is a JavaScript date object
function JS_ObjectIsDate(cx: PJSContext; obj: PJSObject): JSBool;
cdecl; external SpiderMonkeyLib;
{ Error hadling }
/// determine whether an exception is pending in the JS engine.
// - JS_IsExceptionPending returns JS_TRUE if an exception has been thrown
// in the context cx and the exception has not yet been caught or cleared.
// Otherwise, it returns JS_FALSE
// - This can be used from JSNative functions which call JS code to determine
// if the called JS code threw an exception or not.
function JS_IsExceptionPending(cx: PJSContext): JSBool;
cdecl; external SpiderMonkeyLib;
/// get the current exception being thrown within a context
function JS_GetPendingException(cx: PJSContext; var vp: jsval): JSBool;
cdecl; external SpiderMonkeyLib;
/// set the current exception being thrown within a context
// - JS_SetPendingException sets the current exception being thrown within a
// context. If an exception is already being thrown, it is replaced with the
// new one given.
// - v is the new value to throw as an exception.
// - A native function or hook using this to throw an exception must also
// return JS_FALSE to ensure the exception is thrown.
// - Each JSContext's pending-exception field is a GC root. That is,
// garbage collection never collects a pending exception
procedure JS_SetPendingException(cx: PJSContext; v: jsval);
cdecl; external SpiderMonkeyLib;
procedure JS_ClearPendingException(cx: PJSContext);
cdecl; external SpiderMonkeyLib;
function JS_ReportPendingException(cx: PJSContext): JSBool;
cdecl; external SpiderMonkeyLib;
type
PJSExceptionState = type Pointer;
/// Save the current exception state. This takes a snapshot of cx's current
// exception state without making any change to that state.
// - The returned state pointer MUST be passed later to JS_RestoreExceptionState
// (to restore that saved state, overriding any more recent state) or else to
// JS_DropExceptionState (to free the state struct in case it is not correct
// or desirable to restore it). Both Restore and Drop free the state struct,
// so callers must stop using the pointer returned from Save after calling the
// Release or Drop API.
function JS_SaveExceptionState(cx: PJSContext): PJSExceptionState;
cdecl; external SpiderMonkeyLib ;
/// Restore a specified exception state
procedure JS_RestoreExceptionState(cx: PJSContext; state: PJSExceptionState);
cdecl; external SpiderMonkeyLib ;
/// Drop a specified exception state
procedure JS_DropExceptionState(cx: PJSContext; state: PJSExceptionState);
cdecl; external SpiderMonkeyLib ;
/// retrieve an error report from an exception object
// - If the given value is an exception object that originated from an error,
// the exception will contain an error report struct, and this API will return
// the address of that struct. Otherwise, it returns NULL.
// - The lifetime of the error report struct that might be returned is the same
// as the lifetime of the exception object
function JS_ErrorFromException(cx: PJSContext; v: jsval): PJSErrorReport;
cdecl; external SpiderMonkeyLib;
/// Given a reported error's message and JSErrorReport struct pointer, throw
// the corresponding exception on cx
function JS_ThrowReportedError(cx: PJSContext; const msg: PCChar;
reportp: PJSErrorReport): JSBool; cdecl; external SpiderMonkeyLib;
/// Throws a StopIteration exception on cx
function JS_ThrowStopIteration(cx: PJSContext): JSBool;
cdecl; external SpiderMonkeyLib;
/// JS_IsConstructing must be called from within a native given the
// native's original cx and vp arguments
// - If JS_IsConstructing is true, JS_THIS must not be used;
// the constructor should construct and return a new object
// - Otherwise, the native is called as an ordinary function and
// JS_THIS may be used
function JS_IsConstructing(cx: PJSContext; const vp: PjsvalVector): boolean;
{$ifdef HASINLINE}inline;{$endif}
type
/// low-level definition of the jsval internals
// - do not use directly
jsval_payload = record
case Byte of
0: (i32: int32);
1: (u32: uint32);
2: (boo: JSBool);
3: (str: PJSString);
4: (obj: PJSObject);
5: (ptr: pointer);
6: (why: JSWhyMagic);
7: (word: jsuword);
8: (uintptr: JSuintptr)
end;
{$ifdef IS_LITTLE_ENDIAN}
jsval_val_layout = packed record
payload: jsval_payload;
tag: JSValueTag;
end;
{$else} //BIG_ENDIAN
jsval_val_layout = record
tag: JSValueTag;
payload: jsval_payload;
end;
{$endif}
/// low-level definition of the jsval internals
// - do not use directly
jsval_layout = record
case Byte of
0: (asBits: QWord);
1: (s: jsval_val_layout);
2: (asDouble: double);
3: (asPtr: Pointer);
end;
{ ArrayBuffer support from jsfriendapi.h}
/// Create a new signed 8 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewInt8Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new unsigned 8 bit integer (byte) typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewUint8Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewUint8ClampedArray(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new signed 16 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewInt16Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new unsigned 16 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewUint16Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new signed 32 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewInt32Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new unsigned 32 bit integer typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewUint32Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new signed 32 bit float (single) typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewFloat32Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new signed 64 bit float (double) typed array with nelements elements
// - will fill the newly created array with zeros
function JS_NewFloat64Array(cx: PJSContext; nelements: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit signed integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewInt8ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit unsigned integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewUint8ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit unsigned integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewUint8ClampedArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 16 bit signed integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewInt16ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 16 bit unsigned integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewUint16ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit signed integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewInt32ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit unsigned integer typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewUint32ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit float (single) typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewFloat32ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 64 bit float (double) typed array and copy in values
// from a given object
// - The object is used as if it was an array; that is, the new array (if
// successfully created) will have length given by array.length, and its
// elements will be those specified by array[0], array[1], and so on, after
// conversion to the typed array element type.
function JS_NewFloat64ArrayFromArray(cx: PJSContext; arr: PJSObject): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit signed integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewInt8ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit unsigned integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewUint8ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 8 bit unsigned integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewUint8ClampedArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 16 bit signed integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewInt16ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 16 bit unsigned integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewUint16ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit signed integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewInt32ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit unsigned integer typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewUint32ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 32 bit float (single) typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewFloat32ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new 64 bit float (double) typed array using the given
// ArrayBuffer for storage
// - The length value is optional; if -1 is passed, enough elements to use up the
// remainder of the byte array is used as the default value
function JS_NewFloat64ArrayWithBuffer(cx: PJSContext; arrayBuffer: PJSObject;
byteOffset: uint32; length: int32): PJSObject; cdecl; external SpiderMonkeyLib;
/// Create a new ArrayBuffer with the given byte length.
function JS_NewArrayBuffer(cx: PJSContext; nbytes: uint32): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Check whether obj supports JS_GetTypedArray* APIs
// - Note that this may return false if a security wrapper is encountered that
// denies the unwrapping.
// - if this test or one of the JS_Is*Array tests succeeds, then it is safe to call
// the dedicated accessor JSAPI calls
function JS_IsTypedArrayObject(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Check whether obj supports JS_GetArrayBufferView* APIs
// - Note that this may return false if a security wrapper is encountered that
// denies the unwrapping.
// - if this test or one of the JS_Is*Array tests succeeds, then it is safe to call
// the dedicated ArrayBufferView accessor JSAPI calls
function JS_IsArrayBufferViewObject(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 8 bit signed integer typed array types (ArrayBufferView subtypes)
function JS_IsInt8Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 8 bit unsigned integer typed array types (ArrayBufferView subtypes)
function JS_IsUint8Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 8 bit unsigned integer typed array types (ArrayBufferView subtypes)
function JS_IsUint8ClampedArray(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 16 bit signed integer typed array types (ArrayBufferView subtypes)
function JS_IsInt16Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 16 bit unsigned integer typed array types (ArrayBufferView subtypes)
function JS_IsUint16Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 32 bit signed integer typed array types (ArrayBufferView subtypes)
function JS_IsInt32Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 32 bit unsigned integer typed array types (ArrayBufferView subtypes)
function JS_IsUint32Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 32 bit float (single) typed array types (ArrayBufferView subtypes)
function JS_IsFloat32Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
/// Test for specific 64 bit float (double) typed array types (ArrayBufferView subtypes)
function JS_IsFloat64Array(obj: PJSObject): JSBool; cdecl; external SpiderMonkeyLib;
type
Tint8Vector = array[0..(MaxInt div sizeof(int8))-1] of int8;
Pint8Vector = ^Tint8Vector;
Tuint8Vector = array[0..(MaxInt div sizeof(uint8))-1] of uint8;
Puint8Vector = ^Tuint8Vector;
Tint16Vector = array[0..(MaxInt div sizeof(int16))-1] of int16;
Pint16Vector = ^Tint16Vector;
Tuint16Vector = array[0..(MaxInt div sizeof(uint16))-1] of uint16;
Puint16Vector = ^Tuint16Vector;
Tint32Vector = array[0..(MaxInt div sizeof(int32))-1] of int32;
Pint32Vector = ^Tint32Vector;
Tuint32Vector = array[0..(MaxInt div sizeof(uint32))-1] of uint32;
Puint32Vector = ^Tuint32Vector;
Tfloat32Vector = array[0..(MaxInt div sizeof(single))-1] of single;
Pfloat32Vector = ^Tfloat32Vector;
Tfloat64Vector = array[0..(MaxInt div sizeof(double))-1] of double;
Pfloat64Vector = ^Tfloat64Vector;
/// Unwrap 8 bit signed integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsInt8Array(obj: PJSObject; var length: uint32; var Data: Pint8Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 8 bit unsigned integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsUint8Array(obj: PJSObject; var length: uint32; var Data: Puint8Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 8 bit unsigned integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsUint8ClampedArray(obj: PJSObject; var length: uint32; var Data: Puint8Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 16 bit signed integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsInt16Array(obj: PJSObject; var length: uint32; var Data: Pint16Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 16 bit unsigned integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsUint16Array(obj: PJSObject; var length: uint32; var Data: Puint16Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 32 bit signed integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsInt32Array(obj: PJSObject; var length: uint32; var Data: Pint32Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 32 bit unsigned integer typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsUint32Array(obj: PJSObject; var length: uint32; var Data: Puint32Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 32 bit float (single) typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsFloat32Array(obj: PJSObject; var length: uint32; var Data: Pfloat32Vector): PJSObject;
cdecl; external SpiderMonkeyLib;
/// Unwrap 64 bit float (double) typed array into direct memory buffer
// - Return nil without throwing any exception if the object cannot be viewed as the
// correct typed array, or the typed array object on success, filling both out parameters
function JS_GetObjectAsFloat64Array(obj: PJSObject; var length: uint32; var Data: Pfloat64Vector): PJSObject;
cdecl; external SpiderMonkeyLib;