Greetings! The GCL team is happy to announce the release of version 2.7.1, the culmination of many years of work and a major development in the evolution of GCL. Please see http://www.gnu.org/software/gcl for downloading information.

The GNU build system has been installed.

The git repository hosts the sources at the maintainer-clean level, plus some packaging files for various systems. When building from a git checkout, you should not need autotools, but you may need to touch the following files in the top level source directory in order, as git does not preserve timestamps: aclocal.m4 configure.in configure Makefile.am Makefile.in.

When building from the distributed tarball this resetting of timestamps using 'touch' will never be necessary. Furthermore, as is customary this tarball will include in addition pre-built documentation, so the user will not need texinfo unless building the optional standard targets dvi, pdf, and html.

The check target will run the ansi-tests and some timing benchmarks.

The dist target will recreate the distribution tarball, and distcheck will test it.

Parallel builds are supported, but you should note that GCL will work in available system memory by default, and if multiple processes do not coordinate allocation, the effects could be negative. The environment variables GCL_MEM_MULTIPLE and GCL_MEM_BOUND can limit the memory each process sees, and GCL_MULTIPROCESS_MEMORY_POOL will instruct multiple processes to manage the memory collectively. These variables and more are documented in the info pages. The function 'user::help briefly explains how to access the info pages from the command prompt using the functions 'describe, 'apropos, and 'si::info.

Configure enable/disable options for gprof, xgcl, and gcltk will govern whether these features are built and installed -- for example, ./configure --disable-gprof. All options are configured to be built and installed by default if found to be supported at build time.

All known ANSI issues have been resolved, as reflected in the testsuite run via 'make check'. Both traditional and ANSI images are built and installed. The ANSI image is selected by {prefix}/bin/gcl if the environment variable GCL_ANSI is set to any value. Here {prefix} designates the prefix supplied to configure specifying where built files are to be installed, for example ./configure --prefix=/usr. The default {prefix} is /usr/local.

Achieving ANSI compliance has required some backward non-compatible changes in all images, most notably the representation of functions:

      
	
	  GCL (GNU Common Lisp)  2.6.14 Fri Jan 13 10:47:56 AM EST 2023  ANSI    git: Version_2_6_15pre10
	  Source License: LGPL(gcl,gmp), GPL(unexec,bfd,xgcl)
	  Binary License:  GPL due to GPL'ed components: (XGCL UNEXEC)

	  Modifications of this banner must retain notice of a compatible license
	  Dedicated to the memory of W. Schelter
	  
	  Use (help) to get some basic information on how to use GCL.
	  Temporary directory for compiler files:
	  /tmp/

	  >(flet ((rep (x) (list x (consp x) (functionp x) (ignore-errors (funcall x)))))
	      (let* ((x '(lambda nil t))(y (eval x)))
	         (list (rep x) (rep y))))

	  (((LAMBDA () T) T T T) ((SYSTEM:LAMBDA-CLOSURE () () () () T) T T T))

	  GCL (GNU Common Lisp)  2.7.0 Thu Oct 26 12:00:01 PM EDT 2023  ANSI    git: Version_2_7_0pre39
	  Source License: LGPL(gcl,gmp), GPL(unexec,bfd,xgcl)
	  Binary License:  GPL due to GPL'ed components: (XGCL UNEXEC)
	  Modifications of this banner must retain notice of a compatible license
	  Dedicated to the memory of W. Schelter

	  Use (help) to get some basic information on how to use GCL.
	  Temporary directory for compiler files set to /tmp/

	  >(flet ((rep (x) (list x (consp x) (functionp x) (ignore-errors (funcall x)))))
	     (let* ((x '(lambda nil t))(y (eval x)))
               (list (rep x) (rep y))))

	  (((LAMBDA NIL T) T NIL NIL) (# NIL T T))
	
      

GCL functions carry a lot of extra information by default, including the call signature, the assumed signatures of fast-link callees, the compressed-string version of the source, and the file from which it was loaded. This enables some useful features:

• All functions not referencing static data (i.e. closures, load-time-value) can be inlined regardless of the (declaim (inline)) status at function definition. The static data limitation will hopefully be removed in the future.
• GCL fully implements 'function-lambda-expression, usefully abbreviated with 'si::fle.
• GCL provides a utility 'si::do-recomp to identify signature conflicts and recompile the original source files. The older utility using optional .fn files to generate a sys-proclaims.lisp is still supported, but is trumped by the signature information accompanying the function itself. The old system tried to handle this on a per-file basis, which was limited as the produced signatures implicitly depended on signatures in other files. The new system analyzes all conflicts at once, iterating until consistency is achieved.
• Self-explanatory functions 'si::file and 'si::signature.
• GCL provides 'compiler::interpret to reverse the operation performed by 'compile, i.e. to replace a compiled function designated by the supplied symbol with its interpreted counterpart.
• Functions 'compile and 'compiler::interpret are idempotent and can be invoked multiple times.
• Heavy use of automatic inlining is used by the compiler.

Limited profiling is available in all images, when supported, by adding the :prof-p t arguments to compile-file. The corresponding 'compiler::*default-prof-p* can make this the default in any image. Only functions thus compiled will appear in the output of (si::gprof-start)(...)(si::gprof-quit). To profile all of GCL, the profiling images can be run by setting the GCL_PROF environment variable to any value before invoking {prefix}/bin/gcl. The startup banner will let you know which image you are running.

On many systems, notably x86_64, the standard code produced by gcc (the 'medium model') must lie within the first 2Gb of memory. Attempts to load code over this address will trigger an error indicating that the code has been compiled for a restricted address space. One can reserve extra low memory for code if needed using the variable 'si::*code-block-reserve* documented in the info pages.

If the heap has grown too large and there is no longer any space below 2Gb, code can be compiled and loaded for the 'large' memory model at about a 10% performance penalty. The options :large-memory-model t to compile-file, or the corresponding 'compiler::*default-large-memory-model-p*, can control this behaviour. At the moment this support is limited to x86_64 systems.

The function 'compiler::watch can take as an argument any symbol naming a variable or function being compiled to trace the compiler's logic applied to that symbol. Some useful special symbols can also be supplied, such as 'compiler::type-inference, 'compiler::branch-elimination, 'compiler::inline, and 'compiler::tail-recursion. The function 'compiler::unwatch turns off tracing on the supplied arguments, or universally with no arguments.

The variable 'compiler::*annotate* if set will place comments in the generated C file illustrating the inlining. The variable 'compiler::*disassemble-objdump* governs whether assembly accompanies the C source output of disassemble.

The variable 'si::*fast-link-warnings* can let you know if calls to your function cannot be fast linked. All calls regardless of signatures should proceed correctly, albeit possibly slowly in case of signature mismatches.

The demo functions 'xgcl-demo and 'gcl-tk-demo have been updated.