Release Notes for Allegro CL 6.0

The index for the Allegro CL Documentation is in index.htm. The documentation is described in introduction.htm.

This document contains the following sections:

1.0 Introduction

This document provides the release Notes for release 6.0 of Allegro Common Lisp and related products. The sections describe the release notes for the various components (Allegro CL and related products). Each section is divided into non-backward-compatible changes (that produce different behavior in release 6.0 compared to release 5.0.1) and changes unrelated to backward-compatibility. Note that a bug fix is not considered a backward-incompatible change even if it does result in changed behavior because the previous behavior was erroneous.

This document is very long, with many chnages, major and minor, described. Please look particularly at these sections:

• 3.1 New features in the base Lisp: this section describes new features.
• 3.2 Non-backward-compatible changes in the base Lisp: this very important section describes changes to Allegro CL which are not backward compatible. You may have to modify your source code in light of these changes.
• 5.1 Non-backward-compatible changes in Common Graphics: [Windows customers only] this section describes changes to Common Graphics which are not backward compatible. You may have to modify your source code in light of these changes.
• 6.1 Non-backward-compatible changes in AllegroStore: [AllegroStore customers only] this section describes changes to AllegroStore which are not backward compatible. You may have to modify your source code in light of these changes.

If you notice changed or unexpected behavior with an operator, variable, or facility, search for its name in this document to see whether there is an entry concerning it.

2.0 Release Notes for installation

1. New installation procedure: starting in release 6.0, users install a complete Allegro CL system including all add-on products. The version of Allegro CL used (Professional or Enterprise) and the add-on features available are controlled by a license file. This license file is supplied separately (customers will receive email telling them how to retieve their license file). There is no license file on the distribution CDs and Allegro CL will not work without a valid license file in place. Installation is described in installation.htm. The license file is described in more detail in The Allegro CL license file in startup.htm.
2. The distribution includes 8 bit and 16 bit character images. Allegro CL 6.0 has images that support 8 bit characters only, or 16 bit characters only. It is our expectation that most users will use the 16 bit images. Executables supplied with the distribution either have or do not have `8' in the name. Those with 8 in the name (mlisp8 and alisp8, e.g.) support 8 bit characters. Those without a number in the name support 16 bit characters. Image (dxl) files also come in 8 and 16 varieties. Again, 8 in the name means 8 bit character support. Character support for images and executables must match. Trying to start an executable with the wrong type of image fails.
3. No prebuilt Allegro Composer images in the distribution. To create an Allegro Composer image, start Allegro CL and load buildcomposer.cl. That will produce composer and composer.dxl, or composer8 and composer8.dxl. Allegro Composer is available on Unix only.
4. No prebuilt Allegro CLIM images in the distribution. To create a CLIM image, start Allegro CL and load buildclim.cl. That will produce clim and clim.dxl, or clim8 and clim8.dxl.

3.0 Release Notes for the base Lisp

3.1 New features in the base Lisp

We have added a number of new capabilities to Allegro CL, incuding some that improve networking functionality. Here we give links to the documentation of the new features.

1. AllegroServe. AllegroServe (sources not included in the distribution, but available via Open Source license (at http://allegroserve.sourceforge.net), is a web server that can dynamically generate web pages and "web-enable" existing applications with a browser front-end. Built with the goal of enabling developers to publish complicated web pages, AllegroServe gives developers the advantage of servicing large numbers of users on different types of computers, regardless of where they are located. See Appendix D AllegroServe: Working with the Apache web server. A snapshot of the documentation (but it will likely be updated) is in the distribution at aserve/aserve.html.
2. Secure Socket Layer: Allegro CL 6.0 Enterprise supports a secure socket layer. Note that it is only available on platforms with a shared-library version of the OpenSSL libraries (which is not all platforms on which Allegro CL runs -- see Installing OpenSSL libraries in installation.htm). See Secure Socket Layer (SSL) in socket.htm for more information.
3. URI. Support for Universal Resource Indicators. See uri.htm.
4. DNS. Support for Domain Naming Systems. See dns.htm.
5. Relative packages. We have extended package naming to allow relative package names. See packages.htm.
6. Test harness. The testing code used by Franz Inc. for testing Allegro CL has been made available. See test-harness.htm.
7. Simple-streams. The implementation substrate for streams is new. See streams.htm.
8. Support for automatic generation of foreign function definitions. The cbind facility provides tools for automatically generating Lisp code for calling foreign functions using information obtained by scanning C header files. This facility is not fully integrated into the 6.0 release. It is only available for Solaris, IRIX, and Windows. Look at cbind/readme.txt on distribution CD One for Sun and IRIX and on distribution CD Two for Windows. That file contains pointers to the more complete documentation included in that directory.
9. Pretty-printing and speed. We have determined that pretty printing is a significant user of compute cycles, and that turning pretty printing off produced significant speedup of code that did output. A new variable *pprint-gravity* has been defined and techniques are recommended for not paying the overhead when it is not necessary. Please see Speed and pretty printing in implementation.htm for details.

3.2 Non-backward-compatible changes in the base Lisp

1. Modern Common Lisp case mode. The distribution contains images of Allegro CL with a case-sensitive (modern) reader, which does not automatically upcase unescaped strings naming symbols. This means that lowercase strings name different symbols than uppercase strings containing the same letters (and mixed case strings name different symbols still). Standard Common Lisp and Allegro CL symbols have lowercase names. Traditional ANSI (case-insensitive) images are also included in the distribution. See Allegro CL Executables in startup.htm for information on the various images. Note that the startup information printed when Allegro CL is invoked identifes the case mode (assuming *print-startup-message* has its initial value).
2. read-sequence has a new partial-fill argument controlling blocking and may block unexpectedly unless that argument is specified true. The ANSI specification of read-sequence (the link is to the ANSI spec) requires that it wait for input if not enough objects are available on the argument stream to fill the argument sequence (up to the end, if specified) and no EOF is encountered. In release 5.0.1, read-sequence used with buffered bivalent streams used with sockets did not block in many cases (though it did block in some cases). This put Allegro CL out of spec, but it is important for sockets that non-blocking behavior be available.

   Therefore, in release 6.0, an additional keyword argument, partial-fill, is added to the lambda-list for read-sequence. If nil (the default) read-sequence will block. If true read-sequence will block for the first element, but will not block for any elements after the first, and so may return prior to the request being completed. In all cases, read-sequence returns the index in the sequence of the next element not read.

   Because read-sequence did not block for buffered bivalent streams in most (but not all cases), some 5.0.1 users may be relying on the non-standard not-always-blocking behavior and will therefore need to modify their code (by adding :partial-fill t to the read-sequence calls) in order to get the behavior they expect.

   The not-always-blocking behavior was seen when read-sequence was applied to a buffered bivalent stream except when

   • Chunking was being done.
   • The International version of Allegro CL was used.
   • The argument sequence is not an array or type (signed-byte 8), (unsigned-byte 8), or character.

   In those cases, the behavior of read-sequence was standard (blocking). read-sequence always had standard behavior on streams that were not buffered bivalent streams.

   The Allegro CL implementation of read-sequence is described in Implementation of Common Lisp Functions for Simple-Streams in streams.htm

3. Dynamic-extent automatically declared in some cases. Dynamic-extent argument properties are automatically declared on all defun and defmethod forms. This gives the compiler the ability to make assumptions about the dynamic extent use of arguments passed into these functions, and to generate more efficient code. The compiler has always tracked these properties for functions that it knows about, e.g. mapcar, and this new facility extends the interface to user-defined functions and to redefinitions. Warnings are also provided for redeclared definitions and for definitions that occur after the function's first usage. To allow declaration before the first use, a new macro called defun-proto is provided.
4. A number of significant changes for external formats and locales. Allegro CL 6.0 begins the new era of having Allegro CL use arbitrary external-formats and locales. See iacl.htm for complete details. Most user code should not be affected. However, there are some specific new features/functions users should note:

   The locale used by iacl will be looked up by calling setlocale(), which is typical for internationalized applications. A user can override the default locale by specifying "-locale <name>" in the acl command line, or by setting the ACL_LOCALE environment variable.

   The internal format used for characters is unicode. This is a superset of ascii (and latin1), but incompatible with jis/process-code that was used in the previous unix iacl. It is also incompatible with other 8-bit character sets other than latin1. Users of standard acl might be affected by this. Users depending on values of char-code and code-char for international characters may notice this change. Also, euc-specific functionality from previous iacl which defines "types" of characters is being deprecated, but available through an autoload module called "euc.fasl".

   The load function now takes an :external-format argument, as does compile-file. The open function already had an :external-format argument.

   #\newline is now being handled as defined by ANSI CL. In other words, a single character with name #\newline is returned by read-char when the stream position is at the end of a line. This functionality is implemented using external-formats. By default, MSwindows uses the crlf external-format, and unix does not. A new command-line option, "-compat-crlf" is available to provide compatibility with earlier releases of Allegro CL (see #\newline Discussion in iacl.htm). Also, as a result of this new feature, the :mode option to open is now deprecated, as described in :mode Option Removal in iacl.htm.

5. The stream implementation in Allegro CL changed. simple-streams (described in streams.htm) are now used instead of gray streams. The old implementation is preserved (see gray-streams.htm). Those documents describe how the change may affect users. Note: even though this is mentioned in the non-backward-compatible section, the vast majority of users will not have to make any code changes at all. Only those users who have defined new stream classes or defined methods for specific stream classes need worry about this change.

   Beta customers: there have been changes since the release of the beta version of Allegro CL 6.0. Stream code written for the beta version may have to be modified.

6. Sockets use simple-streams rather than Gray streams. In the new socket code in module sock, sockets are simple-streams and so are not assigned formats. The :format keyword is silently ignored, and socket-format always returns :multivalent. The change should be upward compatible.
7. Files compiled in case-insensitive-upper mode will error when loaded into a case-sensitive-lower mode image. A file compiled in case-insensitive-upper (ansi mode) is now blocked (with a continuable error) from being loaded into a case-sensitive-lower (modern mode) lisp. More precisely, a condition of type fasl-casemode-mismatch is signaled, so the new error behavior can be overridden by using the condition system. The blocking is done to avoid multiple symbols (uppercase and lowercase) intended to be identical from being created.
8. link-okay argument to copy-file changed. The default for the :link-ok keyword argument to copy-file is nil instead of :hard, and its use is deprecated (its use causes a warning). See the description page for details.
9. Initial value returned by excl:convert-mixed-case-symbols now true. See the page for convert-mixed-case-symbols. In earlier releases, the initial value was nil.
10. *require-search-list* searches fewer directories. A change to the inital value of *require-search-list* only looks for fasls and in the Allegro directory and its subdirectories. In previous releases, it looked in the current directory, and as a result often loaded user fasls which happened to have the same name as a system fasl (build.fasl, for example). Any users who depended on the wider search should modify *require-search-list*. The old value is given (in a form which is ignored) in the file <Allegro directory>/custom.cl.
11. digit-char-p has third optional argument, specifying case of returned character. digit-char-p has a third, optional case, which defaults to nil. When it is specified true, digit-char-p returns lowercase alphabetical characters rather than uppercase. Thus (digit-char 12 16 t) returns #\c, not #\C.
12. The symbols excl:*clos-package*, excl:*compiler-package*, excl:*keyword-package*, excl:*excl-package*, excl:*lisp-package*, excl:*system-package*, excl:*user-package* no longer exist. In earlier versions their values were the named package objects (thus the value of, say, excl:*compiler-package* was the value returned by (find-package :excl)). They were deprecated for several releases and are gone in 6.0.
13. The fasl version (an internal value associated with fasl files) has been incremented; 6.0 will not load fasl files compiled in earlier lisps.
14. Minor change to sys:pointer-storage-type: pointer-storage-type can now return :pan for an object in newspace that is marked so it will never be tenured. In earlier releases, such objects existed but pointer-storage-type returned :new on them.
15. -Q command-line argument ignored. In releases prior to 6.0, the system would print the names of the pll file and the image file on startup unless -Q was specified as the first command-line argument. In 6.0, this information is not printed so -Q is ignored. See Command line arguments in startup.htm for information on command-line arguments.
16. The value of tpl:*print* must accept two arguments.*print*, if not nil, must be a function that will do the job of cl:print. In earlier releases, this function was passed one argument only (the object to print). In release 6.0, it is passed two arguments, the object to print and the stream to print to. If you have a print function used in earlier releases, we recommend making the second argument optional when you modify it, as then it will run in both the old and new releases. Thus:

    (defun my-print (val &optional (stream *standard-output*))
        ...)
    

17. The value of tpl:*read* must accept one arguments.*read*, if not nil, must be a function that will do the job of cl:read. In earlier releases, this function was passed no arguments. In release 6.0, it is passed one argument, the stream to read from. If you have a read function used in earlier releases, we recommend making the argument optional when you modify it, as then it will run in both the old and new releases. Thus:

    (defun my-read (&optional (stream *standard-input*))
        ...)
    

    Note: *read* was incorrectly documented in release 5.0.1 (and earlier). That documentation said a non-nil value must be a function that would be passed one argument when in fact it had to be a function that would be passed no arguments. In release 6.0, a non-nil value must be a function that will be passed one argument. (So the documentation of *read* in 6.0 is the same as in 5.0.1, but is now correct.)

18. Home directory on Windows is now the value of HOME or c:\\. In earlier releases, the home directory on Windows was always c:\\. In release 6.0, it is the value of the HOME environment variable if that variable is set and c:\\ if that variable is not set. This change affects where [.]clinit.cl is looked for (see Initialization and the sys:siteinit.cl and [.]clinit.cl files in startup.htm), and the functions username-to-home-directory and user-homedir-pathname.
19. cl:file-length now accepts a string or pathname argument. The argument is specified to be a stream open to a file, but starting in 6.0, Allegro CL accepts a pathname or a string naming an (existing) file as well. See cl:file-length in implementation.htm for details.
20. New argument for lisp_init() (Unix only). The lisp_init function, needed if you wish to write your own main(), has a new argument *shared_library_handle, just after the shared_library_name argument. Specify it 0 for uses in your own main(). See main.htm
21. The initial value of *print-startup-message* now includes (:case t) so that the current case mode is printed when Lisp starts up. print-startup-info now accepts :case as a type of information.
22. push and pushnew have changed: in earlier releases, these macros evaluated things in the wrong order. This has been corrected.
23. shiftf and rotatef now set multiple values: this non-compliance with ANSI CL is now fixed.
24. Default for defun-c-callable changed: The default argument type in defun-c-callable has changed from :signed-long to :signed-natural. If a user has pre-6.0 code that explicitly specifies :signed-long, it is likely not to work on 64-bit ports, because :signed-long always specifies 32 bit values. If the user instead takes the default argument type, then the code will work in all 6.0 and pre-6.0 versions. If 32-bits is explicitly desired, however, then the :signed-long (or :unsigned-long) should be explicitly specified.
25. Stepper only works on compiled code: it actually works on interpreted code, but steps through the interpreter itself (with hundreds of steps), so stepping through interpreted functions is rarely useful. This is a change from earlier releases,w here stepping through compiled functions was not useful. See The stepper in debugging.htm. If you find yourself stepping through interpreted code, get out by turning stepping off by entering :step nil followed by :over. See :step and :sover.

3.3 Other changes in the base Lisp

1. New functions for fast reading and writing of floats. These functions write and read the binary representation of floats (rather than the decimal representation), thus saving the time and loss of accuracy associated with conversion to and from decimal format. The functions are single-float-to-shorts, double-float-to-shorts, shorts-to-single-float, and shorts-to-double-float.

2. New closed old areas gc feature.

   Old areas are now numbered, starting with 0 as the oldest old area. The new (sys:gsgc-parameter :open-old-area-fence) (see gsgc-parameter) always returns a non-negative integer which is the number of the oldest old area that is open (not closed). This parameter is setfable, either with the number of the old-area that is desired to be the first open-old-area, or with a negative number, for which the old-areas are counted backward to set the fence. For example, (setf (sys:gsgc-parameter :open-old-area-fence) -1) will close all old areas except for the newest one, no matter how many old areas exist. Restrictions: At least one old area will be open at any time. Attempts to set the fence to a higher or lower number than can be set will result in silent saturation (setting the fence to the nearest possibility), however the return value from such a setf will always indicate the actual open-old-area-fence. Obviously from these restrictions, one must have at least two old-areas in order to close one.

   When an old area is closed, setf is not restricted, but no objects are newly tenured into a closed old-area; it is as if the area is full. Also, no dead object in a closed old area is collected while the area is closed, and data pointed to by that object is also not collected.

   The intended usage model for closing old areas is this: a VAR will load up their application, perform a global-gc and possibly a resize-areas, and then close most of the old-areas, leaving room for their users' data models to be loaded into the open-areas. When the user is done with the data model, it can be thrown away and a fast global-gc performed, making way for the next data model.

3. Relative package utility functions exported. package-parent and package-children are exported. See packages.htm for information on relative package names.
4. The macroexpansions of def-foreign-call forms carries much more user-visible information than in earlier releases. See the description page for def-foreign-call.
5. Two sequence modules available: one fast with little error checking, one slower and safer.

   There were a number of complaints about Allegro CL 5.0.1 (and some earlier releases) that incorrect calls to various sequence functions caused serious errors. The forms were incorrect usually because arguments were of the wrong type or indexes pointed outside the sequence). Note that correct code did not have problems (or, if there were problems, a patch was provided).

   The problem was, of course, balancing safety and speed. Exhaustive argument checking significantly slows down execution.

   In 6.0, there are two modules for sequence functions, :safeseq and :fastseq. Either can be require'd at any time, and they each define or redefine the same operators, and thus loading one cancels the effect of the other. :safeseq does argument checking but causes Lisp to run more slowly. :fastseq is faster but less safe. The images delivered with Allegro CL are build with :fastseq.

   It should be noted that functions in the safeseq module are not better per se than those in fastseq, and for correct code each module's functions operate correctly. Rather, the functions in safeseq behave better for poor coding behavior, as is required by the spec for "safe" code.

   The current list of functions which are affected by these modules include (but are not limited to, possibly by indirection): elt, length, make-list, and all of the map functions, e.g. mapc, mapcar, etc., and butlast.

   See Type errors in sequence functions in errors.htm.

6. defpackage accepts :documentation option. A long-standing ANSI incompatibility is fixed in 6.0: defpackage accepts the :documentation option.
7. while and until exported. The macros while and until are exported from the excl package.
8. generate-application will create a runtime bundle file There is a new argument to generate-application: runtime-bundle: if specified t a bundle file named files.bu will be placed in the application directory. This file contains the modules allowable in a runtime image. This means that such modules need not be loaded into the application image during the application build. See "Including all desired modules in delivery.htm
9. without-redefinition-warnings now in excl package. The symbol naming the macro without-redefinition-warnings has been moved from the common-graphics package to the excl package.
10. Advice deprecated, use def-fwrapper instead. A new facility called def-fwrapper is available, to replace the advice facility. See fwrappers-and-advice.htm.
11. If you still use advice, note that the advice forms cannot be the single form nil. If you want the single form nil (in, for example, :around advice to not call the function and return nil), specify (progn nil) instead. See fwrappers-and-advice.htm and advise, advise-1, and defadvice.
12. Trace corrections. In 6.0, generic functions remain generic when traced; functions that have traced internal functions (flets/labels) now always remember they had been traced when redefined; tracing a function only when called inside another function now correctly handles treads; and tracing works within break loops (e.g. after a :break-after point was hit).
13. International ACL support vector argument to run-shell-command. In earlier releases, the International editions of Allegro CL did not support the vector version of run-shell-command, and limited the non-vector version to 8192 (wide) characters. This restriction does not apply to Allegro CL 6.0 (and note the standard version now supports international character sets). The vector version of run-shell-command works in all versions and there is no limit on the number of characters accepted.
14. custom.cl contains various examples of forms which will restore behavior changed in Allegro CL 6.0 compared to earlier releases. For example, it includes code to restore the 5.0.1 value of *require-search-list*. Note that all code is commented out or suppressed with a #+ignore reader macro. If you want any of the code evaluated when you build an image, you must edit the file.
15. Hash table enhancements. excl::make-hash-table-load-form has been enhanced so that it will faithfully reproduce a hash table as a constant. In addition, three new functions are defined: hash-table-hash-function, hash-table-values, and hash-table-weak-keys, which each take a single hash-table argument and return the appropriate value. None of these is setf-able.
16. Inspection of hash tables improved. Already in 5.0.1, inspection of hash-tables is easier in non-raw mode, listing key/value pairs together indexed one after another (or just keys listed in sans-values hash-tables). However, in 5.0.1 an :i command could not be used to inspect or set elements of the listing; raw mode had to be used for that purpose. Now, the ":i number" command can be used to inspect any key or value listed, or an ":i set number new-value" can be used to set new values (but not new keys). See inspector.htm.
17. Applyn optimization bug fixed. This bug caused a segv when displaying backtraces when code used the applyn optimization. See Stack consing, avoiding consing using apply, and stack allocation in compiling.htm for information on the applyn optimization.
18. Title can be supplied to sys:set-splash-bitmap. The function set-splash-bitmap (available on Windows only) can be used to specify a bitmap to be displayed when an Allegro CL application is starting up. The new :title keyword argument allows specification of the title of the window displaying the bitmap (the title does not appear in the window but in tools such as the icon bar).
19. Stack-allocation of make-list. If a call to make-list has a constant size, declarations are trusted, and the resultant variable is declared as dynamic-extent, then it will be stack-allocated and initialized. The initial-value keyword can be used to specify the value. An attempt to make-list of a variable size will result in heap consing. See Stack consing, avoiding consing using apply, and stack allocation in compiling.htm.
20. New function double-float-p. double-float-p is now exported, like single-float-p.
21. Enhancements to describe. The describe function now will include all trace and/or fwrap functionality around the function-object, if any.
22. New support for using #! in shell scripts. See Starting on UNIX using a shell script in startup.htm.
23. Some old aclwin symbols now exported from the excl package. list-to-delimited-string, delimited-string-to-list, and xor.
24. scm package renamed to excl.scm. The new name fits with the new package naming scheme (see packages.htm). The name scm is a nickname for backward compatibility.
25. UNIX Lisp-based shared libraries. See shared-unix.htm in examples/unix-shared-libraries/ for an example showing how to create a Lisp-based shared library that can be used by other developers writing C, C++ or Java applications.
26. Windows Lisp-based DLL's. See dll.htm in examples/dll/ for an example showing how to create a Lisp-based DLL that can be used by other developers writing C, C++ or Java applications.
27. Lisp-based Internet browser plugin example: see plugin.htm and the examples/cgplugin/ directory for more information.
28. New function file-contents. See file-contents.
29. New argument to sys:update-allegro. update-allegro accepts a new keyword argument: :keep-old-patches. If true (the default) replaced patch files are renamed rather than overwritten, making it easier to back out of a patch. This is particlarly useful when replacing system fasl files.
30. New arguments to map-over-directory. map-over-directory now accepat these keyword arguments: :recurse and :file-type.
31. New arguments to :zoom. :zoom takes two new arguments: :level and :length, which bind tpl:*zoom-print-level* and tpl:*zoom-print-length*.
32. Optional version argument to provide and require. See implementation.htm.
33. Arrays now suitable for equal hashing. Array headers (non-simple and multi-dimensional arrays) now have a hash code, generated at creation time, which gives the array identity for equal hashing.
34. MD5 support. Allegro CL 6.0 provides support for MD5 (Message Digest, version 5) within Lisp. (Message digest represents text in the form of a single string of digits.) See MD5 support in miscellaneous.htm.
35. There is a new +RR command-line argument, which controls whether to put the ACL icon on the system tray (and can override resource values). See Command line arguments in startup.htm.
36. The default value for *tenured-bytes-limit* has been changed; on 32-bit versions the default is 8 Mb (8 * 1024 * 1024) and on 64-bit versions the default is 16 Mb (16 * 1024 * 1024).
37. A bug in push and pushnew, where the order of evaluation of subforms was incorrect, has been fixed.
38. New function for regular expression processing: split-regexp and replace-regexp.
39. File position problem on Windows is fixed. The problem with Allegro CL on Windows where file-position returned incorrect results has been fixed.
40. without-redefinition-warnings, formerly exported from the common-graphics package, is now exported from the excl package.
41. with-command-line-arguments has a new keyword argument usage which, if specified, should be a string. This string is printed when errors are found in the given command line arguments.
42. In earlier releases, the vector holding the keys in a weak-keys hashtable always remained in newspace. In release 6.0, you can arrange that this vector be tenured (which saves space in newspace, but delays the removal of no-longer-used weak values). See cl:make-hash-table in implementation.htm.
43. These symbols have been exported from the excl package. Those with links name defined objects. file-read-only-p, file-hidden-p, file-system-p, file-archive-p, file-normal-p, file-temporary-p, file-attributes, ef-composer-ef, ef-composee-ef, composed-external-format-p, no-external-format-error and oc-eof-macro. The last is used to name macros defined during the execution of octets-to-char.
44. The (* :char) specification is tightened up a little. Previously, a foreign definition like

    (ff:def-foreign-call foo ((x (* :char))) ... )
    

    would assign a lisp type of :foreign-address, because of the extreme overloading of the char* type in C (char* is typedeffed to many types, and is routinely cast to pointers of different type such as int* or struct x *). But this causes the runtime type-checking to be circumvented, since anything at all satisfies a :foreign-address type, and :foreign-address is not even a lisp type at all. A problem with this old specification is in the passing of non-simple strings (e.g. strings with fill-pointers) in a call-direct situation: it is the array-header that is passed to the foreign call, rather than the string data address, as is usually expected.

    Now, the (* :char) specification causes the default lisp type to be string. This causes the compilation of a direct-call specification to fail to compile directly, because the specification is not a simple-string. You can cause the direct-call to occur again by changing the specification to

    (ff:def-foreign-call foo ((x (* :char) simple-string)) ... )
    

45. (* :char) as a value for the returning keyword argument to def-foreign-call is now accepted and converts the return value automatically to a Lisp string using native-to-string.
46. The warnings that occur for automatic string conversion in a def-foreign-call can now be suppressed in any of the following ways:
    • Specify :strings-convert in the def-foreign-call. The value can be either true or false.
    • Specify a translate-type function in the specification.
    • Specify a lisp-type that is not a subytype of string.

    The intention of the strings-convert warning is to alert the user to potential performance and correctness problems in the face of new international character set issues, without generating spurious warnings when unnecessary.

47. Use of Allegro Presto is deprecated. The facility may be removed in a later release. (It is present in release 6.0, however.) Allegro Presto allows partial loading of function definitions from fasl files. The remainder of the definition is loaded only when the function is actually called. This facility made for somewhat smaller images, but at a great increase of complexity. Much the same saving can be achieved with pll files and other techniques. For that reason, it is intended to remove the Allegro Presto facility in a future release. Allegro Presto is described in The Allegro Presto algorithm in loading.htm.

3.4 Base Lisp platform-specific information

HP

Swap allocation on HP is incredibly complex. If you are having trouble using all of the swap that you think you've allocated, contact Franz Inc. for advice (Franz Inc. will likely refer you to HP Support after suggesting what to ask.)

4.0 Release Notes for CLIM

The documentation for CLIM is in an online PDF file, clim-ug.pdf. It has been updated since release 2.0 and is called The CLIM 2.2 User Guide. That document which includes material formerly in the (printed) CLIM Release Notes.

1. CLIM is not available on 64-bit HP's running HP-UX 11.00. There is no available Motif 1.2 on that platform.
2. CLIM on Linux and FreeBSD requires separately purchased Motif: you must have Metro Link Motif 1.2.4 (Linux) or Metro Link Motif Complete! (FreeBSD). See the Metro Link web site www.metrolink.com for details.
3. On versions of Allegro CL using the OS threads model for multiprocessing (in 6.0, only Windows), a window must be created in the same process in which it will run. In non-os-threads implementations, you could create the window in any process and run it in another. Some examples may fail on Windows because this restriction is not observed.
4. On HP's, creation of various Motif widgets can cause errors because fontsets cannot be created. On HP systems, creation of various motif widgets -- such as dialog boxes resulting from calls to accepting-values -- can cause errors because fontsets can not be created, with an immediately preceding warning that the charset HP-ROMAN8 is missing when trying to create the fontset. This should happen only when running CLIM in an international Lisp (ones with 16-bit rather than 8-bit characters -- note that this is now the default), on an HP machine with the X display on a non-HP machine.

   The reason for this is that HP's default locales seem to specify that the HP-ROMAN8 codeset must be available in X. For non-HP X servers it typically is not available, and thus this error occurs.

   There are two solutions (apart from displaying on an HP X server):

   • Run Lisp in a locale which does not require the HP-ROMAN8 codeset. HP provide such several locales which have names like <x>.iso88591. So, for instance, rather than using the C locale, you should be able to use the C.iso88591 locale. You can specify a locale at startup with the -locale environment variable:

     -locale C.iso88591
     

     (See Command line arguments in startup.htm.) Or by specifying the ACL_LOCALE environment variable (see Locales in iacl.htm).

     You can also change the locale once started with by getting a locale object with find-locale and setting the value of *locale* to that object. (The locale shell command tells you what locale you are in. The locale -a shell command lists all available locales.

   • Make the hp-roman8-encoded fonts available to the X server. This could be done by running a font server on the HP machine, or by physically copying the fonts from the HP machine to the machine with the X server. The details of how to do this are not covered here.
5. You cannot run CLIM functions with -e command-line argument. In Allegro CL 6.0, initializations necessary to use any CLIM functionality are performed after the -e command-line arguments are processed. Therefore, no CLIM functionality (such as find-port) should be part of a -e form. Instead, CLIM functionality should be run as part of *restart-init-function*. A -e form can be used to modify that variable, if desired.
6. There is no root window. It is neither necessary nor possible to create a root-window in CLIM 2.2 (unlike CLIM 1.0 and 1.1). Furthermore, clim:make-application-frame does not require a :parent argument.
7. CLIM now works in a case-sensitive Lisp. CLIM now will work in two flavors of Lisp: ANSI Lisp -- standard CL symbols are uppercase, the reader converts non-escaped symbols to uppercase (executable alisp); modern Lisp -- standard CL symbols are lowercase, and the reader does no case conversion (executable mlisp). In the former case, all exported CLIM symbols are uppercase as before; in the latter they are lowercase.
8. On Windows platforms, notify-user now always raises the dialog box it creates to the top of the window stack. Formerly it could be buried behind other windows if the CLIM application frame was itself buried.
9. Lisp will not prompt you to be sure you want to exit Lisp if CLIM timers have been used. Previously if you exited Lisp it would ask you to confirm that you wanted to do so if you'd ever used a timer.
10. For Unix/Linux the CLIM debug fasls (clim-debug.fasl, clim-debugwnn.fasl and clim-debuxm.fasl) are empty. The debugging code is now included in the normal fasls and the empty files included for backwards compatibility. In a future release they will disappear.
11. CLIM has been changed so that, the standard frame top-level loop defaultly rebinds *error-output* to itself, and not to one of the frame panes. This is an incompatible change, which was made to stop problems when Lisp messages (unrelated to the CLIM application) were getting printed to CLIM panes. This is at best annoying, and at worst can cause errors in incremental redisplay.

    Rather than hard-wire this change, it is controlled by an argument to make-application-frame or make-instance of standard-application-frame:

    (make-application-frame ... :non-frame-stream-names <name list>)
    

    Will cause the default top-level loop to rebind the values of the standard streams named in <name list> to themselves, not to CLIM panes, even when there are suitable panes available. The default case is as if you said:

    (make-application-frame ... :non-frame-stream-names '(*error-output*))
    

    And you can inhibit the new behaviour by saying:

    (make-application-frame ... :non-frame-stream-names '())
    

    or providing this as a default-initarg in a frame class definition.

    Note that this behaviour is controlled in terms of stream names not streams, and in fact it is more general than just *error-output*. The names that make sense in the list are *standard-output*, *standard-input*, *error-output*, *query-io*, and *pointer-documentation-output*.

    The behavior of the generic functions frame-standard-output, frame-standard-input, frame-query-io, frame-error-output, and frame-pointer-documentation-output are altered by this change. If the corresponding stream will be rebound to its old value in the frame, the methods defined on standard-application-frame for these generic functions will return nil rather than a stream.

12. On Unix, more of the scrollbar functionality defined in the CLIM spec is now supported, and the values of scrollbars have much finer quantisation, which allows scrolling panes with very many lines accurately.
    • :scroll-to-bottom-callback (a scroll-bar initarg) specifies a callback that is called on scroll to bottom. The callback should be a function of one argument, the scrollbar.
    • The generic function scroll-bar-scroll-to-bottom-callback, which takes a scroll-bar as its only argument, returns the callback called when scrolling to bottom, or nil if none is defined. This corresponds to the value of the :scroll-to-bottom-callback initarg.
    • The generic function scroll-to-bottom-callback, which takes as arguments scroll-bar, client, gadget-id, and value, returns the callback function called when the scrollbar scrolls to bottom.

    Similar sets of initargs and functions exist for

    • ...to-top... -- scroll to top
    • ...down-line... -- scroll down single line
    • ...up-line... -- scroll up single line
    • ...down-page... -- scroll down page
    • ...up-page... -- scroll up page.

    Note the behavior of these functions is that, for instance, the default method on scroll-to-bottom-callback will call the value of (scroll-bar-scroll-to-bottom-callback <scrollbar>) on the scrollbar if it is non-nil.

    On Windows the names exist but the functions are not called.

13. Motif CLIM will by default display on the value of the user's DISPLAY environment variable. To verify that it is set appropriately as,

    <machine-name>:<display-number>.<screen-number>

    enter the command

    % printenv DISPLAY
    

    to a Unix shell prompt. machine-name should identify the machine at a screen of which CLIM should display. The display-number is usually 0 and the screen-number is often omitted altogether.

    If the user has no DISPLAY environment variable or the user's DISPLAY environment variable is inappropriate for this purpose and there is reason not to modify it, enter the following in Lisp before attempting to display anything from CLIM:

    (setf clim:*default-server-path*<
          '(:motif :display "<machine-name>:<display-number>")
    

    The initial value of clim:*default-server-path* is currently (:motif).

14. Deleting output-records that are part of a coordinate-sorted-set can fail. If you specify that a scrolling, text-oriented CLIM window should store its output records sorted by their Y coordinates, searching will be faster searching (e.g. during presentation highlighting), since the search can be bounded. However, there is one exception to the "always sort by Y coordinates" rule, namely that overlapping output records are stored in the order in which they were drawn. This is necessary in order to get replay to stack overlapping things correctly. Unfortunately, this exception has been known to confuse parts of the code that always expect the records to be sorted by Y-coordinate. Sorting by Y coordinates is no longer the default (it was the default in earlier releases) so you will not see this problem unless you explicitly call for sorting be Y coordinates.
15. Sometimes the #\tab key cannot be used to complete the default value in a command. In these cases you can use #\space instead.
16. When running a Motif application (including CLIM) you may see the following warning from time to time:

    Warning: Xt:
        Name:
        Class: XmRowColumn
        Illegal mnemonic character;  Could not convert X KEYSYM to a keycode
    

    This occurs when you are using a keyboard that does not have an F10 key. If you modify the file misc/dot-motifbind so it does not refer to F10 (make it refer to a key you do have), this warning should go away.

17. In X, ellipses are always drawn with axes parallel to the X and Y axes. Although CLIM has facilities for drawing ellipses that are not aligned with the axes, X draws them aligned anyway, regardless of how the ellipse is specified.
18. European keyboards (azerty) are not fully supported. Problems occur mostly with keystrokes used as command accelerators.
19. The examples/clim2/ directory in the distribution contains a set of demo programs, both Lisp source and compiled files. To load the demos, do the following:

    (require :climdemo)  
    

    Then, the simplest way to start the demo is to evaluate:

    (clim-demo:start-demo)
    

20. Redefining a command (which forces the menu to be reconstructed) destroys accelerators for all commands in that menu.
21. There can be a bad interaction between incremental-redisplay and :end-of-line-action :wrap.
22. :own-window t accepting-values flicker when first brought up.
23. The :function type to add-menu-item-to-command-table is not recognized.
24. copy-area and friends ignore the medium clipping region.

5.0 Release Notes for Common Graphics (Windows only)

The first subsection describes changes to Common Graphics and the IDE that are non backward-compatible. Please review this section and make whatever necessary changes to your code to obtain the desired behavior in release 6.0.

The second subsection describes other changes to Common Graphics and the IDE. These should not require code changes (please tell us if any do, because that may indicate a bug), but note that certain function and argument names have been deprecated in favor of new names, and that new code should reflect these changes, and old code should be revised at some point.

There are three appendices about Common Graphics and the IDE. The first deals with a change where functions passed a frame-with-single-child window as an argument no longer automatically operate on the child window. The second lists classes and functions affected by the change to drawing functionality, where it is no longer possible to create objects corresponding to shapes (like circles and ellipses) and then draw those shapes with draw. The third lists minor bug fixes and enhancements, many fixed or made available by 5.0.1 patches.

5.1 Non-backward-compatible changes in Common Graphics

1. make-graphics-context. make-graphics-context takes a required stream argument. In release 5.0.1, this function took no arguments.
2. Common Graphics now uses simple-streams. Simple-streams are the new stream implementation in Allegro CL 6.0. See streams.htm. This change has a number of effects. See Common Graphics and Simple Streams in cgide.htm for more information.
3. without-redefinition-warnings now in excl package. The symbol naming the macro without-redefinition-warnings has been moved from the common-graphics package to the excl package.
4. Changes to open-stream. The second and third arguments to open-stream, location and direction, which were required in 5.0.1 and earlier, are now optional and ignored. See Common Graphics and Simple Streams in cgide.htm for more information.
5. aclwin302:device-to-stream-units and aclwin302:stream-to-device-units. Anyone using the (undocumented) functions aclwin302:device-to-stream-units and aclwin302:stream-to-device-units must change calls to these functions to device-to-scaling-units and scaling-to-device-units respectively, since the former aclwin302 function names are now being used to name symbols in the common-graphics package with different functionality.

6. frame-with-single-child arguments no longer redirected to pane. Functions called on a frame-with-single-child are no longer redirected to the frame-child. This is a backward-incompatible change. In earlier releases, if you called copy-pixmap (for example) on a frame-with-single-child window such as a non-refreshing-window, then the pixmap would actually be drawn on the frame-child pane of the frame-with-single-child instead of on the frame window itself. This redirection was done whenever CG regarded the particular operation as not being useful on the frame. In the copy-pixmap case, the pixmap would never be seen on the frame because the frame's interior is completely covered by the frame-child pane that is automatically created when a frame-with-single-child class is instantiated. (Drawing CAN be done on any window, though, including a frame-window.) Approximately 160 methods that specialized on frame-with-single-child performed this redirection, each checking for the existence of a frame-child pane and simply calling the same generic function on the frame-child if it existed.

   This automatic redirection to the frame-child has now been removed from Common Graphics. This feature is no longer considered worthwhile because (1) if it is desirable to really call one of these generic functions on a frame-with-single-child frame window itself, there is no way to do so, (2) it was not obvious that this behavior was an explicit feature, or which generic functions it affected, and so could lead to confusion over whether a frame-with-single-child frame window and child pane are really one window or two, and it required a significant amount of code (the 160 methods) which is not necessary since it is easy for an application to call frame-child on a frame-with-single-child window to find the auto-instantiated child pane (even if there are additional child windows such as a toolbar and status-bar). The policy now is that the programmer should understand that two windows are involved, and to call functions on the appropriate one explicitly.

   If an application relies on this feature by calling functions on a frame-with-single-child frame window when the frame-child pane is the actual target, then calls to frame-child will need to be inserted in the application source code to redirect the action as needed.

   See below for a complete description and list of affected functions.

7. (setf state) is called whenever the state of a window is changed (expanded, iconified, etc.) Also changes to state and (setf state). (setf state) is now always called when the state of a window is changed, either programmatically by calling other exported functions such as shrink-window, or interactively when the user clicks the shrink, maximize, or restore buttons on a window frame. shrink-window, expand-window, and zoom-window are now regular (non-generic) functions that call (setf state); if an application has added methods on any of these three former generic functions then these need to be changed to (setf state) methods instead.

   This change was made in order to provide a single generic function that can be guaranteed to be called whenever a window state changes, so that applications will need to modify only one generic function to hook into state changes. In earlier releases, (setf state) called the other three functions instead, and was not called for interactive state changes except when a window was iconized.

   When expand-window is called on a window whose state is :shrunk or :icon, the window is returned to either :normal or :maximized state, depending on which of these two states the window most recently had. If it has not yet had either of these states, then it is put into :normal state. For iconized windows, this emulates clicking on the restore button of the icon. Alternately, the new-state argument to (setf state) can be passed as :expanded to achieve the same result; expand-window itself calls (setf state) in this way. (:expanded is not a true state, so the resulting state of the window will be either :normal or :maximized.)

   A (setf state) :around method prevents any other non-:around (setf state) methods from being called if the state would not actually be changed by the call. Therefore any methods added by an application do not need to handle this efficiency consideration. This around method also coerces the special :expanded state to either :normal or :maximized and passes that value to the other (setf state) methods that it calls, so any primary, :before, or :after (setf state) methods added by an application will not receive the :expanded state.

   The generic functions state and (setf state) may be called on dialog-items or windows, while the other three functions apply only to windows.

   The generic function state returns a new second value for the "expanded state" of the window. This value is always either :normal or :maximized. If the current state of the window is :shrunk or :icon, then the value is the state into which the window will be placed if expand-window is called on it or if (setf state) is called on it with the :expanded state. This is also the most recent expanded state that the window was in, or :normal if it has never been expanded. If the current state of the window is :normal or :maximized, the value is the state to which the window was most recently expanded from :shrunk or :icon state.

   Here is an example of an added (setf state) :around method that looks at both the old and new states of any frame-window whose state may be changing, and reports any change. Typcially several custom methods on shrink-window, expand-window, and so on in 5.0.1 could be collapsed into such a single (setf state) method. A simpler :after method could be used instead if the old state is not of interest.

   The without-package-locks is needed here in a source code file that's not in the CG package only because it specializes a CG method on a built-in CG class; normally an application would specialize on its own subclass instead.

   The requested-state argument is ignored because it may be :expanded, and we are interested here in the resulting :normal or :maximized state instead. Similarly, some other (setf state) method could coerce the requested state to something else.

   Eval-in-listener-thread is used to make sure that the printed output always goes to the selected IDE listener pane (and so this method is suitable only for the IDE and not for a generated application). Otherwise, the message will go to the *terminal-io* of whatever thread changed the window state; for example, clicking the minimize button of an IDE window would iconize the window in the IDE GUI thread, for which *terminal-io* is bound to the console, and so the output would appear there.

   The prog1 is used to ensure that this (setf state) method returns whatever the next called method returns, though that would normally be the requested-state.

   (without-package-locks
    (defmethod (setf state) :around (requested-state (window frame-window))
      (declare (ignore requested-state))
      (let* ((old-state (state window))
             new-state)
        (prog1 (call-next-method)
          (setq new-state (state window))
          (unless (eq old-state new-state)
            (eval-in-listener-thread
             `(format t "~&State of ~s changed from ~s to ~s.~%"
                (name ,window) ,old-state ,new-state)))))))
   

8. windowp changed. Windows do not change class when closed. windowp now returns true only for a window that is open, rather than for any instance of the class window. Windows no longer change class when they are closed, so this change is needed to maintain the usefulness of this function to check whether an object is currently valid for operating on as a window. Note that Common Graphics might not know when a window has gone away (been closed) because the thread that created the window has gone away, and so windowp also checks that the process that created the window is still in the *all-processes* list, and returns true only if it is.

9. Function dirty-p removed. The function dirty-p has been removed from CG. It was used primarily internally to avoid ejecting blank pages from printers, but should not be necessary for this.

   If an application called this function directly, it should now instead maintain its own flag for whether it has drawn anything on the current page.

   More typically, an application may have relied on Common Graphics itself to avoid ejecting blank printer pages. If unwanted blank pages begin to appear in this release, the application should avoid producing these pages itself. In cases where no printed output at all should be produced, such as when opening a printer stream simply to query its attributes or when the user cancels a print operation, the application should pass the ABORT flag when closing the printer, which will avoid ejecting any pages. In cases where an extra blank page appears after the printed pages, the application should avoid calling new-page until it is about to print something that belongs on the next page.

10. Changes to use-cg-timer. The default value of the use-cg-timer configuration property is now nil instead of :under-mouse, so the built-in timer will not run at all by default. This is partly an efficiency consideration for the new multi-threaded CG/IDE, since a timer coming in frequently in one thread keeps switching to that thread when another might be running. It is also partly due to the timer not being needed much anymore in the IDE; the only remaining disadvantage is that when the mouse leaves all windows of the IDE (or standalone app), the mouse-out event for the last window that the mouse was in is not generated until the mouse re-enters one of the windows of the IDE or application.

11. range and visible-portion of scroll-bar controls modified. The range and visible-portion of a standalone scroll-bar controls (horizontal-scroll-bar and vertical-scroll-bar) have changed their meaning. The range now excludes the visible-portion. This is a backward incompatibility.

    In 5.0.1 (and earlier), the range of standalone scroll-bar controls included the visible-portion of the scroll-bar, which made it similar to the whole "page" of a scrollable window rather than the scrolling range (which is the page minus the visible portion of the page). This was an inconsistent usage of the CG scroll-range concept. It also meant, for example, if the range of a standalone scroll-bar control was 0 to 100 and the visible-portion was 20, then the possible values of the scrollbar actually ranged from 0 to 80 rather than the alleged range of 0 to 100.

    In 5.0.1 and earlier, one way to disable a scroll-bar dialog-item had been to set its visible-portion greater than or equal to the range. In 6.0, this no longer makes sense since the scrollable range is independent of the thumb length. The corresponding new way to disable a scroll-bar control is to set the range with the min value equal to the max value, such as (0 0). (As with other widgets, a scroll-bar may also be disabled by setting its available property to nil.

12. pop-up property defaults to nil. The pop-up property now defaults to nil universally rather than defaulting to true for dialog-mixin instances. The exception was deemed more confusing than useful. Note: if your 5.0.1 application creates dialogs without passing the :pop-up initarg to make-window, and then calls pop-up-modal-dialog on these dialogs, then the code should be modified so that it either passes ":pop-up t" to make-window or passes ":child-p nil". See pop-up).
13. Change to return value when calling parent on a pop-up window. Calling parent on a window now returns the actual parent in every case, rather than returning the owner when the pop-up property of the window is true. owner should be called to find the owner.
14. Drawing directly on the screen. Code that draws directly on the screen must now be wrapped in a with-device-context form.
15. cursor position argument value not saved. The cursor-position argument passed to a mouse-moved method becomes garbage when the method exits (to avoid needlessly consing position objects), so copies should be made if they are needed after the method completes.
16. Text control newline differences. When calling get-text or text-range to retrieve all or part of the text of a text control, and the text includes newlines, each newline will now be a single #\newline character rather than a carriage return / linefeed pair of characters. The positions in text controls still reflect byte positions within the buffer, though, where newlines (and multi-byte characters) each use more than one byte. Therefore, the byte length indicated by the returned start and end values of get-selection will be greater than the length of the string returned by text-range using those start and end positions if the text contains any newlines or multi-byte characters.
17. Changes to owner, parent-or-owner, overlapped, top-level, pop-up, stream-location. The function parent-or-owner is deprecated. The function owner returns what parent-or-owner did in 5.0.1. stream-location, which also returns what owner does now, is also deprecated. overlapped and top-level are deprecated in favor of child-p (which returns the reverse of what those functions returned). pop-up now explicitly means intended for use as a modal window.
18. set-page-size should be used instead of set-scroll-range. Applications should not normally call set-scroll-range, and should instead call set-page-size or use the :page-width and :page-height make-window initargs.
19. Change to selected-window return value. selected-window now returns the most recently focused child window if it is still available, otherwise defaulting to the frontmost child window as before.
20. stop-at-modal keyword argument to top-level-window removed.  It was determined that the stop-at-modal keyword argument to top-level-window was not useful. That argument has been removed.
21. Drawing using graphical objects is no longer supported. (For example, creating a circle object and then calling draw on it.) This functionality has been removed rather than merely deprecated. See draw. See Appendix B Common Graphics Classes removed because of changed drawing functionality.
22. defdefiner, open-project, add-to-component-toolbar, and remove-from-component-toolbar are now exported from the common-graphics package as well as the devel package.
23. handle and size are now exported from the common-graphics package as well as the windows package.
24. file-read-only-p, file-hidden-p, file-system-p, file-archive-p, file-normal-p, file-temporary-p, and file-attributes are now exported from the excl package as well as the aclwin package.
25. The following symbols have been removed or unexported from the common-graphics package. The unexported items were considered not useful for user code, but the functionality remains in the release.
    • code-file: now devel::code-file, with the same functionality.
    • event-handling-processes: removed. In 5.0.1, described as a placeholder for later development, but a different development path was chosen.
    • main-event-handler: removed. In 5.0.1, described as a placeholder for later development, but a different development path was chosen.
    • hiword: unexported but has same functionality. It is a functional version of the following form (the argument was an integer n): (logand #xffff (ash n -16))
    • read-only-p: unexported but has same functionality.
    • marker-char: removed. This function returned the character used in the Debug window prompt, but in 6.0, that is the same as all Allegro CL prompts.
    • reinitialize-system: unexported but has same functionality.
    • simple-stream-p: removed. In 5.0.1, simple-stream had a different meaning.
    • texture-array-ref: unexported but has same functionality and see contents-ref.
    • texture-array-set: unexported but has same functionality and see contents-set.
    • user-close-primary-window: removed. See user-close.
    • widget-tab-control: unexported but has same functionality.
    • mouse-in: no longer has a value (i.e. not a constant) but symbol still exists naming a generic function.
    • mouse-out: no longer has a value (i.e. not a constant) but symbol still exists naming a generic function.
    • do-streams: removed.
26. Printed representations of boxes and position no longer readable. In releases prior to 6.0, the printed representation of a position was (for example) #.(MAKE-POSITION 1 1). In 6.0, it is #<position 1 1>. The former is machine readable and the latter is not. The problem is that the old representation created a position constant which could (despite technically being a constant) be modified (with setf of position-x, for example). Such constants are very dangerous in multi-threaded code because they can be changed simultaneously by two threads. To avoid such problems, printed representations are no longer machine readable. The same applies to the printed representation of a box, formerly #.(MAKE-BOX 1 2 4) and now #<box 1 2 3 4>.
27. The 5.0.1 Editor right button menu option Process Mode Line has been renamed Find Package Specifier. When chosen, it finds the (in-package ...) form and sets the package of the editor appropriately. See the description of the Editor Workbook dialog.

5.2 Other changes in Common Graphics

1. Some arguments to make-window have new names (old names still work).

   The :parent argument should be replaced with :owner. The preferred initarg to make-window to specify the parent and/or owner of the window is now :owner rather than :parent, though :parent will still work for backward compatibility. The reasoning is that formerly when creating a top-level window, one would pass a window as the value of the :parent initarg even though that window became the owner of the window and not the parent. But since a parent window is now always also the owner window, the window that is passed as the :owner (or :parent) initarg is now always really the owner, and in addition is also the parent if the child-p property of the new window is true.

   The :device argument should be replaced with :class. The preferred initarg to make-window for specifying the name of the class to instantiate is now :class rather than :device, though :device continues to work for backward compatibility. This change is to make the initarg name easier to remember. The corresponding property of form windows is now called class, though its accessor function is still device, due to the presence of the existing Common Lisp symbols class and class-name.

   The :widgets argument should be replaced with :dialog-items. The preferred initarg to make-window for the list of dialog-items (also known as controls or widgets) to place on the new window is now :dialog-items rather than :widgets. This change is to make the initarg match the name of the associated accessor function and property (dialog-items). :widgets will still work for backward compatibility.

2. New project property full-recompile-for-runtime-conditionalizations. If the full-recompile-for-runtime-conditionalizations property is on, then when the File | Build Project Exe menu command or the File | Build Project Distribution menu command is used, the project will be fully recompiled just before creating the executable, with :runtime-system added to *features* during the compilation. See the full-recompile-for-runtime-conditionalizations page for more details.
3. New function build-project: the generic function build-project provides a programmatic interface for building project exe's or distributions (i.e. a programmatic interface to the menu commands File | Build Project Exe and File | Build Project Distribution.
4. lisp-text and multi-line-lisp-text controls supported again. The lisp-text and multi-line-lisp-text classes/controls, removed from Common Graphics, in release 5.0, have now been restored.
5. Widget-window classes are exported. These classes sometimes need to be subclassed for low-level customization. See widget-window and lisp-widget-window.
6. More information on graphics-contexts. The documentation has been filled out for graphics-contexts, with small enhancements to the functionality. See copy-graphics-context and the the new macro restoring-graphics-context.
7. Some coordinate-translating functions have been deprecated in favor of more consistent names. Specifically: window-to-stream-units is now device-to-stream-units; stream-to-window-units is now stream-to-device-units; screen-to-dialog-units is now device-to-dialog-units; and dialog-to-screen-units is now dialog-to-device-units. The old names still work.
8. New behind argument to make-window and add-component. Both make-window and add-component accept a behind keyword argument which allows controlling the initial position of a widget or window in the occlusion order.
9. New functionality for positioning the CG utility dialogs. The center-all-modal-dialogs-on-screen configuration option may now be :on-owner to center the dialogs on the owner window; this is now the default. A position-utility-dialog method may be written to position the utility dialogs in some custom way. ask-user-for-choice-from-list and yes-no-or-cancel-list have new width and height keyword arguments, and their dialog-exterior-box argument is deprecated.
10. Function to invoke a browser. The function invoke-html-browser is now exported for showing a web page or file in the currently running or default web browser. Web-page-contents returns a string containing the HTML contents of a web page.
11. New argument to scroll. The function scroll has a new delay-redraw keyword argument, to match the same argument of scroll-to (which scroll calls).
12. Drawing Bezier curves. The new function draw-curve draws Bezier curves.
13. Multi-threading and Common Graphics. Multi-threaded CG applications are now more feasible, and the IDE has been enhanced for debugging multiple threads. See About using multiple windowing threads in a CG application in cgide.htm.
14. List-view controls can display icons. The list-view control now allows an icon to be displayed in each row, and can do all four list-view layout styles (as in the Windows File Explorer).
15. Can now scroll by logical objects. It is now possible to scroll windows by the logical objects displayed in them rather than by pixels, by overriding the default methods of several CG generic functions. See the horizontal-scroll-bar and vertical-scroll-bar pages.
16. windows-screen-device exported. windows-screen-device is now exported and is the type-of the screen object.
17. windows-graphics now exported. windows-graphics is now exported, and names the class of all streams that can be drawn on.
18. New Windows pull-down menu. There is a new Windows menu on the IDE menu bar. It can be used for exposing top-level windows in the IDE which aren't otherwise accessible from the IDE menubar, thus allowing quicker access than the Window List dialog does.
19. Documentation entries for certain key grid-widget functions has been improved. See read-cell-value, write-cell-value, draw-cell, data-reader, and data-object.
20. New return value from ask-user-for-string. ask-user-for-string returns an additional boolean value indicating whether the user accepted or cancelled the dialog.
21. additional arguments to move-window. The function move-window has additional arguments for specifying how much of the window needs to appear in the parent.
22. Changes to clipping-box: In version 5.0.1, the functions clipping-box and nclipping-box mistakenly returned a box that did not account for the scroll-position of the stream. with-clipping-box and (setf clipping-box) did not have this bug. Also, clipping-box and nclipping-box now return a second value indicating what sort of clipping region the window currently has --- nil means an empty clipping region (of size zero), where no drawing can be done at all, :simple means that the region is the exact box that was returned, and :complex means that the region is some non-rectangular portion of the returned box. When the clipping region is empty, earlier versions returned an arbitrarily large box; now the first returned value will instead be nil.
23. New configuration property conserve-indentation. The new IDE configuration property conserve-indentation may be toggled on to save some indentation space in the IDE editor.
24. Menu-item cluster property now works correctly. The cluster property of menu-item now works correctly to allow mutually-exclusive radio-button groups of contiguous items on a menu.
25. New common-status-bar-font and custom-tooltip-font configuration properties. The new configuration properties custom-status-bar-font and custom-tooltip-font allow overriding the system default tooltip font and status-bar font.
26. Lisp clipboard changes. The lisp clipboard stack shown in the Clipboard Browser dialog will now include items that are copied to the Windows clipoard in the rich text format and the device-independent bitmap format. New copy-command and paste-command methods for bitmap-pane and the drawable control allow copying and pasting pixmaps between these streams and the clipboard. (For the drawable control, the use-bitmap-stream property must first be turned on.) The new setfable function clipboard-object can be used in place of the separate clipboard-string and clipboard-pixmap functions. The new generic function clipboard-changed could be wrapped by applications to catch whenever the clipboard's contents have changed.
27. Printing fixes and enhancements.

    When opening a printer stream with the no-dialog-p option, the stream was not defaulting to the values most recently chosen by the user on the Page Setup or Print dialogs, such as the orientation and which printer to print to.

    The multicolor, paper-source, print-quality, and scale printer properties contained arbitrary (and often incorrect) values when the printer driver did not support multiple options for these properties; the properties will now be nil in this case.

    pop-up-printer-setup-dialog (for the Page Setup dialog) returns four additional values: paper-source, port-name, printer-name, and driver-name.

    There is a new paper-source printer property.

    The new function printer-names returns a list of available printers; one of these may be passed as the :printer-name initarg to open-stream, along with the :no-dialog-p option, to programmatically specify the printer for a print job.

28. The badly-named :host keyword parameter of ask-user-for-new-pathname and ask-user-for-existing-pathname has been renamed to :initial-directory for clarity and for consistency with the :initial-name parameter. Passing a :host argument will still work for backward compatibility.
29. There are two new Help menu items: Help | Download Patches and Help | Connect to www.franz.com.
30. New simple grid example. The Navigator has a new simple grid example (a color editor) as well as an example for simple animation in a drawable control.
31. The Filter widget of the Find in Files dialog may now contain multiple filters separated by semicolons, for example *.cl;*.lsp;*.lisp. The filters are kept in a history list. It also now works to append the filter wildcard directly to the search directory, as in c:\acl6\mycode\*.cl.
32. The keyboard shortcuts for moving to recent and nearby tabs in the editor and backtrace panes are now on the right-button shortcut menu for the body of those windows rather than only when clicking the tabs themselves. These handy shortcuts had been hard to discover.
33. The new generic function clear-grid-section may be overridden to avoid clearing whole grid sections when a grid is redisplayed to reduce flashing if the section knows how to draw its whole interior.
34. The maker-function that is automatically generated for a form window (in a .bil file) has a few additional arguments to allow customizing the window at runtime without modifying the generated code. These include child-p, which could be passed as nil to create a top-level owned window rather than a child, as well as title and border. The comments above the finder-function and maker-function have been improved also, so that the generated code looks something like this:

    ;; The finder-function, which returns the window if it already
    ;; exists, and otherwise creates and returns it.
    ;; Call this function if you need only one copy of this window,
    ;; and that window is a non-owned top-level window.
    (defun form1 () (find-or-make-application-window :form1 'make-form1))
     
    ;; The maker-function, which always creates a new window.
    ;; Call this function if you need more than one copy,
    ;; or the single copy should have a parent or owner window.
    ;; (Pass :owner to this function; :parent is for compatibility.)
    (defun make-form1
        (&key parent (owner (or parent (screen *system*)))
         (exterior (make-box 358 180 1024 550)) (name :form1)
         (title "Form1") (border :frame) (child-p t) form-p)
    

35. The static-text widget now has a wrapping property to optionally prevent its text from wrapping.
36. Calling generate application or build-lisp-image while running the IDE. Note that images with the IDE have the value of *restart-app-function* set to a function which starts the IDE. If you call build-lisp-image or generate-application in such an image, be aware that the value of the restart-app-function argument is inherited from the running image, so be sure to specify a value for that argument (specify nil if you want none) unless you want the IDE to start in the new image.
37. The Tree of Knowledge in the IDE (displayed with Help | Common Graphics Tree) is being expanded beyond CG and IDE symbols and topics to cover more of the base lisp extensions to Common Lisp and the base lisp's non-graphical programming environment. Presently it includes links to HTML pages for all CG and IDE general topics and exported symbols, and to all base lisp general topics and a small subset of exported symbols. It does not include standard Common Lisp functionality at all. Additional base lisp exported symbols may be added in the future.
38. Type-ahead now works in IDE listeners. Characters that are typed while an evaluation is being performed are not immediately visible, but will be echoed to the window and handled after the current evaluation has completed and the next prompt is printed.
39. The new function set-foreground-window will bring a window to the front even when its thread is not the current foreground thread.
40. The function find-links takes an additional append keyword argument that allows collecting links of multiple colors in a rich-edit control.
41. The new function eval-in-listener-thread allows evaluating a form in a particular IDE thread.
42. The functions rich-edit-range, get-text, and text-range have a new argument to choose whether the returned string contains CR/LF's or just LF's.
43. The Project Manager dialog now has a check-box for the purify option on the Advanced tab.
44. New configuration option start-in-allegro-directory causes the file selection dialog to initially default its directory to the Allegro directory rather than the Windows current directory.
45. The new variable *starting-ide* is set to nil after the IDE has finished coming up.
46. Comtabs no longer override global keyboard accelerators.

6.0 Release Notes for AllegroStore

Most of the changes to AllegroStore involve enhancements that support large databases efficiently. The one non-backward-compatible change, other than supporting new versions of ObjectStore (the underlying database used by AllegroStore) is the channel facility has been removed, replaced by the new notification facility.

There is a new version of the AllegroStore manual. In 6.0, it is a PDF file (allegrostore.pdf).

6.1 Non-backward-compatible changes in AllegroStore

1. Channel multiprocessing facility removed. The channel multiprocessing functionality that provided partial multiprocessing support for the Solaris, Irix, and HPUX operating systems is no longer available. Channel functionality has been removed so the Unix AllegroStore platforms may take advantage of performance enhancements that are not possible without removing channels. Also, blob and persistent foreign type functionality cannot work correctly with channels. Any application that used channels should be able to use multiple AllegroStore clients that communicate using the new notification functionality. Multi-client applications using notifications should perform better than Astore 1.3 channel applications. Notifications are described in section 6.24 of the AllegroStore Manual.

2. New version of ObjectStore on certain platforms: YOU MUST DUMP YOUR DATABASE BEFORE USING THE NEW VERSION. On the Windows, Solaris, and Irix platforms (but not on HP's), AllegroStore uses the new ObjectStore 6.0 major release. Since ObjectStore 5.x databases are not compatible with ObjectStore 6.0, users on these platforms must convert their existing databases. Before installing Ostore 6.0/Astore 2.0, create a dump file for each database using asdump. Be sure to use the latest Astore 1.3 asdump version available at the Franz ftp site.

   Wed Apr 19 15:22:28 PDT 2000
    Patch: asdump
           asverify
     Allegrostore patch: asdump now correctly identifies and discards
     stale pointers.  asverify will no longer crash when encountering
     stale pointers.
    Impact: Recommended.
   

   After installing Ostore 6.0/Astore 2.0, create Astore databases with asrestore. We recommend that you do the dump prior to installing the new version.

   The major benefit that Ostore 6.0 provides Astore users is an increased ability to create very large databases.

6.2 Other changes in AllegroStore

1. The current OS version/Ostore release version information:

   Solaris:: Solaris 2.7 is supported, Solaris 2.8 is not supported. Uses Ostore 6.0 SP4.

   Windows: Windows 95, 98, NT, and 2000 are all supported. Uses Ostore 6.0 SP4. See 6.2.2 Special note for users on Windows.

   Irix: Irix 6.5 is supported. Uses Ostore 6.0 SP4.

   Linux: Redhat 6.0 is supported. Redhat 5.x is not supported. Uses Ostore 5.0 SP5 Beta. See 6.2.1 Special note for users on Linux for more information on AllegroStore on Linux.

   HP: HP/UX 10.20 and 11.0 are supported. Uses Ostore 5.1 SP3. (Note that the HP/UX 11.0 Astore 2.0 release uses a custom Lisp executable, aslisp, as did the HP/UX 10.20 Astore 1.3 release. However, the HP/UX 10.20 Astore 2.0 release does not include an aslisp custom Lisp executable because Astore 2.0 runs with the usual Lisp executable under HP/UX 10.20.)

   HP 64: HP/UX 11.0 is supported. Uses Ostore 6.0SP4. A supplied custom Lisp executable, aslisp, is required when running AllegroStore.

2. persistent-ftype-array class. A persistent-ftype-array class is now available that allows allocating, setting, and accessing persistent memory without creating a parallel lisp object in the lisp heap. Persistent ftype (foreign type) arrays are more powerful than the blob class because persistent ftype array data may contain pointers to persistent addresses. See section 6.9 of the AllegroStore Manual.
3. :cached persistent slot definition. A new :cached persistent slot definition option enables automatic slot value read caching for persistent slots. For applications that access a slot's value many times during a single transaction, automatic read caching will result in a significant performance improvement. See section 6.6.1 of the AllegroStore Manual.
4. Improved long transaction functionality. For event driven applications that can insure that lock contention won't occur, the new begin-transaction, commit-transaction, and abort-transaction functions provide true long transaction functionality.
5. New notification functionality. New notification functionality makes it easier for multi-client applications to send messages to each other, especially when a persistent object is the message subject. Notifications are described in section 6.24 of the AllegroStore Manual.
6. Better options to open-database for large databases. There are new open-database options that give developers more control when working with huge blobs and large databases. These options reduce the probability of running into ObjectStore "address full" errors. See the information under the heading New arguments to open-database and with-database allowing instance/pointer/segment allocation on page 7-9 of the AllegroStore Manual.

6.2.1 Special note for users on Linux

Astore 2.0 on Linux is based on the Ostore 6.0 SP5 Beta release, which is the first Linux ObjectStore release. Here are issues related to the ObjectStore Beta version status:

1. The new Astore 2.0 persistent-ftype-array class is not available under Linux Astore because Linux ObjectStore does not support the underlying ObjectStore functionality. It is expected that the final Linux Ostore 6.0 SP5 release will support the needed functionality. Franz intends to update the Linux Astore distribution to use the final Ostore 6.0 SP5 release when it becomes available.
2. The Linux Ostore osconfig utility does not optionally set up shared library links in /usr/lib. Therefore, you must add $OS_ROOTDIR/lib to your LD_LIBRARY_PATH environmental variable in order to successfully run AllegroStore.
3. On our installation, the ObjectStore scripts intended to automatically restart the ObjectStore server upon reboot did not do so every time.
4. On our installation, sometimes AllegroStore did not run after the ObjectStore server was started. We found that socket permissions in /tmp/ostore were involved. We found that executing
   chmod o+w /tmp/ostore/*
   as superuser corrected the problem.
5. Except for persistent-ftype-array tests, which do not work because the beta Linux ObjectStore release does not provide the needed functionality, our entire AllegroStore test suite runs successfully. However, we have seen intermittent unreproducible errors. Please let us know if you experience anything similar.

6.2.2 Special note for users on Windows

One Windows 98 beta tester reported problems that were related to using Windows file dialogs: if a Windows file dialog is popped up before ObjectStore is initialized, a hard crash or hung process can occur after the dialog is destroyed.

To prevent this, call (astore::ensure-objectstore-initted) before doing any activity that causes a Windows file dialog to pop up.

Windows VAR customers should take note: if your application includes functionality that uses Windows file dialogs, you should call (astore::ensure-objectstore-initted) in your application initialization function. This will prevent problems on customers' machines even if you don't see a problem on your development machine.

Appendix A: More on Common Graphics changes to frame-with-single-child

As said above, functions called on a frame-with-single-child are no longer redirected to the frame-child.

In earlier releases, if you called copy-pixmap (for example) on a frame-with-single-child window such as a non-refreshing-window, then the pixmap would actually be drawn on the frame-child pane of the frame-with-single-child instead of on the frame window itself. This redirection was done whenever CG regarded the particular operation as not being useful on the frame. In the copy-pixmap-case, the pixmap would never be seen on the frame because the frame's interior is completely covered by the frame-child pane that is automatically created when a frame-with-single-child class is instantiated. (Drawing CAN be done on any window, though, including a frame-window.) This redirection was effected by approximately 160 methods that specialized on frame-with-single-child, each of which checked for the existence of the frame-child pane and simply called the same generic function on the frame-child if it existed.

This automatic redirection to the frame-child has now been removed from Common Graphics. This feature is no longer considered worthwhile because (1) if it is desirable to really call one of these generic functions on a frame-with-single-child frame window itself, there is no way to do so, (2) it was not obvious that this behavior was an explicit feature, or which generic functions it affected, and so could lead to confusion over whether a frame-with-single-child frame window and child pane are really one window or two, and it required a significant amount of code (the 160 methods) which is not necessary since it is easy for an application to call frame-child on a frame-with-single-child window to find the auto-instantiated child pane (even if there are additional child windows such as a toolbar and status-bar). The policy now is that the programmer should understand that two windows are involved, and to call functions on the appropriate one explicitly.

If an application relies on this feature by calling functions on a frame-with-single-child frame window when the frame-child pane is the actual target, then calls to frame-child will need to be inserted in the application source code to redirect the action as needed.

Frame-with-single-child methods that have been removed from the following generic functions, as well as from some corresponding setf functions. Functions that call these functions may be affected as well (for example, copy-pixmap did not have such a method, but it calls copy-pixels-to-stream, which did have such a method). Application calls to these functions where a frame-with-single-child frame window is passed probably should pass the frame-child in almost all cases.

animate-color-number, background-color, background-texture, bottom-margin, char-from-line-number, clipping-box, close-palette, color-number, copy-pixels-to-stream, copy-stream-area, create-pixmap-handle, current-line-number, current-text-column, cursorcursor-position, default-background-color, default-foreground-color, draw-box, draw-circle, draw-circle-arc, draw-circle-sector, draw-ellipse, draw-ellipse-arc, draw-ellipse-sector, draw-icon, draw-polygon, draw-polyline, draw-rounded-box, draw-string-in-box, draw-to, fill-box, fill-circle, fill-circle-sector, fill-ellipse, fill-ellipse-sector, fill-polygon, fill-rounded-box, fill-texture, fill-texture-size, first-visible-line, font, font-faces, font-handle, font-sizes, foreground-color, get-selection, get-texture, get-texture-info, invalidate-window, invert-box, left-margin, line-dashing, line-end, line-height, line-join, line-number-from-char, line-texture, line-width, move-to, nclipping-box, ncurrent-position, ncursor-position, nfill-texture-origin, nfontmetrics, nget-box, nget-fixed-box, nget-line, nget-position, nget-shape-box, nget-shape-fixed-box, nget-shape-line, nscroll-position, nstream-origin, nstream-string-corners, nstream-string-size, number-of-text-lines, nvisible-box, open-palette, page-height, page-width, paint-operation, palette, palette-size, pixel, pop-up-printer-job-dialog, property-default-value-p, realize-palette, release-mouse, right-margin, scroll-box, scroll-range, scroll-to, scrollbars, set-first-visible-line, set-graphics-context, set-page-size, set-scroll-range, set-selection, stream-char-width, stream-string-width, stream-units-per-inch, text-line, top-margin, transparent-character-background.

Appendix B: Common Graphics Classes removed because of changed drawing functionality

Drawing using graphic objects is no longer supported. This is a backwardly incompatible change.

As an alternative to functions such as draw-line or draw-ellipse, where all coordinates are specified in a single function call, Common Graphics also used to allow applications to create objects such as line and ellipse instances and then to draw or erase them by passing the instances to the functions draw, erase, graphics-fill, and erase-contents. This alternative has been deemed not significantly useful, and we are unaware of users using it, and so this functionality has been removed. Here are the classes and functions that have been removed:

• draw
• erase
• graphics-fill
• erase-contents
• line
• line-from
• line-to
• polyline
• polyline-vertices
• polygon
• polygon-vertices
• circle
• circle-center
• circle-radius
• circle-arc
• circle-arc-center
• circle-arc-radius
• circle-arc-start-angle
• circle-arc-length-angle
• circle-sector
• circle-sector-center
• circle-sector-radius
• circle-sector-start-angle
• circle-sector-length-angle
• ellipse
• ellipse-center
• ellipse-semi-major-axis
• ellipse-semi-major-axis-angle
• ellipse-semi-minor-axis
• ellipse-arc
• ellipse-arc-center
• ellipse-arc-start-angle
• ellipse-arc-length-angle
• ellipse-arc-semi-major-axis
• ellipse-arc-semi-major-axis-angle
• ellipse-arc-semi-minor-axis
• ellipse-sector
• ellipse-sector-center
• ellipse-sector-start-angle
• ellipse-sector-length-angle
• ellipse-sector-semi-major-axis
• ellipse-sector-semi-major-axis-angle
• ellipse-sector-semi-minor-axis
• rounded-box
• rounded-box-height
• rounded-box-corner-height
• rounded-box-corner-width
• rounded-box-top-left
• rounded-box-width

Appendix C: Common Graphics bug fixes and minor enhancements

This appendix lists bug fixes and minor enhancements to Common Graphics and the IDE. Many of these were implemented as patches to release 5.0.1.

1. When changing the mouse cursor of a window while the mouse is over the window, the cursor image now changes without the mouse having to move.
2. Common controls and lisp-widgets now call set-focus-event and kill-focus-event generic functions (as they have always been documented to do) when focus is set or changed. In 5.0.1, they actually (and incorrectly) called the on-set-focus and on-kill-focus individual widget event handlers directly.
3. A bug was fixed where certain system parameters such as screen-width and screen-height were cached, so the functions returned out-of-date values if the end user changed their values in Control Panel while Allegro or a standalone application is running.
4. A redisplay glitch when deleting grid-widget rows near the end of a section that was scrolled to the end is fixed.
5. Fixes have been made to window scrollbars to make them turn themselves on and off at the right times more consistently.
6. The Debug Window command history now handles circular lists, either when typed as input or printed as return values.
7. Carets are now positioned correctly in scrolled windows.
8. The Alt-key menu-bar accessors now work when focused on a child dialog of the menu-bar window.
9. Draw-icon no longer ignores the scroll-position of the window.
10. A redisplay glitch occurring after stretching proportional grid-widget subsections is fixed.
11. A dropping-outline with the top-level-dropper property turned on (to allow hanging outside its parent) now works properly on a modal dialog.
12. The system menu of child windows no longer truncates some final characters.
13. A Common Dialog invoked from another modal dialog is now modal with respect to the first dialog.
14. The IDE command history mechanism handles recursive lists in evaluated expressions or their returned values.
15. A rich-edit-multipic's font dialog now defaults to the current font of the associated rich-edit-pane.
16. A bug was fixed where a grid-widget scrollbar sometimes remained active when it had nothing to scroll and should have been disabled, or became enabled while it had nothing to scroll.
17. A grid-widget now redisplays correctly after scrolling a grid section that is partly clipped by a parent window of the window that the grid-widget is on.
18. Clicking on a grid-widget scrollbar left the keyboard focus there; now it returns the focus to the body of the grid.
19. Tabbing within a grid no longer gets stuck in an infinite loop when there was no other available cell to tab to.
20. The IDE generally no longer asks you to save the project file when running a project after saving one of its source code files (it just saves it).
21. A fix to the editor means that certain macros no longer indent much further in the IDE editor than in Emacs.
22. Saving a source code file under a different name is no longer forgotten by the project containing the file unless a Save All was also done before invoking other commands such as Find In File to search the project.
23. By popular demand, the IDE no longer closes editor buffers when closing projects that contain files being edited, or when removing files from the current project.
24. The IDE listener prompt now matches the prompt in listeners of the base lisp, showing the current read package of the listener followed by a sequential number for the form to be evaluated.
25. Find In Files now finds a match when a partial match immediately preceded the real match. For example, "foo" would not be found where "fofoo" appeared in the text.
26. When typing into a typable combo-box, text can now be added beyond what fits into the physical width of the combo-box
27. The inspector expression editor no longer gets into an infinite recursion generating recreation code for the value being edited.
28. There are two new editor commands when in emacs mode: RECENTER moves the text line that contains the text cursor to the vertical center of the editor pane. JUST-ONE-SPACE replaces the zero or more spaces at the text cursor position with one space. (Editor keystrokes are documented only in the Help | Shortcut Keys dialog.)
29. A bug is fixed where using devel:defdefiner could result in problems loading the prefs.cl file while starting up the IDE, due to a user package not existing at that time.
30. A bug is fixed where a widget on a tab-control could get buried by the tab-control in certain cases.
31. When opening a project or saving a project file, the search target of the Find In Files dialog will now switch to the current project, and the default directory of the file selection dialog will switch to the directory of the project.
32. current-position and ncurrent-position no longer report an incorrect position when the window is scrolled.
33. Tooltips no longer appear and expose the window that they describe when the window was not the foreground window.
34. Hotspots no longer needlessly required the hotspot-mixin class to come earlier in the class precedence list than the window class with which it is mixed.
35. The F1 Help command will now find top-level "colon" commands from the non-IDE top-level.
36. When the scroll-while-tracing configuration option is on, each newly traced call is now selected so that the arguments and return values of functions appear in the dialog as the calls occur.
37. The static-text widget now has a wrapping property to optionally prevent its text from wrapping. The default is true, which emulates the former behavior, where the control wraps the text at spaces as needed to prevent the text from extending off the right side of the control. Turning this property off can be useful for a static-text that displays only a single line of text so that a long word that would otherwise be wrapped to the next (unseen) line will instead remain on the first line to be visible up to the point where it is clipped by the right edge of the control.
38. The symbols primary-window and development-project-window are no longer exported. These symbols name classes that the IDE uses to facilitate its "project-style" interface, which employs multiple top-level windows that have a single owner, rather than multiple child windows in a single parent. We had planned to export this functionality for applications, but had done so only partially, and this support no longer seems sufficiently helpful to warrant providing it for apps. An application can use a project-style interface simply by creating multiple top-level windows that have the same owner window and managing issues such as deciding which window should have a menu command directed to it when a global menu-bar on one of the top-level windows is invoked.
39. The print name of windows now includes the process that created them, which is also the process that receives their events. This can be helpful in debugging multi-threaded applications.
40. A bug where circles were drawn off-center by a pixel is fixed.
41. The up and down arrow keys may now be used to increment the value of an editable-text widget that is attached to an up-down control when the editable-text has the keyboard focus.
42. Button-style tab-controls with focus-on-click nil no longer receive the keyboard focus when clicked.
43. The font property now works correctly on a drawable control. Previously you needed to specify the font on the window of the control rather than the control itself, where the property appears in the inspector for interactive specification.
44. Quick Symbol Info will now be shown in the status-bar when simply clicking on a symbol in the IDE editor if the symbol has a function binding or global variable binding.
45. load-project no longer fails when the project-name is not a keyword.
46. When Quick Find Definition is invoked on an individual method in the trace outline, it will jump directly to that method rather than showing all applicable methods of the generic function to those arguments. (The regular Find Definitions command will still do that.)
47. If the trace command is issued while an individual method is selected in the Find Definitions dialog, it will now trace only that method rather than the whole generic function.
48. The trace dialog will now indicate when a function call has not yet returned, by showing an elipsis (...) to the right of the function name in the trace outline widget until the function returns, and also by displaying "Still inside ..." as the label on the widget for returned values if the function call is selected in the trace outline widget before the call returns.
49. Toggling individual items in the Profile Dialog's filter dialog no longer requires holding down the control key.
50. A bug was fixed where, if multiple web browsers were running, the IDE's help facilities could display information in one browser but expose another one.
51. A bug was fixed where the Stop button was not responsive on the Find in Files dialog when searching a large hierarchy of directories that contained no files that matched the filter.
52. There is a new navigator example for constructing a mouse cursor programmatically.
53. (setf foreground-color) for a text-edit-pane no longer breaks when passing nil as the color.
54. The boldp, italicp, and underlinep arguments to plain-to-rich-text now have effect (in earlier releases, they did not work).
55. count-icons-in-file now returns the proper number of icons in a file.
56. The fancier "drag-images" version of drag-and-drop when dragging from a list-view now drags a reasonable image of the value rather than of the whole widget.
57. The dropping-pane of a dropping-outline is no longer left stranded on the parent window when removing a dropping-outline from a dialog.
58. When removing an up-down-control from a dialog, the pointer from its buddy widget to it is now removed.
59. Pressing ENTER in the IDE editor just after a long symbol followed by a dot no longer causes a break.
60. An error no longer occurs when opening a project that has subprojects if the open-project-action configuration option was set to :no-compile (seen on the Projects tab of the Options dialog).
61. A parenthesis-matching glitch in a horizontally-scrolled editor pane is fixed.
62. Find Definitions no longers breaks on FOO if there are methods for (setf FOO) but not for FOO itself.
63. Syncing a picture widget on a form to its image file (see the right-button menu of pixmap widgets on forms) did not mark the form as modified, and so a Save All did not save the new image that was re-read from the .bmp file.
64. window-under-mouse now works in the header area of a list-view control.
65. A Common Graphics base Lisp Internet browser plugin is now feasible - see plugin.htm and the examples/cgplugin/ directory for more information.
66. A problem on Windows NT where occasionally a pixmap would not appear at all when drawn with copy-to-stream, or the pixmap handle created by open-pixmap-handle would never draw anything, which seems to be caused by an NT bug, has, we believe been worked around.
67. A problem where 24-bit pixmaps created by load-pixmap sometimes displayed a row or so of random pixels at the very top is fixed.
68. If a project used the default-init-function, then calling the finder-function for the main window created by default-init-function no longer returns nil rather than the window.
69. A trackbar's visible-range now displays correctly if it extends from a negative number to a positive number.
70. An up-down-control now accepts widths other than 13.
71. The save-selection-when-unfocused option of a multi-line text control no longer always behaves as if it were turned on when running in win95/98.
72. A bug where pasting sometimes failed in a rich-edit control, due to rich-edit-range or (setf rich-edit-range) leaving a non-rich-text string on the OS clipboard for the rich-text format has been fixed.
73. If an error is signaled when inside a with-mouse-confined, the mouse is now unconfined to allow debugging.
74. draw-to, draw-by, move-to, and move-by now work in a with-delayed-redraw on a bitmap-pane.
75. rgb-to-hls no longer sometimes returns rationals (which broke when further passed to hls-to-rgb).
76. The italic and bold attributes are no longer ignored when changing the inspector fonts.
77. Loading 16-bit pixmaps has been sped up.
78. A bug where the interactive Menu Editor sometimes corrupted menu-items by causing multiple menu-items to share the same internal ID number has been fixed.
79. A bug where Undo did not work well with the Comment In / Out commands (undoing only a single line) has been fixed.
80. Restarting lisp will now show the console window if it was present when lisp was most recently exited (assuming that the prefs.cl file is left intact.)
81. A bug where editing a widget in the inspector when it is on a hidden tab of a tab-control on a form could add the widget additionally to the selected tab has been fixed.
82. The prefs.cl file could break loading if load-project had been called programmatically with a logical pathname in the previous invocation of lisp. Logical pathnames are now converted to absolute pathnames before being saved in the prefs.cl file.
83. The IDE status bar now says "external" rather than "x" when showing quick symbol info on an external symbol.

Appendix D: AllegroServe: Working with the Apache web server

As said above, AllegroServe (Aserve) is a web server that can dynamically generate web pages and "web-enable" existing applications with a browser front-end. Built with the goal of enabling developers to publish complicated web pages, AllegroServe gives developers the advantage of servicing large numbers of users on different types of computers, regardless of where they are located. AllegroServe is not included in the distribution, but available via Open Source license at http://allegroserve.sourceforge.net.

There is a snapshot of the documentation (but it will likely be updated in the downlaod and on the Franz website) in the Allegro CL 6.0 distribution at aserve/aserve.html. A download from SourceForge as described above will include the latest version of the documentation.

When using AllegroServe, there may be reasons, practical or political, where you would like to use another web server to handle the bulk of pages on your site and only use AllegroServe for dynamic pages. This is easy to do if the other web server has the ability to act as a proxy. The newest versions of the Apache web server have the proxy capability. In this section we'll describe what you have to do to configure Apache and to generate proxy-friendly html. The Apache notes apply to version 1.3.9 of Apache and are likely to apply to other versions as well (but it would be useful to read the document on the proxy module just in case).

The proxy support for Apache is found in the Proxy Module rather than being built into the server. First you must make sure that the proxy module is loaded into Apache by looking for references to it in the main Apache configuration file (httpd.conf), and ensuring that those references are not commented out.

Then you should ensure that proxying is turned on with this line in httpd.conf:

ProxyRequests on

Next you have to decide which urls on the Apache server should be sent to Aserve to be processed. Suppose we say that all urls that begin /aserve/ should be sent to Aserve, and that Aserve will run on the same machine as Apache but will listen on port 8080. We state this by adding this line to httpd.conf:

ProxyPass /aserve/ http://localhost:8080/
ProxyPassReverse /aserve/ http://localhost:8080/

The second line is to ensure that redirects get translated back to a form that the client can understand.

After these changes are made Apache must be restarted in order for them to take effect.

Now if a web browser asks for http://yourmachine.com/aserve/ it will see the result of Apache asking for http://localhost:8080/. What you would like is that if links are followed on the web page returned, that the illusion is maintained that pages in the http://localhost:8080/ tree are found below http://yourmachine.com/aserve/. In order for this to work, the web pages must use relative links to name pages in the same tree. For example if you used absolute links as in

((:a :href "/foo") "click on me and I'll fail")

then when the user clicked on this the web browser would ask for http://yourmachine.com/foo which would not be sent to Aserve to return the correct page.

However if the path to the url was written without the leading slash, and thus were relative, then clicking on this link:

((:a :href "foo") "click on me and it will work")

will cause a request for http://yourmachine.com/aserve/foo which will be sent to Aserve as http://localhost:8080/foo which will return the correct page (the page published with a path of "/foo").

Appendix E: 64 bit Allegro CL Implementations

There are now 64-bit implementations of Allegro CL for some platforms that support 64-bit operations. In release 6.0, the Compaq Alpha (formerly DEC ALpha) and the HP-PA platforms have 64-bit Allegro CL available. See 64 bit Allegro CL Implementations in implementation.htm for information on the few incompatibilities between the 32-bit and 64-bit versions.

Copyright (c) 1998-2000, Franz Inc. Berkeley, CA., USA. All rights reserved. Created 2000.10.5.