Merge pull request #1899 from svaarala/ecmascript-spelling-misc

Use 'ECMAScript' spelling in misc places

CONTRIBUTING.md

@@ -26,7 +26,7 @@ To make a code contribution to Duktape
 * Test your changes as thoroughly as possible.  At the very minimum:
 
   - Travis test run must pass, which covers both a code policy check, and
-    runs basic API and Ecmascript test case set.
+    runs basic API and ECMAScript test case set.
 
   - If some test cases are invalidated by the changes, fix the test cases as
     part of the branch.  If you add new functionality, you should add test

Makefile

@@ -638,7 +638,7 @@ releasetest: xmldoctest closuretest bluebirdtest luajstest jsinterpretertest lod
 	@echo ""
 	@echo "### Release tests successful!"  # These tests now have output checks.
 
-# Runtests-based Ecmascript and API tests.
+# Runtests-based ECMAScript and API tests.
 .PHONY:	runtestsdeps
 runtestsdeps:	runtests/node_modules UglifyJS2
 runtests/node_modules:

README.md

@@ -11,13 +11,13 @@ with a focus on **portability** and **compact** footprint.
 
 Duktape is easy to integrate into a C/C++ project: add `duktape.c`,
 `duktape.h`, and `duk_config.h` to your build, and use the Duktape API
-to call Ecmascript functions from C code and vice versa.
+to call ECMAScript functions from C code and vice versa.
 
 Main features:
 
 * Embeddable, portable, compact
-* Ecmascript E5/E5.1 compliant, with some semantics updated from ES2015+
-* Partial support for Ecmascript 2015 (E6) and Ecmascript 2016 (E7),
+* ECMAScript E5/E5.1 compliant, with some semantics updated from ES2015+
+* Partial support for ECMAScript 2015 (E6) and ECMAScript 2016 (E7),
   [Post-ES5 feature status](http://wiki.duktape.org/PostEs5Features.html),
   [kangax/compat-table](https://kangax.github.io/compat-table)
 * ES2015 TypedArray and Node.js Buffer bindings
@@ -28,7 +28,7 @@ Main features:
 * Minimal platform dependencies
 * Combined reference counting and mark-and-sweep garbage collection with finalization
 * Custom features like co-routines
-* Property virtualization using a subset of Ecmascript E2015 Proxy object
+* Property virtualization using a subset of ECMAScript E2015 Proxy object
 * Bytecode dump/load for caching compiled functions
 * Distributable includes an optional logging framework, CommonJS-based module
   loading implementations, etc
@@ -155,7 +155,7 @@ Duktape uses [Semantic Versioning](http://semver.org/) for official
 releases.  Builds from Duktape repo are not official releases and don't
 follow strict semver, mainly because `DUK_VERSION` needs to have some
 compromise value that won't be strictly semver conforming.
-Because Duktape tracks the latest Ecmascript specification versions,
+Because Duktape tracks the latest ECMAScript specification versions,
 compliance fixes are made in minor versions even when they are technically
 not backwards compatible.  See
 [Versioning](http://duktape.org/guide.html#versioning) for details.

RELEASES.rst

@@ -81,7 +81,7 @@ Released
 * Enforce string/buffer length limits to avoid corner cases with strings
   and buffers close to size_t limit
 
-* Ecmascript E5.1 test cases and fixes
+* ECMAScript E5.1 test cases and fixes
 
 * Mark-and-sweep stringtable leak fixed, affected mostly builds without
   reference counting
@@ -108,7 +108,7 @@ Released
 * Added support for function declarations outside function or program top
   level (also known as "function statements"), with V8-like semantics
 
-* Renamed __duk__ to Duktape for more consistency with Ecmascript conventions
+* Renamed __duk__ to Duktape for more consistency with ECMAScript conventions
 
 * Removed somewhat useless Duktape.build property and added Duktape.env
 
@@ -205,7 +205,7 @@ Released
 
 * Add duk_push_heap_stash(), duk_push_global_stash(), and
   duk_push_thread_stash() to provide C code with stashes for storing
-  values invisible to Ecmascript code
+  values invisible to ECMAScript code
 
 * Add duk_safe_to_string() and duk_safe_to_lstring() to make it easier
   to write result printing in C
@@ -221,10 +221,10 @@ Released
 
 * Add Duktape.compact(), Duktape.line(), and Duktape.act()
 
-* Add a "use duk notail" directive which indicates that an Ecmascript
+* Add a "use duk notail" directive which indicates that an ECMAScript
   function should never be tail called
 
-* Add a barebones built-in logging framework with both Ecmascript and C
+* Add a barebones built-in logging framework with both ECMAScript and C
   APIs and easy customization
 
 * Add a message argument to fatal handler function callback, simplify
@@ -454,7 +454,7 @@ Released
   duk_xmove())
 
 * Change strictness behavior for Duktape API calls: all API calls now have
-  Ecmascript strict semantics, even when a call is made with an empty call
+  ECMAScript strict semantics, even when a call is made with an empty call
   stack outside of any Duktape/C function
 
 * Change strictness handling of duk_eval() and variants so that all code is
@@ -469,7 +469,7 @@ Released
 
 * Add API call duk_set_global_object() which allows the global object of a
   context to be replaced; this is useful as an initial mechanism for proper
-  sandboxing of Ecmascript code
+  sandboxing of ECMAScript code
 
 * Add API calls duk_get_prototype() and duk_set_prototype() for getting and
   setting an object's "internal prototype" from C code
@@ -515,7 +515,7 @@ Released
   there will be no API to use it
 
 * Fix value stack reserve handling for function calls: a function call
-  (Ecmascript or Duktape/C) might reduce the valstack "checked size" which
+  (ECMAScript or Duktape/C) might reduce the valstack "checked size" which
   was previously requested by user code (for more detail, see API test case
   test-dev-valstack-checked-size-call.c)
 
@@ -524,7 +524,7 @@ Released
   would also be executed for the Proxy object
 
 * Fix a few Date bugs for large out-of-range years which caused some assert
-  failures and incorrect behavior when year was out of Ecmascript range (e.g.
+  failures and incorrect behavior when year was out of ECMAScript range (e.g.
   year 870e6 and year -200e6)
 
 * Minor compile warnings fixes for non-default options (e.g. when reference
@@ -656,7 +656,7 @@ Released
 
 * Add duk_def_prop() which allows creation of accessor (getter/setter)
   properties and other custom properties from C code (instead of using
-  Object.defineProperty() from Ecmascript code)
+  Object.defineProperty() from ECMAScript code)
 
 * Add duk_is_error() API call to check if a value inherits from Error
 
@@ -671,7 +671,7 @@ Released
 * Add vararg variants duk_error_va(), duk_push_error_object_va(), and
   duk_log_va()
 
-* Add DUK_GIT_DESCRIBE macro to the C API (with no Ecmascript equivalent)
+* Add DUK_GIT_DESCRIBE macro to the C API (with no ECMAScript equivalent)
   to allow application code to e.g. log more detailed version information
   relevant for non-official snapshot builds
 
@@ -778,7 +778,7 @@ Released
   body was not checked and Duktape would accept e.g. "function () [}"
   (GH-106)
 
-* Fix compiler register limit bug where an Ecmascript function with
+* Fix compiler register limit bug where an ECMAScript function with
   [65536,262143] VM registers would be compiled into incorrect bytecode
   instead of being rejected with an internal error (GH-111)
 
@@ -873,7 +873,7 @@ Released
   body was not checked and Duktape would accept e.g. "function () [}"
   (GH-106)
 
-* Fix compiler register limit bug where an Ecmascript function with
+* Fix compiler register limit bug where an ECMAScript function with
   [65536,262143] VM registers would be compiled into incorrect bytecode
   instead of being rejected with an internal error (GH-111)
 
@@ -1477,7 +1477,7 @@ Released
   notifications (AppNotify) (GH-596, GH-563)
 
 * Add duk_debugger_pause() API which allows the target to quickly pause
-  Ecmascript execution and break into the debugger (GH-615)
+  ECMAScript execution and break into the debugger (GH-615)
 
 * Add sizeof void pointer to the BasicInfo debugger command (GH-611)
 
@@ -1873,18 +1873,18 @@ Configuration:
 
 Buffers:
 
-* Incompatible change: rework buffer types and their Ecmascript and C API
+* Incompatible change: rework buffer types and their ECMAScript and C API
   behavior: remove Duktape.Buffer; provide Uint8Array.allocPlain() and
   Uint8Array.plainOf() to replace Duktape.Buffer; plain buffers now behave
   like Uint8Arrays and inherit from Uint8Array.prototype; plain buffers now
   test false in duk_is_primitive() which is more consistent with their
-  Ecmascript coercion behavior; many small changes in how built-in functions
+  ECMAScript coercion behavior; many small changes in how built-in functions
   behave for plain buffer arguments e.g. in enumeration, JSON serialization,
   and Object.prototype.toString() output (GH-875, GH-1005, GH-864, GH-1197)
 
 * Incompatible change: remove the ability to do a 1:1 buffer-to-string
   coercion (using buffer data directly as the internal string representation)
-  from the default Ecmascript bindings, an encoding (usually UTF-8) is now
+  from the default ECMAScript bindings, an encoding (usually UTF-8) is now
   always applied (GH-875, GH-1005)
 
 * Incompatible change: remove non-standard properties from ArrayBuffer
@@ -1947,7 +1947,7 @@ Other type changes:
   (plainPointer instanceof Duktape.Pointer === true) (GH-864)
 
 * Incompatible change: lightfunc values now test false in duk_is_primitive()
-  which is more consistent with how they behave in Ecmascript coercions
+  which is more consistent with how they behave in ECMAScript coercions
   (GH-864)
 
 * Incompatible change: lightfunc value as a "this" binding is ToObject()
@@ -1984,7 +1984,7 @@ Debugger:
 * Rename debugger protocol artificial property "bound" to "boundfunc" for
   consistency with an internal flag rename (GH-703)
 
-Ecmascript 2015+ and real world compatibility:
+ECMAScript 2015+ and real world compatibility:
 
 * Change Object constructor argument coercion policy to match ES2015
   requirements for .keys(), .getOwnPropertyNames(),
@@ -2015,7 +2015,7 @@ Ecmascript 2015+ and real world compatibility:
 
 * Add support for ES2016 exponentiation and exponentiation assignment
   operators, e.g. "2 \*\* 10" evaluates to 1024, avoiding the cost of an
-  Ecmascript call to Math.pow() while also being more readable (GH-987,
+  ECMAScript call to Math.pow() while also being more readable (GH-987,
   GH-997)
 
 * Add a Reflect built-in, provides Reflect.construct() etc. from ES2015; some
@@ -2118,7 +2118,7 @@ Ecmascript 2015+ and real world compatibility:
 WHATWG Encoding API:
 
 * Add TextEncoder and TextDecoder built-ins (the Encoding API) which allow
-  Ecmascript code to convert between buffers and strings using the UTF-8
+  ECMAScript code to convert between buffers and strings using the UTF-8
   encoding (GH-975)
 
 Other C API changes:
@@ -2154,8 +2154,8 @@ Other C API changes:
   DUK_ERR_UNSUPPORTED_ERROR; use standard error types instead (GH-827)
 
 * Incompatible change: map API related errors (which previously used
-  DUK_ERR_API_ERROR and a plain Error for Ecmascript representation) into
-  TypeErrors and RangeErrors to match common Ecmascript conventions (GH-827)
+  DUK_ERR_API_ERROR and a plain Error for ECMAScript representation) into
+  TypeErrors and RangeErrors to match common ECMAScript conventions (GH-827)
 
 * Incompatible change: remove duk_to_defaultvalue() which invoked the
   [[DefaultValue]] specification algorithm removed in ES2015 (it was folded
@@ -2193,7 +2193,7 @@ Other C API changes:
 
 * Add time functions to the C API (duk_get_now(), duk_time_to_components(),
   duk_components_to_time()) to allow C code to conveniently work with the
-  same time provider as seen by Ecmascript code (GH-771, GH-1209, GH-1211,
+  same time provider as seen by ECMAScript code (GH-771, GH-1209, GH-1211,
   GH-1226)
 
 * Add duk_push_bare_object() API call which pushes an object without an
@@ -2214,7 +2214,7 @@ Other C API changes:
 * Remove duk_{get,put,has,del}_var() calls from API header; they were not
   fully implemented and not part of the documented public API (GH-762)
 
-Other Ecmascript binding changes:
+Other ECMAScript binding changes:
 
 * Incompatible change: remove built-in print() and alert() bindings which,
   being dependent on stdout/stderr, are often a portability issue (GH-745)
@@ -2229,7 +2229,7 @@ Other Ecmascript binding changes:
   (which is difficult to version and work with) to an object with named
   properties; the properties are not under versioning guarantees (GH-1125)
 
-* Allow a bound Ecmascript function as an argument to new Duktape.Thread()
+* Allow a bound ECMAScript function as an argument to new Duktape.Thread()
   (GH-1134, GH-1157)
 
 Extras:
@@ -2338,7 +2338,7 @@ Footprint:
   lexenv/varenv fields in duk_hcompfunc struct (GH-1132); omit duk_hcompfunc
   _Formals array when it is safe to do so (GH-1141); omit duk_hcompfunc
   _Varmap in more cases when it is safe to do so (GH-1146); reduce initial
-  bytecode allocation in Ecmascript compiler for low memory targets (GH-1146);
+  bytecode allocation in ECMAScript compiler for low memory targets (GH-1146);
   packed arguments for some internal helper calls (GH-1158, GH-1172); misc
   internal helpers to reduce call site size (GH-1166, GH-1173); config options
   for function .name and .fileName control (GH-1153); internal helper
@@ -2436,7 +2436,7 @@ Other bug fixes:
 Miscellaneous:
 
 * Incompatible change: bytecode opcode format reworks drop maximum function
-  and constructor call argument count from 511 to 255, and maximum Ecmascript
+  and constructor call argument count from 511 to 255, and maximum ECMAScript
   function constant count from 262144 to 65536 (GH-903)
 
 * Add a human readable summary of 'new MyConstructor()' constructor call
@@ -2939,11 +2939,11 @@ Miscellaneous:
 * Function.prototype.call(), Function.prototype.apply(), Reflect.apply(),
   and Reflect.construct() can now be used in tailcalls (e.g.
   'return func.call(null, 123);'), don't grow the native C stack when doing an
-  Ecmascript-to-Ecmascript call, and no longer prevent coroutine yielding
+  ECMAScript-to-ECMAScript call, and no longer prevent coroutine yielding
   (GH-1421, GH-1545, GH-1557)
 
 * Constructor calls (new Func()) can be used in tailcalls, don't grow
-  the native C stack when doing an Ecmascript-to-Ecmascript call, and no
+  the native C stack when doing an ECMAScript-to-ECMAScript call, and no
   longer prevent coroutine yielding (GH-1523)
 
 * Increase maximum call argument count from 255 to ~64k (GH-1292, GH-1586)
@@ -3050,11 +3050,11 @@ Miscellaneous:
 
 * Use monotonic time (if available) for debugger transport peeking, so that
   the peek callback is called with the same realtime rate even if the
-  Ecmascript time source jumps or doesn't advance in realtime (GH-1659)
+  ECMAScript time source jumps or doesn't advance in realtime (GH-1659)
 
 * Allow sub-millisecond resolution for DUK_USE_DATE_GET_NOW() Date provider;
   the extra resolution is visible through duk_get_now() but not through Date
-  instances because Ecmascript requires Date instances to have integer
+  instances because ECMAScript requires Date instances to have integer
   millisecond timestamps (GH-773, GH-1660, GH-1669)
 
 * Add sub-millisecond resolution to the default POSIX and Windows Date
@@ -3253,7 +3253,7 @@ Planned
   internal algorithm and duk_to_primitive() API call (GH-1825)
 
 * Add duk_random() to allow C code access to the same random number source
-  as Ecmascript code (GH-1815)
+  as ECMAScript code (GH-1815)
 
 * Add duk_push_new_target() to allow C code to access new.target; at present
   this is for completeness because without actual class support it's only
@@ -3326,7 +3326,7 @@ Planned
 
 * Add Makefile.jsoncbor to the distributable (GH-1885)
 
-* Change spelling from Ecmascript to ECMAScript throughout the internal source
+* Change spelling from ECMAScript to ECMAScript throughout the internal source
   code; as far as external behavior is concerned this only affects a few
   debug prints (GH-1894)
 

config/tags.yaml

@@ -4,19 +4,19 @@
 #
 
 ecmascript:
-  title: Ecmascript Edition 5 (ES5) options
+  title: ECMAScript Edition 5 (ES5) options
 
 ecmascript2015:
-  title: Ecmascript 2015 (ES6) options
+  title: ECMAScript 2015 (ES6) options
 
 ecmascript2016:
-  title: Ecmascript 2016 (ES7) options
+  title: ECMAScript 2016 (ES7) options
 
 ecmascript2017:
-  title: Ecmascript 2017 (ES8) options
+  title: ECMAScript 2017 (ES8) options
 
 ecmascript2018:
-  title: Ecmascript 2018 (ES9) options
+  title: ECMAScript 2018 (ES9) options
 
 duktape:
   title: Duktape specific options

debugger/duk_debug.js

@@ -417,7 +417,7 @@ RateLimited.prototype.trigger = function () {
 /*
  *  Source file manager
  *
- *  Scan the list of search directories for Ecmascript source files and
+ *  Scan the list of search directories for ECMAScript source files and
  *  build an index of them.  Provides a mechanism to find a source file
  *  based on a raw 'fileName' property provided by the debug target, and
  *  to provide a file list for the web UI.

dist-files/README.rst

@@ -2,13 +2,13 @@
 Duktape
 =======
 
-Duktape is a small and portable Ecmascript E5/E5.1 implementation.  It is
+Duktape is a small and portable ECMAScript E5/E5.1 implementation.  It is
 intended to be easily embeddable into C programs, with a C API similar in
 spirit to Lua's.
 
 Duktape supports the full E5/E5.1 feature set (with some semantics updated
 from ES2015+) including errors, Unicode strings, and regular expressions,
-a subset of Ecmascript 2015 (E6) and Ecmascript 2016 (E7) features (e.g.
+a subset of ECMAScript 2015 (E6) and ECMAScript 2016 (E7) features (e.g.
 computed property names, Proxy objects, exponentiation operator, Reflect),
 ES2015 ArrayBuffer/TypedView, Node.js Buffer, performance.now(), and WHATWG
 Encoding API living standard.

runtests/runtests.js

@@ -1,5 +1,5 @@
 /*
- *  Test case runner.  Supports both Ecmascript tests and Duktape API
+ *  Test case runner.  Supports both ECMAScript tests and Duktape API
  *  C tests.  Duktape API C tests are compiled on-the-fly against a
  *  dynamic or static library.
  *

src-input/duk_js_compiler.h

@@ -5,7 +5,7 @@
 #if !defined(DUK_JS_COMPILER_H_INCLUDED)
 #define DUK_JS_COMPILER_H_INCLUDED
 
-/* ecmascript compiler limits */
+/* ECMAScript compiler limits */
 #define DUK_COMPILER_TOKEN_LIMIT           100000000L  /* 1e8: protects against deeply nested inner functions */
 
 /* maximum loopcount for peephole optimization */