elk/MIGRATE

$Id: foo$

This file lists changes in the interpreter kernel that affect the C/C++
interface to applications using Elk and to Elk extensions, and (in
rare cases) the Scheme level interface.

Changes in release 3.0:

     o  To avoid name conflicts, the names of extension initialization
	(finalization) functions now begin with elk_init_ (elk_finit_).
	You will have to edit your source and change the function names
	accordingly.

     o  The Scheme object representation ("Object") has been changed from
	an unsigned long to a struct.  Although the changes are backwards
	compatible with the Elk 2.2 interface and should, in general, not
	affect your C/C++ code, you should be aware of a few potential
	trouble spots:

	  o  Code can no longer assume sizeof(Object) == sizeof(int).
	     Thus, all arguments and return values of type Object must
	     be declared properly.

	  o  You can no longer cast an `int' into an Object or vice versa.

	  o  You cannot compare Objects directly; use the EQ macro.

	  o  POINTER_CONSTANT_HIGH_BITS is gone (but you weren't supposed
	     to use this anyway...)

	  o  Initializing a local (auto) Object variable in the declaration
	     doesn't work any longer if you are using a K&R C compiler.

     o  You can no longer enforce allocation of a specific type slot
	by Define_Type().  The first argument to Define_Type() now _must_
	be zero.

     o  The constant MAX_TYPE has become meaningless and will be removed
	in the future.  Also, SETFIXNUM and SETTYPE do not exist any
	longer (SET can be used instead); SETPOINTER is obsolete.

     o  There are a few new interface functions that your code may benefit
	from (such as Set_App_Name); see CHANGES and the new C/C++
	Programmer's Manual (doc/cprog).

     o  A few `P_*' functions have been renamed in the interpreter for
	consistency.  See include/compat.h.

     o  In Elk 2.2, the primitives c[ad]*r and cxr just returned ()
	if the list was too short.  Proper error checking has been
	added.  If your Scheme code suddenly produces errors in calls
	to c[ad]*r, check the arguments.

     o  All the names of converters for callbacks in lib/xaw/*.d and
	lib/xm/*.d now have a prefix `callback:'.  This was required
	to resolve name conflicts with the converters for ordinary
	resources.  If you are using custom widgets or have added your
	own converters to existing widgets, you will have to add the
	prefix.


Changes in release 2.2:

     o  All Scheme files in the distribution now end with the suffix .scm;
	`require' now appends .scm to the feature name if no file name has
	been specified.  You should rename your Scheme files accordingly
	(if you haven't done yet anyway).

     o  Declarations that are private to the interpreter (and are not
	supposed to be used by extensions) have been moved from
	include/extern.h into include/intern.h.  You should make sure
	that extensions only use functions and variables defined in
	the new include/extern.h.

     o  If you have an extension that invokes fork() and that may execute
	Scheme primitives in the child process, make sure that the new
	function `Call_Onfork()' is invoked in the child process to call
	the `fork handlers' which may have been registered by the
	interpreter or by other extensions.

     o  The interpreter kernel now exports functions to convert C longs
        into Scheme numbers and vice versa.  See CHANGES for the list of
	new functions.

     o  The new function Define_Reader() may be used by extensions to
	define their own `#' read syntaxes.  See lib/bitstring.c for an
	example.

     o  The macros Make_C_String, Declare_C_String, and Dispose_C_String
	are now obsolete (but are retained for compatibility for a
	limited time).  You should use the new, improved functions/macros
	mentioned in CHANGES and in src/cstring.c.

     o  Get_Integer() and the new Get_Long() can be called with inexact
	integers (such as the result of truncate).  If you are writing
	a Scheme primitive that requires its argument(s) to be *exact*
	integers, use Get_Exact_Integer() or Get_Exact_Long().

     o  Elk 2.2 now correctly supports inexact integers.  This may cause
	Scheme code such as

	   (vector-ref '#(a b c) (truncate 1.5))
	
	which used to work in earlier versions of Elk to fail, as
	truncate returns an inexact integer in this example.  One simple
	way to fix this is to use inexact->exact to convert the inexact
	integer into an exact one.

     o  As extensions (such as the new UNIX extension) are now allowed
	to use signals, it is important that you protect critical code
	sections by calls to Disable_Interrupts/Enable_Interrupts (in C)
	or disable-interrupts/enable-interrupts (in Scheme).

     o  The representation of Void has changed-- it is no longer a
	separate, pointer-less type (like Null), but a symbol with
	an empty name.  As a result you now have to GC_Link variables
	holding Void.

     o  The old (undocumented) `struct' extension is obsolete; you
	should use the new record extension (see doc/record).

     o  The primitives `file-status' and `getenv' have been removed.
	file-status can be approximated by functions from the new UNIX
	extension like this:

           (require 'unix)

           (define (file-status file)
             (let ((stat (unix-errval (unix-stat file))))
               (if (unix-error? stat)
	           'non-existent
	           (stat-type stat))))

	Use unix-getenv from the UNIX extension in place of the old
	getenv primitive (note, though, that unix-getenv must be called
	with a string; it doesn't accept a symbol).

     o  The `linkscheme' shell script gets installed into a different
	directory (lib) now and works in a slightly different way.
	The `linkext' script is now called lib/makedl.  `init_objects'
	is gone; see INSTALL for a new mechanism to link extensions
	with the interpreter statically.


Changes in release 2.1:

     o  The library libutil.a (which was part of the default libraries
	in earlier versions) has been removed; the code has been
	integrated into the interpreter kernel.

	If you have pre-linked dynamically loadable extensions against
	this library or against object files in lib/misc, just remove
	the relevant commands from your Makefiles.

     o  The semantics of the Truep() macro have changed; the empty
        list no longer counts as false (see comment in CHANGES).


Changes in release 2.0:

     o  The Elk include file "scheme.h" now is in a different directory
	(include), so you have to change the -I option in your Makefiles.

     o  <errno.h> is no longer included by "scheme.h", so you have
	to include it in your extensions if it is required.

     o  lib/string.h is included automatically if you include scheme.h.

     o  It is no longer necessary to pre-link extensions against
	lib/util/objects.o or lib/util/symbol.o.  The files now are in
	a library (libutil.a); extensions are linked against this
	library automatically when they are loaded into Elk.

     o  The way new Scheme objects are allocated has changed as a
	side-effect of adding the necessary hooks for the generational
	garbage collector (which is not yet present in Elk 2.0).
	
	The function Get_Bytes has been replaced by the new function
	Alloc_Object.  Alloc_Object already returns a Scheme `Object';
	there is no need to use SET any longer.  The arguments are the
	object's size in bytes, the type, and a flag indicating whether
	the object is constant (constant objects may be placed into a
	read-only portion of the memory in later versions of Elk).

	So you have to replace old code to allocate an object of type
	T_Foo that looked like this:

	   Object o;  char *p;

	   p = Get_Bytes (sizeof (struct S_Foo));
	   SET(o, T_Foo, (struct S_Foo *)p);

	by this:

	    Object o = Alloc_Object (sizeof (struct S_Foo), T_Foo, 0);

	(use 1 instead of 0 if the new object is considered immutable).

     o  If you store weak pointers to objects and forward the pointers
	explicitly in an after-GC function, you are now required to use
	a set of new macros.  See src/terminate.c and lib/util/objects.c
	for examples.

     o  The empty list is no longer regarded as false.  To simplify
	testing, you can evaluate

	   (empty-list-is-false-for-backward-compatibility #t)

	to enable the old (no longer standard-conforming) semantics.
	A call to this function with an argument of #f reverts to
	the default behavior.