For details of these, see the documentation in the LispWorks User Guide and Reference Manual , unless a manual is referenced explicitly.
The character implementation in LispWorks now covers the full range of the Unicode standard, including the supplementary planes in addition to the Basic Multilingual Plane (BMP). This involves the following changes:
cl:code-char accepts integers from 0 below
cl:char-code-limit. Other values cause an error. For codes in the surrogate range it returns
nil. Reading characters from streams and converting characters from foreign strings can generate characters in the whole range (depending on the external format used), and can never generate character objects corresponding to surrogate code points.
Character bits and font attributes (as specified in
Common Lisp: the Language (2nd Edition)
are no longer supported.
char-font-limit have been eliminated from the LISPWORKS package. The syntax for reading characters with bits is now illegal and trying to read such a character (for example
#\c-a) will signal an error.
LispWorks 6.1 and earlier versions also accept some special characters representing keystrokes that do not correspond to Unicode characters, such as
#\Home. These are illegal in LispWorks 7.0 and later and will signal an error too.
Use strings rather than characters to define LispWorks Editor key sequences with modifiers. See Editor bindings for keystrokes with modifiers for examples.
In other situations when you previously used character bits, you should use Gesture Spec objects (see
sys:coerce-to-gesture-spec). The function
sys:gesture-spec-to-character will now signal an error if the gesture spec has bits or corresponds to a non-character key like
F1, unless the new errorp argument is supplied as
16-bit characters and 16-bit strings are implemented by the new types
lw:simple-bmp-string (BMP is Basic Multilingual Plane, comprising the Unicode code points
lw:simple-text-string consume 32 bits per character now, but in LispWorks 6.1 and earlier versions they consume only 16 bits per character. If you have an application that uses many 16-bit strings and you are worried about memory size, you may consider using strings of type
lw:bmp-string instead of
lw:text-string. That will work provided that all the characters you ever use have codes less than
#x10000. If the codes are all below
256, you can use
lw:unicode-alpha-char-p and so on have been updated to follow the rules specified in Unicode 6.3.0.
Code Coverage allows you to compile your code with code execution counters which record when each piece of code is executed. After exercising your code you use a web browser or the LispWorks IDE tools to visualize which parts of your program were executed and how frequently.
See "Code Coverage" in the LispWorks User Guide and Reference Manual , and New Code Coverage tool.
You can now perform socket I/O operations that invoke a callback when they are complete, rather than synchronously calling a function that returns a value (like
cl:read-line). This allows many operations to run in a single thread. See "The Asynchronous I/O API" in the
LispWorks User Guide and Reference Manual
The new function
hcl:fast-directory-files is a faster way to access files than
cl:directory, especially in situations when you need to filter based on simple features such as size and access time, or filter based on the name in a more complex way than
hcl:unlocked-queue is useful when accessing the queue is always done together with other operations that need to be "atomic", so that you need a lock around them anyway, or when adding and removing items is done in the same process.
sys:run-shell-command is called with
:wait nil and
:save-exit-status t, it now always returns three values (stream, error-stream, process) even if none of the input, output or error-output arguments have the value
:stream. This allows the exit status of the process to be recovered by calling
sys:pipe-exit-status on stream.
The main change is the interpretation of backslash and double-quote (see the
CommandLineToArgvW function at
Ring objects can be used to hold Lisp objects and provide stack-like behavior. Each ring is limited to a maximum number of elements and can be rotated. You can control the insertion point where elements get added and removed, and iterate across the elements. For more information, see
The new function
hcl:reduce-memory frees memory and tries to reduce the size of a 32-bit LispWorks image, without enlarging it even temporarily. It is therefore better than
hcl:clean-down when the operating system has signalled that memory is low.
(stop-profiling :suspend t)
(start-profiling :initialize nil)
Source level stepping of subforms occurring within a macro expansion works, provided that the subform is
eq to the original subform in the call to the macro. In the rare case where a macro copies a subform, making it non-
eq, you can use the
dspec:replacement-source-form macro to indicate which original subform should be identified as the source code for the new form.
The predicate function
hcl:delivered-image-p returns true when called from a delivered image, that is an image saved by a call to
lw:deliver. It returns
nil otherwise. It exists in LispWorks 6.1, but is now documented in LispWorks 7.0.
hcl:load-data-file is now more flexible with respect to the file type of the loaded file; you can control whether loaded forms are evaluated; and you can provide a custom callback as an alternative to printing the result of each form. It still allows you to load data files created with previous versions of LispWorks and on most platforms.
cl:compile-file keyword argument
:load now accepts the special value
:delete, which means load the compiled file and then delete it (not affecting the source file). This is especially useful when using
:output-file :temp, to avoid leaving compiled (fasl) files on disk.
comm:accept-tcp-connections-creating-async-io-states now accept a backlog argument which specifies the maximum number of pending connections for the socket in the operating system.
LispWorks Release Notes and Installation Guide - 2 Mar 2015