Name Description Size
Array-inl.h 1093
Array.cpp 133979
Array.h JS Array interface. 10312
Array.js ES5 15.4.4.14. 29174
AsyncFunction.js 623
AsyncIteration.js 872
AtomicsObject.cpp JS Atomics pseudo-module. See "Spec: JavaScript Shared Memory, Atomics, and Locks" for the full specification. In addition to what is specified there, we throw an Error object if the futex API hooks have not been installed on the runtime. Essentially that is an implementation error at a higher level. Note on the current implementation of atomic operations. The Mozilla atomics are not sufficient to implement these APIs because we need to support 8-bit, 16-bit, and 32-bit data: the Mozilla atomics only support 32-bit data. At the moment we include mozilla/Atomics.h, which will define MOZ_HAVE_CXX11_ATOMICS and include <atomic> if we have C++11 atomics. If MOZ_HAVE_CXX11_ATOMICS is set we'll use C++11 atomics. Otherwise, if the compiler has them we'll fall back on gcc/Clang intrinsics. Otherwise, if we're on VC++2012, we'll use C++11 atomics even if MOZ_HAVE_CXX11_ATOMICS is not defined. The compiler has the atomics but they are disabled in Mozilla due to a performance bug. That performance bug does not affect the Atomics code. See mozilla/Atomics.h for further comments on that bug. Otherwise, if we're on VC++2010 or VC++2008, we'll emulate the gcc/Clang intrinsics with simple code below using the VC++ intrinsics, like the VC++2012 solution this is a stopgap since we're about to start using VC++2013 anyway. If none of those options are available then the build must disable shared memory, or compilation will fail with a predictable error. 31589
AtomicsObject.h 6437
BigInt.cpp !ENABLE_INTL_API 6599
BigInt.h 1745
BigInt.js Format this BigInt object into a string, using the locale and formatting options provided. Spec PR: https://github.com/tc39/ecma402/pull/236 1392
Boolean-inl.h namespace js 1011
Boolean.cpp JS boolean implementation. 4961
Boolean.h JS boolean interface. 703
Classes.js 962
DataViewObject.cpp bytesPerElement = 31802
DataViewObject.h 6333
Date.js Get a cached DateTimeFormat formatter object, created like so: var opts = ToDateTimeOptions(undefined, required, defaults); return new Intl.DateTimeFormat(undefined, opts); |format| must be a key from the "formatters" Record described above. 6409
embedjs.py \ /* 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/. */ namespace js { namespace %(namespace)s { static const %(sources_type)s data[] = { %(sources_data)s }; static const %(sources_type)s * const %(sources_name)s = reinterpret_cast<const %(sources_type)s *>(data); uint32_t GetCompressedSize() { return %(compressed_total_length)i; } uint32_t GetRawScriptsSize() { return %(raw_total_length)i; } } // selfhosted } // js 6940
Error.js ES6 20140718 draft 19.5.3.4. 853
Eval.cpp static 20436
Eval.h builtin_Eval_h 1615
Function.js bind_bindFunction{0,1,2} are special cases of the generic bind_bindFunctionN below. They avoid the need to merge the lists of bound arguments and call arguments to the bound function into a new list which is then used in a destructuring call of the bound function. All three of these functions again have special-cases for call argument counts between 0 and 5. For calls with 6+ arguments, all - bound and call - arguments are copied into an array before invoking the generic call and construct helper functions. This avoids having to use rest parameters and destructuring in the fast path. Directly embedding the for-loop to combine bound and call arguments may inhibit inlining of the bound function, so we use a separate combiner function to perform this task. This combiner function is created lazily to ensure we only pay its construction cost when needed. All bind_bindFunction{X} functions have the same signature to enable simple reading out of closed-over state by debugging functions. 13396
Generator.js 2834
intl 35
Iterator.js 255
JSON.cpp ES5 15.12.3 Quote. Requires that the destination has enough space allocated for src after escaping (that is, `2 + 6 * (srcEnd - srcBegin)` characters). 31396
JSON.h If maybeSafely is true, Stringify will attempt to assert the API requirements of JS::ToJSONMaybeSafely as it traverses the graph, and will not try to invoke .toJSON on things as it goes. 1362
Map.js 3980
MapObject.cpp HashableValue ********************************************************* 54889
MapObject.h Comparing two ropes for equality can fail. The js::HashTable template requires infallible hash() and match() operations. Therefore we require all values to be converted to hashable form before being used as a key in a Map or Set object. All values except ropes are hashable as-is. 14896
Module.js 21739
ModuleObject.cpp static 59628
ModuleObject.h 12342
Number.js Format this Number object into a string, using the locale and formatting options provided. Spec: ECMAScript Language Specification, 5.1 edition, 15.7.4.3. Spec: ECMAScript Internationalization API Specification, 13.2.1. 3311
Object.cpp Make an object whether this was called with 'new' or not. 59270
Object.h Like IdToValue, but convert int jsids to strings. This is used when exposing a jsid to script for Object.getOwnProperty{Names,Symbols} or scriptable proxy traps. 2451
Object.js ES6 draft rev 32 (2015 Feb 2) 19.1.2.9. 9412
Profilers.cpp Profiling-related API 15487
Profilers.h Functions for controlling profilers from within JS: Valgrind, Perf, etc 2747
Promise.cpp 203527
Promise.h 24745
Promise.js 2377
Reflect.cpp Reflect methods ******************************************************* 6812
Reflect.h builtin_Reflect_h 1003
Reflect.js , newTarget 5588
ReflectParse.cpp JS reflection package. 117869
RegExp.cpp ES 2017 draft rev 6a13789aa9e7c6de4e96b7d3e24d9e6eba6584ad 21.2.5.2.2 steps 3, 16-25. 56129
RegExp.h The following builtin natives are extern'd for pointer comparison in other parts of the engine. 6205
RegExp.js 37352
RegExpGlobalReplaceOpt.h.js 4436
RegExpLocalReplaceOpt.h.js 4048
SelfHostingDefines.h 4489
Set.js 3456
Sorting.js eslint-disable comma-spacing 15266
Stream.cpp 3.3. ReadableStreamAsyncIteratorPrototype ***************************** 28821
Stream.h builtin_Stream_h 1076
streams 43
String.cpp Forward declarations for URI encode/decode and helper routines 124551
String.h Initialize the String class, returning its prototype object. 3642
String.js A helper function implementing the logic for both String.prototype.padStart and String.prototype.padEnd as described in ES7 Draft March 29, 2016 24423
Symbol.cpp 7949
Symbol.h Stores this Symbol object's [[PrimitiveValue]]. 2653
TestingFunctions.cpp 212330
TestingFunctions.h namespace js 1324
TypedArray.js Steps 3-5 (non-wrapped typed arrays). 52742
TypedObject-inl.h static 741
TypedObject.cpp Overwrites the contents of `typedObj` at offset `offset` with `val` converted to the type `typeObj`. This is done by delegating to self-hosted code. This is used for assignments and initializations. For example, consider the final assignment in this snippet: var Point = new StructType({x: float32, y: float32}); var Line = new StructType({from: Point, to: Point}); var line = new Line(); line.to = {x: 22, y: 44}; This would result in a call to `ConvertAndCopyTo` where: - typeObj = Point - typedObj = line - offset = sizeof(Point) == 8 - val = {x: 22, y: 44} This would result in loading the value of `x`, converting it to a float32, and hen storing it at the appropriate offset, and then doing the same for `y`. Note that the type of `typeObj` may not be the type of `typedObj` but rather some subcomponent of `typedObj`. 103868
TypedObject.h ------------- [SMDOC] Typed Objects ------------- Typed objects are a special kind of JS object where the data is given well-structured form. To use a typed object, users first create *type objects* (no relation to the type objects used in TI) that define the type layout. For example, a statement like: var PointType = new StructType({x: uint8, y: uint8}); would create a type object PointType that is a struct with two fields, each of uint8 type. This comment typically assumes familiary with the API. For more info on the API itself, see the Harmony wiki page at http://wiki.ecmascript.org/doku.php?id=harmony:typed_objects or the ES6 spec (not finalized at the time of this writing). - Initialization: Currently, all "globals" related to typed objects are packaged within a single "module" object `TypedObject`. This module has its own JSClass and when that class is initialized, we also create and define all other values (in `js::InitTypedObjectModuleClass()`). - Type objects, meta type objects, and type representations: There are a number of pre-defined type objects, one for each scalar type (`uint8` etc). Each of these has its own class_, defined in `DefineNumericClass()`. There are also meta type objects (`ArrayType`, `StructType`). These constructors are not themselves type objects but rather the means for the *user* to construct new typed objects. Each type object is associated with a *type representation* (see TypeRepresentation.h). Type representations are canonical versions of type objects. We attach them to TI type objects and (eventually) use them for shape guards etc. They are purely internal to the engine and are not exposed to end users (though self-hosted code sometimes accesses them). - Typed objects: A typed object is an instance of a *type object* (note the past participle). Typed objects can be either transparent or opaque, depending on whether their underlying buffer can be accessed. Transparent and opaque typed objects have different classes, and can have different physical layouts. The following layouts are possible: InlineTypedObject: Typed objects whose data immediately follows the object's header are inline typed objects. The buffer for these objects is created lazily and stored via the compartment's LazyArrayBufferTable, and points back into the object's internal data. OutlineTypedObject: Typed objects whose data is owned by another object, which can be either an array buffer or an inline typed object. Outline typed objects may be attached or unattached. An unattached typed object has no data associated with it. When first created, objects are always attached, but they can become unattached if their buffer becomes detached. Note that whether a typed object is opaque is not directly connected to its type. That is, opaque types are *always* represented by opaque typed objects, but you may have opaque typed objects for transparent types too. This can occur for two reasons: (1) a transparent type may be embedded within an opaque type or (2) users can choose to convert transparent typed objects into opaque ones to avoid giving access to the buffer itself. Typed objects (no matter their class) are non-native objects that fully override the property accessors etc. The overridden accessor methods are the same in each and are defined in methods of TypedObject. 39980
TypedObject.js 31608
TypedObjectConstants.h 3909
Utilities.js List specification type ********* 7495
WeakMap.js 806
WeakMapObject-inl.h builtin_WeakMapObject_inl_h 1905
WeakMapObject.cpp static 9504
WeakMapObject.h builtin_WeakMapObject_h 2406
WeakSet.js 638
WeakSetObject.cpp static 7345
WeakSetObject.h builtin_WeakSetObject_h 1855
.eslintrc.js 586