Tag JSREF_RELEASE_19980414 (4/14/98): - RegExp unicode fix. - Added new iterator-style JSObjectOps enumeration API for host objects. See jspubtd.h for details. Tag JSREF_RELEASE_19980413 (4/13/98): - Date fixes: - ECMAv1 fix: fixed function length for Date setters. - Bug workaround: avoid MSVC optimizer bug in Date. - Y2K fix: Use the verbose '%#c' date formatter for toLocaleString on windows, to get a 4 digit date. - New thread safety fixes from bjorn: - Added more asserts to catch cases where the thread identifier stored in the context is out of synch with the current thread. JS_ATOMIC_ADDREF now calls a function instead of a macro, so that when compare-and-swap is implemented using busy-wait (e.g. SPARC v8), we avoid being confused by the busy value. For the same reason, we now call AtomicRead at certain places in jslock.c. Finally, the environment variable JS_NO_THIN_LOCKS, when set, effectively turns off the thin locks so that all locking is done using NSPR only. - ECMAv1 numeric fixes: print preceding 0 when formatting 0.4, ignore supplied radix to Number.prototype.toString when printing non-finite numbers. Tag JSREF_RELEASE_19980403 (4/3/98): - API renaming: JS_NewRuntime for JS_Init, JS_DestroyRuntime for JS_Finish (the old names are maintained for backward binary compatibility; the new names are macros). - Improved JS_THREADSAFE locking, with compare-and-swap based optimization of the uncontested lock and unlock cases to avoid DLL-crossing and worse native OS locking overhead. The Request/GC interlock enforced by JS_BeginRequest, JS_EndRequest, JS_GC, and JS_MaybeGC allows requests on the same cx to nest (JS_BeginRequest may be called more than once before JS_EndRequest, so long as the number of End calls matches the number of Begin calls). Thread-safety for prarena.c and prdtoa.c, based on jslock.h/JS_THREADSAFE. - Experimental JS exception implementation, subject to change. Any value may be thrown. The catch expression must be of the form (v) or (var v). Catch code must re-throw as there is no way yet for the compiler to decide that no catch clause matched (and more than one catch clause makes no sense, yet -- no finally yet, either). - JS_ConvertArguments API addition, for converting an argc/argv pair according to a simplified scanf-like format string. - JS_GetPropertyAttributes and JS_SetPropertyAttributes API additions, which take C-string property names (Unicode string and indexed elements TBD). - JS_CloneFunctionObject, for server-like environments where code (functions) should be shared in a prototype object, but data (global variables) must be per request in a set of objects, one per concurrent request. You load the functions in the prototype, then "fault them in" on demand via the request object's resolve hook, using JS_CloneFunctionObject to make a lightweight copy that has the right scope (__parent__) link. - Whacked js.c (more whacking needed) so it uses fewer secret js_* calls and more JS PUBLIC/FRIEND API entry points. - Simplified Windows MSDEV build regime to use js.mak/mdp only, which builds the DLL as a sub-project, then compiles js.c and links the JS shell. - Fix a lying comment about JS_AddRoot in README (which is being turned into a real "JS API tutorial" document, due soon). - Better error reporting for an operand that does not convert to function, and spiffed up the decompiler (jsopcode.c) to remove hardwired opcode lengths. - Atom indexing does not abuse the atom's next link and a flags bit, which had been done in haste long ago (and not fixed till now), but which required that compilation be single-threaded throughout a runtime. - ECMAv2 change: undefined is a top-level property with undefined value (it may be overwritten or deleted by a script). - ECMAv1 fix: arguments is implemented as a separate object from Call, but with Netscape extensions (callee, caller). - ECMAv1 fix: array length and indexes are uint32. - ECMAv1 fixes enabled by major overhaul of the compiler to generate a tree of parse-node structures and generate code from it. The bugs had to do with the order of evaluation and conversion in for/in loop and assignment expressions. This change also moved the "quickening" for name-to-arg/var-slot bytecodes from the interpreter to the compiler. - Proposed ECMAv2 toSource method, which produces compilable object and array initializers and new expressions to reconstruct a given graph. - Proposed ECMAv2 instanceof operator, based on hasInstance JSObjectOp and (for maximum code-sharing among native object classes, with one exception) JSClass methods. There is also js_IsDelegate, for checking whether a given object is a prototype of another. - To-be-proposed ECMAv2 in operator, inspired by for/in loop syntax: ('p' in o) for o = {p:1} is true; (1 in o) for o[1] defined (even with value undefined) is true. Note distinction between typeof o.p == "undefined" and ('p' in o). - XDR (eXternal Data Representation) code to support Script.prototype.freeze and Script.thaw/Script.prototype.thaw. You can store a persistent, portable encoding of a script (including its top-level functions and all their kids) and load it later. Exception "try-notes" are not currently XDR'd; this will be fixed next time. - Recent GC bugs mentioned in snews://secnews.netscape.com/netscape.dev.jsref have been fixed. The patches were posted already; this tarball rolls them up along with other fixes and improvements. We've had help from Netscape's Application Products Division in stress-testing this release; we are pretty confident that JS_THREADSAFE GC and request execution work well. One new fix: finalizers are run without the GC lock held, to allow them to call JS_RemoveRoot and otherwise to avoid AB-BA deadlocks. - Call and construct are now optional methods in JSObjectOps and JSClass. The hack of converting a regexp to a function is no longer necessary, and script callability (shorthand for script.exec) uses the JSClass call hook likewise. - Fixed standard class bootstrapping bug that left an extra Object instance in the middle of the prototype chain for Date, RegExp, etc. (all but Object and Function) instances. - String.prototype.split ECMAv1 conformance restoration (split-by-empty-string was stupidly broken last time). Tag JSREF_RELEASE_19980219 (2/16/98): - Fixed very recent i++ (for undefined i) crash-bug (also prior, longstanding bug where i++ for undefined i resulted in NaN). - ECMA conformance for [[DefaultValue]] (8.6.2.6), ToBoolean (9.2), and null (default) this-parameter handling (10.2.3). - New bytecodes paving the way for ECMA-conformant for/in loops and unqualified name assignment. - JS1.2 String.prototype.replace did not emulate Perl4's expansion of $` to be the global left context (not from last local match). Essentially the same bug bit replace for the empty-string global match case, which "bumps along" by one character, but failed to include that character in local left context (so "abc".replace(/ */g, 'X') produced "XXXX" instead of "XaXbXcX"). - Fix recent regression that clamped String.prototype.split's limit argument at the subject string's length. - Fixed type mismatch problems in #if !JS_HAS_REGEXPS code. Tag JSREF_RELEASE_19980216 (2/16/98): - Fixed stuck GC lock by adding JS_UNLOCK_GC at the bottom of js_GC. Tag JSREF_RELEASE_19980213 (2/13/98): - Add JS_ShutDown API, which must be called after all JSRuntimes have been destroyed by JS_Finish calls, and from a single thread, when shutting down or restarting the program in which JSRef is embedded. This is needed to avoid leaking the deflated_string_cache and (JS_THREADSAFE only) lock. Tag JSREF_RELEASE_19980212 (2/12/98): - Finer-grained locking. Instead of one big, reentrant lock around the entire runtime, there are distinct locks: - The non-reentrant runtime lock, a binary semaphore to protect the runtime's contextList and other members. - An atom state lock used only in jsatom.c for a thread-safe internal atom table API. This lock is never held while calling out from jsatom.c to other modules that may acquire locks, and no caller into jsatom.c's lock- acquiring entry points does so while holding a lock of its own (the GC calls non-locking entry points only). - A lock and pair of condition variables for interlocking GC execution with script execution. The GC may run only when no script requests are running, or when at most one is running and it has invoked the GC from its branch callback. The new JS_SetGCCallback API may be used to supply a function to be called at the beginning and end of GC -- if called at the beginning, a false return value will cancel the GC run. - A reentrant lock per native object map (scope) to protect the JSScope and its parts (JSProperty, JSSymbol, and PRHashTable structures) as well as the slots vectors of all instances sharing the scope (the prototype object and any unmutated clones of it). The model jslock.c and jslock.h provided include four new header files that are not yet supplied with JSRef: - pratomic.h for PR_COMPARE_AND_SWAP_WORDS and PR_COMPARE_AND_SWAP_INT32 macros that take an address, an old value, and a new value, and return true if the old value is at the address, in which case the new value is atomicly stored there; and return false without changing memory otherwise. - prcvar.h for the PRCondVar condition variable type and its operations (New, Destroy, Wait, Notify, and NotifyAll). - prlock.h for the PRLock binary semaphore type and its operations (New, Destroy, Lock, and Unlock). More lock overhead and lock-free synchronization optimizations are coming in a future JSRef release. In anticipation of these changes, the JS_THREADSAFE version of JS_GetClass now requires an initial JSContext *cx argument along with JSObject *obj. - New String.prototype.replace feature: a function expression may be passed as the second argument, in which case it will be invoked with the match and parenthesized submatch strings as arguments, followed by input and index (these are come from the extended array returned by RegExp.prototype.exec and String.prototype.match). This "lambda replacement" approximates Perl's s///e flag; the idea came from Mike Shaver (shaver@netscape.com). Here's a example function that replaces any number with an F after it (for Fahrenheit) with its Celsius conversion: // f2c("32F, 212F, or 0F") => "0C, 100C, or -17.77777777777778C" function f2c(x) { var s = String(x) return s.replace(/(\d+(\.\d*)?)F\b/g, function ($0,$1,$2) { return (($1-32) * 5/9) + "C" }) } - First-character discrimination optimization for regular expressions, plus a fix to anchor-search for \b and \B. - A first-class Script object to decompose eval into its compile and exec parts (so you can compile outside a long loop, then exec in the loop body to avoid recompiling invariant source). See jsscript.c. - More ECMA fixes: - bitwise logical and shift operators use the correct ECMA type conversions, intermediate types, and boundary behavior. - Array.prototype.push emulates Perl5 for JS versions other than 1.2; there it emulated Perl4, except when no arguments were passed (it would return the array object bound to this in that case; fixed to return undefined). - All generic Array methods now update a length property, in case no such property existed in the object that delegates to Array.prototype, or that refers to the particular method. - Except for JS1.2, Array.prototype.splice always returns an array, even when given no arguments or a zero-length slice. JS1.2 compatibility continues. - NaN Date fixes. - JSFunctionSpec's nargs member now species the "best arity" of the function, which ECMA specifies as the value of the function's length property. So to allocate local GC roots, use the new extra member of JSFunctionSpec and let nargs count only the minimum or optimum number of desired arguments. - Relational and equality operator fixes too gnarly and subtle to describe here, affecting mainly the hint argument (or lack of it) to valueOf. - A new JS_IsConstructing API and underlying support, so ECMA [[Call]] and [[Construct]] can be distinguished. - A JS_InitClass extension to tolerate NULL for the constructor native C function argument -- this causes a class like Math to be created, where the class object is not callable or constructable. - Fixes to handle non-finite indexes in several string and array methods. - A high-level object operation dispatch table has been added. See JSObjectOps in jsapi.h, and the new flags and function pointers in JSClass. To provide a table of object operations, your class should set the JSCLASS_HAS_OBJECTOPS flag and implement the getObjectOps class method, returning the address of a static or otherwise appropriate-lifetime JSObjectOps structure. The methods in this struct will be specified in a forthcoming version of the JS API doc. The JSCLASS_NEW_ENUMERATE flag can be used without adding getObjectOps to your class, to say that its enumerate method returns a JSIdArray containing all lazy and eager property ids for an object, instead of having to define all lazily-bound properties in the object, to minimize locking and reduce the space cost of old-style enumerate. - Atoms are now garbage-collected. To clarify the fact that symbol table ids are either tagged jsval-like integers, or else JSAtom pointers, a new typedef called jsid (equivalent to jsval in C) has been introduced. - Major changes to remove JSProperty's object member, in order to optimize for space. These mostly entail an extra &obj2 or &pobj result parameter being passed to js_FindProperty, js_LookupProperty, etc., to capture the prototype or original object in which the property was found. - Updated Windows MSDEV makefiles to support MSDEV5.0 as well as 4.2: - js32.mak, an NMAKE makefile, builds js32.dll - jsshell.mak, an NMAKE makefile, now recursively invokes js32.mak to build js32.dll - jsshelld.mak and jsshelld.mdp, collectively a 4.2 IDE project, build jsshell.exe and have a subproject that builds js32.dll. These two project files are not derived from the other .mak files, nor are the other .mak files derived from them. - JS_PUBLIC_API etc. macros in jspubtd.h, used by jsapi.h and a few other .h files, to optimize linkage within the Windows DLL. Tag JSREF_RELEASE_19971128 (11/28/97): - Major Unicode changes. JSString has a jschar *chars member now, not char *bytes; it points to a counted array of uint16 (jschar) elements. The scanner handles \uXXXX escapes; so does the regular expression parser. JS_GetStringBytes(str) now returns the ISO-Latin-1 counterpart of str's Unicode sequence by decimating into separate memory whose lifetime matches that of str->chars. The API entry points taking char *name or char *base arguments now have UC counterparts (except for the JS_*Property entries) that take jschar *name, size_t length or similar argument-pairs. There is a new JS_ValueToUint16 API entry for converting from a jsval to a Unicode code point. - The beginnings of JavaScript 1.3 version support, including === and !== for equality by type and value identity, and sharp variables (see below). - Linux support from Mike Shaver (shaver@ingenia.ca, shaver@netscape.com) in config/Linux_All.mk. OS/2 ifdefs from IBM (initials DSR?), via Dan Libby (danda@netscape.com). - A new gc command in the js shell for testing, useful in conjunction with the GC_MARK_DEBUG ifdef'd code in jsgc.c and js.c to plug leaks and find stuck references. Use the new API entry point JS_AddNamedRoot in preference to JS_AddRoot, which still exists but provides no debugging name for the GC thing graph root that it establishes. See also JS_DumpNamedRoots. - JSCLASS_NEW_RESOLVE flag and JSNewResolveOp function pointer typedef, for more efficient unbound name resolution. - Sharp variables (based on Common Lisp's dispatching macros of the same form) for expressing cycles and join-points in object graphs created by object and array initializers. For example, #1={p:#2={q:42}, r:{cycle:#1#, joinPoint:#2#}} creates an object, call it o, where o.p and o.r.joinPoint both reach the same object, which has a property named q with value 42; and o.r.cycle is o. In a future release, the final JS1.3 version will return object and array initializer strings from {Object,Array}.prototype.toSource methods, rather than toString, for ECMA and backward compatibility. - More ECMA conformance fixes, apart from Unicode: - New ECMA-conformant jsdate.c by Mike McCabe (mccabe@netscape.com). - Improved equality and relational operator implementations. - Correct division operator result sign. - The unary-plus operator. - NaN and Infinity top-level properties. - Setting a read-only property fails silently, rather than stopping the script with an error report. - Deleting a permanent property fails with a false return from the delete operator. If the property is not in the object addressed in the delete expression, or it is successfully deleted, the expression results in true. - The beginnings of finer-grained, non-nesting/low-level locking in jslock.h, used in jsstr.c for the deflated_string_cache_lock. For this version, you need to provide a PRLock typedef and PR_NewLock, PR_DestroyLock, PR_Lock, and PR_Unlock functions that implement a binary semaphore. - Performance improvements based on aggressive, coherent use of the property cache (part of the JSRuntime structure). This required a fix to restore a watchpoint associated with a deleted property when a new property with the same identifier is created in the same object. - Regular expression bugfixes and Unicode extensions in jsregexp.c and jsstr.c. - Fixed Perl bug where \xZ or similar was translated to "\0Z". - Fixed another Perl bug where [x-\d] matched {'x', '-', '0', ... '9'} but [\d-x] matched only the digits. The second is now equivalent to the first. - Fixed JS bug where only $1 through $9 could be used in the replacement string passed to String.prototype.replace. Also allow literal $ in the replacement string if it is preceded by \ (as a JS literal: "\\$"). - Fixed non-JS1.2 versions to return left context from start of global match instead of from end of last local match (Perl4 had a similar bug which 1.2 emulated too much). This alters "$`" expansion in replacement strings. Tag JSREF_1_14_RELEASE (around 7/22/97): - JSTaskState and related API entry point names have been renamed to use the trendier "Runtime" rather than "TaskState", ditto rt or runtime for task. - JS_GetScriptPrincipals is no longer in jsapi.h, it moved to jsdbgapi.h and has a new interface that takes the JSScript * being queried. It therefore requires JS_FrameIterator and JS_GetFrameScript. - JS_LockGCThing/JS_UnlockGCThing and their macro wrappers JSVAL_LOCK/UNLOCK are deprecated as of now. Use JS_AddRoot to register a pointer to the thing you would lock, and clear the pointer and/or JS_RemoveRoot its address later to unlock the thing. I would like to remove GC thing-locking in a future release; it precludes too many alternative GC implementations. - ECMA conformant Date API, including get/setFullYear and the UTC variants to all the get/set methods. - ECMA conformant Number.MIN_VALUE, which is the smallest denorm now, not the smallest normal as in all past JS versions. - ECMA comformant isFinite() function. - ECMA signed 0 and NaN number to string conversions. - Watcom (__WATCOMC__) support for PC builds. Quick update (4/27/97): - Prototypes are no longer constructed in JS_InitClass. If you want a class prototype to be constructed by the native 'constructor' function passed to JS_InitClass, you can save JS_InitClass's return value and do it yourself: proto = JS_InitClass(...); ok = JS_CallFunctionName(cx, proto, "constructor", argc, argc, &rval); - Object, array, and function literals are supported on input for JS_VERSION 1.2 at compile-time. Only for JS_SetVersion(cx, JSVERSION_1_2) at runtime: object.toString() returns an object literal, likewise for array.toString, and function.toString returns an anonymous function literall (rather than the definition of a function named "anonymous") for functions created using new Function(...). - Final RegExp API: regexp.exec and string.match always return null on mismatch (not -1), and always return a match array on match (whether parens matched or not). The match array's 0'th element is the matching string, and any paren submatches are in elements 1..N. The index and input properties can be used to find left and right context without resort to the RegExp.leftContext and RegExp.rightContext statics: leftContext = match.input.substring(0, match.input.index) rightContext = match.input.substring(match.input.index + match[0].length) - A JS_MaybeGC entry point in the API, safe to use from branch callbacks (well tested) and arbitrary preemption points (not so well tested) when garbage may be piling up, but a forced GC (JS_GC) is not desirable. - Various bugfixes and improvements. Newer news (3/18/97): - Regular expressions a la Perl are supported. - Perl array methods push, pop, shift, unshift, and splice are supported. - Perl substr, with its righteous interpretation of negative offset, is also now supported. - Lexical closures a la Scheme are supported. See ycomb.js. - Property caching and other performance improvements have been added. - Mac CodeWarrior JSRef.prj and MacPrefix.h files are now bundled. - Windows MSDEV4.2 .mak and .mdp files bundled. - The 32-bit Windows version of prcpucfg.h is shipped; on Unix platforms, you should remove this file or set it aside and let gmake generate the right one for your host architecture. - Classes whose objects have private data (JS_SetPrivate/JS_GetPrivate) must flag that fact with the JSCLASS_HAS_PRIVATE flag in their JSClass structs. - There are also two new property ops in JSClass, addProperty and delProperty. News flashes (12/31/96): - Define JS_THREADSAFE and write code in jslock.c for multi-threaded JS. - NOTE: JS_EvaluateScript and JS_ExecuteScript no longer return a JSVAL_LOCKed result in *rval -- this was never safe in a multithreaded environment, when *rval referred to an object tree of depth > 1, because a preempting GC run could reclaim the unrooted, descendent objects. Instead, callers of these API entry points must use JS_AddRoot and JS_RemoveRoot to maintain the rval pointer argument in the GC's root set. See JS_AddRoot comments below. - Labeled statements and break and continue to label a la Java are supported. - The switch statement is now supported. You can switch on any primitive type value (number, string, boolean). - Numerous performance enhancements, notably the quick ops at the bottom of jsopcode.def, have been made.