This file contains old Tech Corner entries.
SWIG is a tool for automatically generating interfaces to C/C++ libraries for use with non-C/C++ programming languages. (SWIG stands for Simplified Wrapper and Interface Generator). This update represents a major rewrite of the existing module for interfacing to Allegro CL. Many new features and improvements have been added. This essay describes the improvements. It includes examples showing how to use the interface.
Allegro Prolog, an implementation of Prolog within Allegro CL, is included with the Allegro CL 7.0 distribution. An update released in mid September, 2005, provides a new version of Allegro Prolog for 7.0. Allegro CL 8.0 has both version included with the distribution. (The update can be downloaded with sys:update-allegro.) This new version allows Allegro Prolog to be used as a query language for AllegroCache (described here). The documentation for the new facility is here.
Allegro CL has for some time provided an OLE interface with its Allegro CL on Windows. However, it is low-level and quite complex. A new high-level interface has just been released in an update to Allegro CL 7.0 (and is included automatically in Allegro CL 8.0). (The update can be downloaded with sys:update-allegro.) The documentation for the new facility is in ole.htm. (That document also documents the older interface, which is still supported.)
64-bit Allegro CL 7.0 has now been released on Solaris 10 for x86-64 hardware, to augment our SPARC 32-bit and 64-bit versions for SPARC. Contact email@example.com for more information on the 64-bit Allegro CL 7.0 on Solaris x86-64. Allegro CL 8.0 is also available on that platform
An update to the SOAP interface in Allegro CL 7.0 was released in mid July, 2005. This soap.002 update can be downloaded with sys:update-allegro. The new functionality is included in Allegro CL 8.0 with no update necessary. The new SOAP interface release provides
See the updated soap documentation,doc/soap.htm, for more information on the SOAP interface and the update.
An update to Allegro CL 7.0 on 32-bit platforms greatly increases the size of files that can be reliably handled. (Functions which may not have worked before but now do include file-position and file-length, and the OS Interface functions stat, os-truncate, and os-ftruncate.) The new limit is (1- (expt 2 63)) in size. This is about two million times larger that the old limit, which was 4 Gigabytes. (On 64-bit platforms, the maximum allowable size has always been (1- (expt 2 63)).) You can obtain the update with sys:update-allegro. The new functionality is included in Allegro CL 8.0 with no update necessary.
64-bit Allegro CL has now been released on Mac OS X 10.4 machines. (The 32-bit Allegro CL has been available on Mac OS X for some time.) See here for a list of all platforms on which Allegro CL runs. Contact firstname.lastname@example.org for more information on the 64-bit Allegro CL on Mac OS X.
The multiprocessing model in Allegro CL 7.0 has been upgraded. In earlier releases, different models were used on UNIX/Linux/Mac OS X machines and on Windows machines. Windows used OS threads while the UNIX-type implementation used the older model derived from Lisp machines. In 7.0, the models have been unified. UNIX-type platforms still do not use OS threads, using instead threads created and managed within Lisp, but the interface is essentially identical whether or not OS threads are used, allowing porting of programs more easily between Windows and UNIX-style platforms. This essay provides more information on the new implementation.
The Document Object Model (DOM) provides a programmatic interface to XML and HTML. Support for DOM Level 1 Core is now available by patch to Allegro CL 6.2 customers (it is included with the Allegro CL 7.0 distribution). The patch downloading function, sys:update-allegro, will automatically download the correct patch for the version being run. We provide a brief introduction to Allegro CL DOM support here. The full documentation is here for Allegro CL 7.0 and here for Allegro 6.2 (both documents are the same).
Last month we released a new Perl regular expression API module (see A new Regular Expression API below). This month, we release an update to that module which includes additional functionality. This essay provides a brief introduction to the new functionality in the update. The document regexp.htm has been updated as well and describes the additions to the API.
OpenGL is a collection of 2D and 3D graphics routines providing an environment for developing portable, interactive 2D and 3D graphics applications (see www.opengl.org). Allegro CL 7.0 contains an interface to OpenGL 1.1 on Windows and 1.2 and 1.3 on Linux platforms. This Tech Corner essay introduces the interface. The interface documentation has not yet been fully integrated into the Allegro CL documentation. A Readme file describing the interface is in the AllegroCL 7.0 distribution at opengl/readme.txt.
Allegro CL 7.0 was released before certain OpenGL interface files were available. To use the OpenGL interface, please first run sys:update-allegro to download the necessary additional files (after the update, you should see the new directories opengl/win32-1.1/, opengl/linux-1.2/, and opengl/linux-1.3/).
Allegro Oracle Direct Connect is a new interface between Allegro CL and Oracle databases (version 8 or higher). It uses the Oracle C Interface (OCI) libraries from Oracle. It is available by patch to Allegro CL 6.2 customers (it is included with the Allegro CL 7.0 distribution). Allegro CL 6.2 customers need an additional license, available from their account manager. We provide a brief introduction to the new interface here. The full documentation is here for Allegro CL 7.0 and here for Allegro 6.2 (both documents are the same).
Allegro Prolog, an implementation of Prolog within Allegro CL, is included with the Allegro CL 7.0 distribution and is available as a patch for Allegro CL 6.2. (The patch is downloaded by sys:update-allegro.) We provide a brief introduction to the new Prolog implementation here. The documentation for the new facility is here for Allegro CL 7.0 and here for Allegro 6.2.
This is the latest in a series of Tech Corner articles on new features in the Allegro CL/SOAP API. The previous entry was The updated Allegro CL/SOAP API with WSDL support, which described WSDL 1.1 support. This essay describes WSDL generation support. It was added by a patch in May, 2004. This essay discusses the new facility.
Allegro CL has for some time offered support for Regular Expression matching. We have just added a new API for regular expressions, which is faster and more Perl like than the earlier API. Both the old and the new APIs can be used at the same time in the same running Lisp. This essay provides a brief introduction to the new API. Both APIs are described in regexp.htm.
If you use an Apache webserver, but you wish to also use AllegroServe, you must integrate Allergoserve into your Apache-based server. This essay provides several suggestions for on Apache/Allegroserve integration. Allegroserve is described in aserve.html (the link is to the documentation on the opensource page, which is always the latest documentation).
SWIG (Simplified Wrapper and Interface Generator) is a tool for automatically generating interfaces to C/C++ libraries for use with non-C/C++ programming languages. We have added a module to SWIG to support generation of interface code suitable for Allegro Common Lisp. This essay provides more information on the new SWIG module.
In release 6.2 and in earlier releases, the maximum number of array dimensions and the maximum number of array elements was 16,777,216 (i.e (expt 2 24)) in 32-bit Lisps and 72,057,594,037,927,936 (i.e. (expt 2 56)) in 64-bit Lisps. In release 7.0, the limit will be raised to most-positive-fixnum is both cases. Therefore, arrays can be about 32 times larger in 32-bit images and 16 times larger in 64-bit images.
For most users and applications, the change to the new larger allowable array sizes will be transparent, the only difference being that requirements that bumped into the old limits can now be met. But there are some programs that may have problems with the changes to arrays: (1) those that created huge numbers of (presumably small) arrays whose total data space is the equivalent of an odd number of words, and (2) those that incorporated foreign (i.e. C) code that depended on the internal structure of arrays in Allegro CL. The first group will find space usage greatly increased for these arrays, because the new arrays use an additional word of data per array, and alignment requirements cause the total memory usage to be increased by two words. The second group will have more serious problems: because the internal structure of arrays has changed, the foreign code will cease to work properly.
We have addressed these issues by simultaneously supporting the old, shorter array implementation in parallel with the new, larger array implementation. We have added the type short-array, which is a 6.2-type array. Short-arrays are arrayp (i.e. a subtype of array) and (when 1-dimensional) vectorp (i.e. a subtype of vector), but not a subtype of any other standard Common Lisp array or vector type. Instead, new types, named by the standard Common Lisp types with short- prepended (i.e short-simple-array, short-string, etc.), have been created. Similarly, aref works on both type of arrays but other standard Common Lisp array accessor and predicate functions do not work on short-arrays; instead again, new accessors and predicates, named by the standard Common Lisp function names with short- and sometimes s prepended (i.e. short-simple-array-p, ssvref), are provided.
We believe that most users and applications will be able to use the new, larger arrays without any changes to their existing programs, and that users who depend on the internal structure of arrays will find it easy to adapt their code to use the new short-arrays instead.
The 7.0 documentation is not public yet, so we cannot yet link to the new array documentation. When that documentation is available, this entry will be updated to link to it.
A third pre-release version of a new Allegro CL/SOAP interface has been made available as a patch to supported Allegro CL customers. (It is not at the moment available to Trial users.)
SOAP is a remote procedure call protocol embedded in HTTP. The protocol uses XML structures to transmit call and data between client and server. The Allegro CL/SOAP API enables Allegro CL applications to communicate with new and legacy applications on the internet. SOAP in Allegro CL supports SOAP servers and thus provide Web Services written in Common Lisp.
The third release includes WSDL support. Many web services are defined in an XML dialect known as WSDL. The WSDL definition specifies the element content and data types in the SOAP messages received and sent by the service.
Given a web service WSDL definition, we can generate the Lisp functions and definitions needed to send messages to the service and to receive and decode the replies.
The patch can be downloaded by Enterprise and Professional customers in the usual way, by running sys:update-allegro. More information about the patch can be found in the patch log.
Future releases are planned to include the following features:
We are pleased to announce support for Mac OS X 10.3. However, we will no longer support Mac OS X 10.1.
A binary version of Allegro Webactions is now available to all users of Allegro CL 6.2.
See as well this later entry about the Allegro CL/SOAP API.
A second pre-release version of a new Allegro CL/SOAP interface has been made available as a patch to supported Allegro CL customers. (It is not at the moment available to Trial users.)
SOAP is a remote procedure call protocol embedded in HTTP. The protocol uses XML structures to transmit call and data between client and server. The Allegro CL/SOAP API enables Allegro CL applications to communicate with new and legacy applications on the internet.
This new release allows Allegro CL users to build SOAP servers and thus provide Web Services written in Common Lisp.
Future releases will include the following features:
See as well this later entry about the Allegro CL/SOAP API.
A pre-release version of a new Allegro CL/SOAP interface has been made available as a patch to supported Allegro CL customers. (It is not at the moment available to Trial users.)
SOAP is a remote procedure call protocol embedded in HTTP. The protocol uses XML structures to transmit call and data between client and server. The Allegro CL/SOAP API enables Allegro CL applications to communicate with new and legacy applications on the internet. (In this initial pre-release, it is a client only API.) For example, google.com provides a SOAP API that allows programs to initiate searches and retrieve results. (The new facility provides an example linking to Google.)
A new facility for generating dynamic web pages, Allegro Webactions, has been made available as a patch to supported Allegro CL customers. (It is not at the moment available to Trial users.) Allegro Webactions sits on top of AllegroServe (Franz Inc.'s Lisp-based web server) and provides a framework for building web applications that are easy to maintain and update.
The document Using Allegro Webactions provides a general description of Allegro Webactions and its capabilities. The document Webactions is a User Guide and Reference Manual for the software provided in the patch. (The documentation links are to the docs on the Opensource site.)
A new website, http://examples.franz.com/, providing links to downloadable example programs and application is now live. The examples demonstrate non-trivial uses of Lisp and the features of Allegro CL. This essay provides an introduction to the new website.
A new implementation of the FTP client module has been available for downloading for a while. This module can be used to communicate with an FTP server, including Allegro FTPd (http://github.com/franzinc/aftpd/). It can be downloaded using sys:update-allegro. The relevant file is ftp.fasl. This essay provides more information on the module.
MySQL is a powerful, efficient, production ready open-source database that runs on all popular platforms. There are language bindings for most popular languages. The document doc/mysql.htm describes the bindings for the Allegro Common Lisp language. The Allegro MySQL module was provided as a test release in the fall of 2002. It is now available to all supported users. The Allegro MySQL module will be downloaded when you run sys:update-allegro to download patches and updates for Allegro CL 6.2. See this note for more information and some examples.
One of the recent updates to Allegro CL 6.2 was a full-fasl patch for the Remote Procedure Call (rpc) facility. This update added new functionality and modified some existing functionality. The rpc.htm document was also updated to reflect the changes.
In this note, we discuss one of the new RPC features: a facility to manage a pool of Allegro CL light-weight processes (lwp's) used to execute in-coming remote calls.
There have been several documentation updates in the last couple of months. (Recall the documentation is available in the support/documentation/ page.) Among the code updates are a new jLinker patch, with new and corrected functionality and a new Operating System Interface facility which we discussed in a the last entry. See release-notes.htm, particularly the section Information on changes and new stuff since the 6.2 release for details on updates.
A patch is now available (by running sys:update-allegro) that provides better integration between Lisp and native operating system resources. The documentation on this new facility has been added to the Operating System Interface (doc/os-interface.htm) document. See particularly Appendix A: Operating System Interface Functionality in that document.
Click here for more details.
Starting with the Allegro CL 6.2 release, we are updating the Allegro CL documentation more frequently. The documentation is available in the support/documentation/ page. That page has links to the latest version of the Allegro CL 6.2 documentation.
There have been several documentation updates since the Allegro CL 6.2 release in July, 2002, and new updates are made regularly. (The FAQ is updated more frequently, whenever an item is changed or a new item is posted.)
In an update, we correct minor errors (spelling mistakes, missed links, and the like), we rewrite sections of pages that were unclear or incomplete, and we correct any serious mistakes that have been reported. Most such mistakes are listed in errata.htm.
Modified pages are identified in the upper right corner, where change from the 6.1 documentation is also noted. If a page has been changed, it says one of "Minimal update since 6.2 release", "Moderate update since 6.2 release", "Significant update since 6.2 release", or "New since 6.2 release". New pages are added to the standard index but not (in the latest update) to the permuted index.
You can download the new documentation to replace that distributed with the Allegro CL 6.2 release (or an earlier update), as decribed on the support/documentation/ page.
In an earlier Tech Corner entry, we discussed the Allegro CL 6.1 Documentation update, mentioning the new Permuted Index files (see permuted-index.htm) included in the update. In this entry, we will discuss how the permuted index was generated and show the generation code. The discussion is in a separate file. Click here to see it.
The Allegro CL encapsulating streams facility was added in release 6.1 but not documented until the Allegro CL 6.1 documentation update. In this entry, we discuss the facility and one of the examples. The full story is in stream encapsulations in streams.htm
In the previous example, we showed how to use the Allegro CL RPC facility to gain remote access to an application. In this entry, we do much the same thing in a different way. We use telnet to connect with the application (which has started a server process to listen for telnet connections via the socket interface). Lisp forms can be passed to the application and the results of evaluating them are passed back.
Click here to see the example and to see the source code used to implement it.
An earlier Tech Corner entry introduced the new Allegro RPC facility, which implements a general purpose remote procedure call facility for Allegro CL. In this entry, we discuss an example using RPC. The sample code in [Allegro Directory]/examples/rpc-inspect.cl can be used to examine a running Lisp image from another Lisp image running on a separate, possibly remote, machine.
An updated version of the Allegro CL 6.1 documentation has been posted on the Franz Inc. website, on the support/documentation/ page (the link is to the main documentation page, which has links to the new 6.1 documentation as well as to documentation for earlier versions). The update corrects errors in the documentation as originally released, expands or clarifies various material, and, in some cases, adds new material applicable to release 6.1 (for example, the description of stream encapsulations in streams.htm). Instructions linked to on the support/documentation/ page tell you how to download and install the revised documentation.
A new feature has also been added: a permuted index generated from the standard index. The permuted index takes standard index entries and indexes them on every word they contain. run-shell-command is thus indexed under R (for run), S (for shell), and C (for command) in the permuted index. This is particularly useful when looking, for example, for functions associated with a concept such as multiprocessing gates (which typically have gate in their names but often not at the start of their names, e.g. make-gate and open-gate: see permuted-index-g.htm). A link to the main permuted index file, permuted-index.htm has been added to the title/navigation bar of every page. Each permuted index page has scroll-to links just under the title allowing quick scrolling down the page.
In a future Tech Corner entry, we will discuss how the permuted index was generated.
The Allegro CL RPC module, adding in release 6.1 and documented in rpc.htm, provides a flexible remote procedure call capability to a Lisp application. A remote procedure call allows one Lisp process (or image) to call a function in a separate Lisp process (or image). The two Lisp processes could be running on the same machine, or they could be running on different machines separated by a great distance. Unless otherwise indicated, references below are to sections of rpc.htm.
A remote call in the application program looks and behaves like an ordinary function call (see the defining macro def-remote-function). The RPC module takes care of the marshalling (encoding) and unmarshalling (decoding) of data values, and the synchronization of events. Calls and callbacks may be nested in each process to preserve dynamic environments, as described in the Callback style of stream sockets section. Calls may also be handled in parallel threads to isolate dynamic environments or to increase responsiveness. Many data types are transmitted by value but complex data structures are transmitted as remote references, as described in the Data representation section.
One application of RPC is to implement a coarse-grained form of parallel computation that takes advantage of a machine with multiple processors. An application can be split into several components that can run in separate Lisp images. Since each Lisp component in the application is a separate process from the point of view of the operating system, each may run on a separate processor. The same application can also run on several distinct machines connected on a local area network. The RPC module allows the separate components of the application to communicate in a natural way that looks like an ordinary function call.
Another application of RPC is transaction-oriented processing among widely separated components of an application.
Allegro CL RPC supports two types of connections: stream socket and datagram. Datagram connections differ from stream socket connections in that connections are maintained for single actions only. Datagram connections are described in the Datagram socket connections. One application of datagram connections is to implement a collection of servers that distribute information to other applications on a network. The datagram protocol is well suited to situations where connectivity may be intermittent, multiple sources may be available, and sychronization of calls is not critical. Since each call is a separate connection event, the application is not burdened with opening, maintaining, and closing connections.
The RPC module is not a universal solution. There are some things it does not do well, and some that it does very poorly. Even when the distributed components are running on the same machine, it is not an efficient way to transmit large volumes of data. A shared database or a file may be more effective in these cases. When the distributed components are separated by a great physical distance and connected by a slow network such as the internet, network latency becomes the governing factor and applications can only communicate with occasional calls where timing is not critical.
In a later Tech Corner entry, we will show how to use RPC to gain remote access to an application.
The most widely used compression algorithm on Windows and Unix is called Deflate (see http://www.gzip.org/zlib/rfc-deflate.html). Deflate is used in zip files (the standard file archiver on Windows) and in gzip'ed files on Unix. It is also used in Java Jar files (since Jar files follow the zip file format).
The Deflate algorithm combines the Lempel Ziv (1997) compression algorithm and Huffman coding.
We have written the code to uncompress deflated files, which we call Inflation. The source is available on our open source web site at http://github.com/franzinc/zlib. We will be adding code to show how to turn a simple-stream into a stream that inflates its input. At this point in time we have no plans to implement compression of files using the deflate algorithm. Simple-streams are described in streams.htm.
Over its previous several releases, Allegro CL has provided a firm structure on which to program international character applications by using Unicode representation and Lisp-definable external-formats to arbitrary character sets. International applications, however, often have other needs as well, such as handling local currency and date/time formats, as well as language specific character sorting requirements. Starting with release 6.1, Allegro CL includes new Localization tools to meet these requirements.
Using Allegro locales:
numberscan be displayed and read (parsed) based on culturally specific rules (e.g., a comma may be used as a thousands-separator in one locale, and as a decimal point in another locale).
date and timecan be displayed in culturally appropriate ways, including the use of international characters (e.g., for day or month names).
monetary informationcan be displayed in regionally appropriate ways.
In Allegro CL, the value of *locale* determines the current locale. This variable can be dynamically rebound to allow multi-threaded Allegro CL applications to operate in different locales simultaneously.
Allegro CL 6.1 comes with about 140 pre-defined locales for cultures around the world. Users can easily modify or add locales either within lisp or by directly editing source localedef files.
In addition to supporting locales, Allegro CL also supports new collation functionality. Words containing international characters may be collated (sorted) differently in different natural languages. Allegro CL now includes a string-sort-key function which specifies how to sort such words. The collation information is in a table whose format comes from the Unicode organization. Users can modify collation behavior by modifying or creating completely new tables.
Allegro CL 6.1 tunes performance and streamlines development allowing Allegro CL users to take advantage of the exciting powerful features premiered in Allegro CL 6.0.
[19Jan2001] The open source XML and HTML parsers were updated in Jan 2001 to fix some known problems. For the HTML parser, a fix was made that prevents the parser from infinitely looping on some pages that contain SCRIPT tags. For the XML parser, we made changes that allow compilation and usage in ANSI mode Lisp images.
The release of Allegro CL 6.0 has a vastly improved stream interface. To read about this new API click here.
ANSI Common Lisp has no direct support for testing applications and API's. We have decided to make public the test harness used by Franz Inc. to test releases of Allegro CL and associated products, in the hope that it will assist Allegro CL customers make their code more robust. Click here to see a more detailed description of our test harness and instructions for getting it as a patch to Allegro CL 5.0.1.
Similar to relative pathnames, relative packages names identify
children and parents of packages and permit the use of dots (.) to
refer to package children and parents. Allegro CL has implemented a
relative package scheme which should reduce package name conflicts. To
use it, you define package names with dots (for example, the packages
the current package,
.bar::a refers to the symbol
foo.bar is the current
..::b refers to the symbol
foo::b. Click here
to see a description of the relative package name scheme and
information on how to get the functionality in Allegro CL 5.0.1 with a
Universal Resource Indicators or URIs provide a superset of the functionality of Universal Resource Locators (URLs). URIs are defined in specifications available in several locations, including the IETF web site and the UCI/ICS web site. We have extended Allegro CL to include support for URI objects. Click here to see a description of URI support and information on how to get the functionality in Allegro CL 5.0.1 with a patch.
Click here to see the description of the new facility for downloading patches for Allegro CL.
|Copyright © 2017 Franz Inc., All Rights Reserved | Privacy Statement|