diff options
Diffstat (limited to 'js/public/TypeDecls.h')
-rw-r--r-- | js/public/TypeDecls.h | 151 |
1 files changed, 151 insertions, 0 deletions
diff --git a/js/public/TypeDecls.h b/js/public/TypeDecls.h new file mode 100644 index 0000000000..1686b19173 --- /dev/null +++ b/js/public/TypeDecls.h @@ -0,0 +1,151 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// This file contains public type declarations that are used *frequently*. If +// it doesn't occur at least 10 times in Gecko, it probably shouldn't be in +// here. +// +// It includes only: +// - forward declarations of structs and classes; +// - typedefs; +// - enums (maybe). +// It does *not* contain any struct or class definitions. + +#ifndef js_TypeDecls_h +#define js_TypeDecls_h + +#include <stdint.h> // uint8_t + +#include "jstypes.h" // JS_PUBLIC_API + +typedef uint8_t jsbytecode; + +class JS_PUBLIC_API JSAtom; +struct JS_PUBLIC_API JSContext; +struct JSClass; +class JS_PUBLIC_API JSFunction; +class JS_PUBLIC_API JSObject; +struct JS_PUBLIC_API JSRuntime; +class JS_PUBLIC_API JSScript; +class JS_PUBLIC_API JSString; + +struct JSPrincipals; + +namespace js { +class JS_PUBLIC_API TempAllocPolicy; +}; // namespace js + +namespace JS { + +class JS_PUBLIC_API GCContext; +class JS_PUBLIC_API PropertyKey; + +typedef unsigned char Latin1Char; + +class JS_PUBLIC_API Symbol; +class JS_PUBLIC_API BigInt; +#ifdef ENABLE_RECORD_TUPLE +class JS_PUBLIC_API RecordType; +class JS_PUBLIC_API TupleType; +#endif +class JS_PUBLIC_API Value; + +class JS_PUBLIC_API Compartment; +class JS_PUBLIC_API Realm; +struct JS_PUBLIC_API Runtime; +class JS_PUBLIC_API Zone; + +template <typename T> +class Handle; +template <typename T> +class MutableHandle; +template <typename T> +class Rooted; +template <typename T> +class PersistentRooted; +template <typename T> +class RootedVector; +template <typename T> +class PersistentRootedVector; +template <typename T, typename AllocPolicy = js::TempAllocPolicy> +class StackGCVector; + +typedef Handle<JSFunction*> HandleFunction; +typedef Handle<PropertyKey> HandleId; +typedef Handle<JSObject*> HandleObject; +typedef Handle<JSScript*> HandleScript; +typedef Handle<JSString*> HandleString; +typedef Handle<JS::Symbol*> HandleSymbol; +typedef Handle<JS::BigInt*> HandleBigInt; +typedef Handle<Value> HandleValue; +typedef Handle<StackGCVector<Value>> HandleValueVector; +typedef Handle<StackGCVector<JSObject*>> HandleObjectVector; +typedef Handle<StackGCVector<JS::PropertyKey>> HandleIdVector; + +typedef MutableHandle<JSFunction*> MutableHandleFunction; +typedef MutableHandle<PropertyKey> MutableHandleId; +typedef MutableHandle<JSObject*> MutableHandleObject; +typedef MutableHandle<JSScript*> MutableHandleScript; +typedef MutableHandle<JSString*> MutableHandleString; +typedef MutableHandle<JS::Symbol*> MutableHandleSymbol; +typedef MutableHandle<JS::BigInt*> MutableHandleBigInt; +typedef MutableHandle<Value> MutableHandleValue; +typedef MutableHandle<StackGCVector<Value>> MutableHandleValueVector; +typedef MutableHandle<StackGCVector<JSObject*>> MutableHandleObjectVector; +typedef MutableHandle<StackGCVector<JS::PropertyKey>> MutableHandleIdVector; + +typedef Rooted<JSObject*> RootedObject; +typedef Rooted<JSFunction*> RootedFunction; +typedef Rooted<JSScript*> RootedScript; +typedef Rooted<JSString*> RootedString; +typedef Rooted<JS::Symbol*> RootedSymbol; +typedef Rooted<JS::BigInt*> RootedBigInt; +typedef Rooted<PropertyKey> RootedId; +typedef Rooted<JS::Value> RootedValue; + +typedef RootedVector<JS::Value> RootedValueVector; +typedef RootedVector<JSObject*> RootedObjectVector; +typedef RootedVector<JS::PropertyKey> RootedIdVector; + +typedef PersistentRooted<JSFunction*> PersistentRootedFunction; +typedef PersistentRooted<PropertyKey> PersistentRootedId; +typedef PersistentRooted<JSObject*> PersistentRootedObject; +typedef PersistentRooted<JSScript*> PersistentRootedScript; +typedef PersistentRooted<JSString*> PersistentRootedString; +typedef PersistentRooted<JS::Symbol*> PersistentRootedSymbol; +typedef PersistentRooted<JS::BigInt*> PersistentRootedBigInt; +typedef PersistentRooted<Value> PersistentRootedValue; + +typedef PersistentRootedVector<PropertyKey> PersistentRootedIdVector; +typedef PersistentRootedVector<JSObject*> PersistentRootedObjectVector; + +template <typename T> +using HandleVector = Handle<StackGCVector<T>>; +template <typename T> +using MutableHandleVector = MutableHandle<StackGCVector<T>>; +} // namespace JS + +using jsid = JS::PropertyKey; + +#ifdef ENABLE_RECORD_TUPLE +// This takes 1 or 2 parameters. ... is just used so that +// it's possible to omit the comma when passing a single +// param: +// IF_RECORD_TUPLE(doThis) +// IF_RECORD_TUPLE(doThis, elseThis) +# define IF_RECORD_TUPLE(x, ...) x +#else +# define IF_RECORD_TUPLE(x, ...) __VA_ARGS__ +#endif + +// Follows the same pattern as IF_RECORD_TUPLE +#ifdef ENABLE_DECORATORS +# define IF_DECORATORS(x, ...) x +#else +# define IF_DECORATORS(x, ...) __VA_ARGS__ +#endif + +#endif /* js_TypeDecls_h */ |