+** Many basic lisp operations are now faster.
+This is especially the case when running a Mule-enabled XEmacs.
+
+A general overhaul of the lisp engine should produce a speedup of 1.4
+in a Latin-1 XEmacs, and 2.1 in a Mule XEmacs. These numbers were
+obtained running (byte-compile "simple.el"), which should be a pretty
+typical test of `pure' lisp.
+
+Lisp hash tables have been re-implemented. The Common Lisp style hash
+table interface has been made standard, and moved from cl.el into fast
+C code (See the section on hash tables in the XEmacs Lisp Reference).
+A speedup factor of 3 can be expected with code that makes intensive
+use of hash tables.
+
+The garbage collector has been tuned, leading to a speedup of 1.16.
+
+The family of functions that iterate over lists, like `memq', and
+`rassq', have been made a little faster (typically 1.3).
+
+Lisp function calls are faster, by approximately a factor of two.
+However, defining inline functions (via defsubst) still make sense.
+
+And finally, a few functions have had dramatic performance
+improvements. For example, (last long-list) is now 30 times faster.
+
+Of course, your mileage will vary.
+
+Many operations do not see any improvement. Surprisingly, running
+(font-lock-refontify-buffer) does not use the Lisp engine much at all.
+Speeding up your favorite slow operation is an excellent project to
+improve XEmacs. Don't forget to profile!
+
+** XEmacs finally has an automated test suite!
+Although this is not yet very sophisticated, it is already responsible
+for several important bug fixes in XEmacs. To try it out, simply use
+the makefile target `make check' after building XEmacs.
+
+** New hash table implementation
+As was pointed out above, the standard interface to hash tables is now
+the Common Lisp interface, as described in Common Lisp, the Language
+(CLtL2, by Steele). The older interface (functions with names
+containing the phrase `hashtable') will continue to work, but the
+preferred interface now has names containing the phrase `hash-table'.
+
+Here's the executive overview: create hash tables using
+make-hash-table, and use gethash, puthash, remhash, maphash and
+clrhash to manipulate entries in the hash table. See the (updated)
+Lisp Reference Manual for details.
+
+** Lisp code handles circular lists much more robustly.
+Many basic lisp functions used to loop forever when given a circular
+list. Now this is more likely to trigger a `circular-list' error.
+Printing a circular list now results in something like this:
+
+ (progn (setq x (cons 'foo 'foo)) (setcdr x x) x)
+==> (foo ... <circular list>)
+
+An extra bonus is that checking for circularities is not just
+friendlier, but actually faster than checking for quit.
+
projects / chise / xemacs-chise.git- / blobdiff