ANNOUNCE

Subject: [announce] Vicare Scheme revision 0.4.1-devel.3

                             Vicare Scheme
                             =============


Vicare Scheme is an R6RS compliant fork of Ikarus Scheme, aiming to be a
native compiler for R6 Scheme producing single threaded programs running
on  Intel x86  32-bit  and  64-bit processors.   It  is  tested only  on
GNU+Linux;  it  should work  on  POSIX  platforms,  but not  on  Cygwin.
"Vicare" is pronounced the etruscan way.

  The latest release tarball of this package can be downloaded from:

       <https://bitbucket.org/marcomaggi/vicare-scheme/downloads>

the home page of the Vicare project is at:

	       <http://marcomaggi.github.io/vicare.html>

development takes place at:

                 <http://github.com/marcomaggi/vicare/>

and as backup at:

	   <https://bitbucket.org/marcomaggi/vicare-scheme/>


Notes for revision 0.4.1-devel.3
--------------------------------

* Fixes issue #97.

* Minor improvements in core primitives acting on booleans.


Notes for revision 0.4d1.2
--------------------------

* Fixes issue #96.


Notes for revision 0.4d1.1
--------------------------

* Fixes issue #94.


Notes for revision 0.4d1
------------------------

* With this  tag the project  is starting  to favour the  typed language
  over the standard one.


Notes for revision 0.4d0
------------------------

This project  is no  more hosted  at SourceForge  and Gitorious.   It is
still hosted at Github and newly hosted at Bitbucket.

  Lots of backwards incompatibilities... life is hard!

* The boot images have been rotated.

* The package is  now using a single,  big, all-inclusive "Makefile.am".
  Building the  package is  probably slower then  before.  Using  the -j
  option of "make" helps  a bit; I am not sure  it can rebuild reliably,
  but it should.

* BACKWARDS INCOMPATIBILITY Ikarus is no more.  The library (ikarus) and
  the  libraries in  the  hierarchy  (ikarus system  ---)  do not  exist
  anymore.

* BACKWARDS  INCOMPATIBILITY  The   libraries  infrastructure  has  been
  completely overhauled.  There are too  many changes to list them here,
  we must  read the relevant documentation;  system environment variable
  names and  command line  option names have  changed too  (sorry).  The
  most important stuff:

  - Version numbers are supported.  If,  while scanning the search path,
    a  library is  loaded  and its  version number  does  not match  the
    requested  version  reference: that  library  is  discarded and  the
    search goes on.

  - The library (vicare) now has a version number; the full library name
    is:

       (vicare (0 4 ?year ?month ?day))

    where ?YEAR,  ?MONTH and ?DAY  are fixnums representing the  date of
    the last build.

  - The default of this package (and  in future for all the other Vicare
    packages) is to  install only the FASL files, and  leave the sources
    uninstalled; to install also the  source libraries we must configure
    with:

       $ configure --enable-sources-installation ...

  - When running  "make all" from  the build directory of  this package:
    the libraries are compiled.

  - Previously  there  were   2  file  extensions  for   FASL  files  to
    distinguish a 32-bit build from a 64-bit build:

       .vicare-32bit-fasl
       .vicare-64bit-fasl

    there  is now  a single  FASL  file extension:  ".fasl".  We  should
    arrange  the  package configuration  to  install  32-bit FASL  files
    under:

       $(prefix)/lib/vicare-scheme

    and 64-bit FASL files under:

       $(prefix)/lib64/vicare-scheme

   - Caching of libraries compiled  on-the-fly (under "~/.vicare") is no
     more supported.

  See the  documentation nodes  "using libraries" and  "libutils".  Most
  likely this code needs to be ironed out.

* BACKWARDS INCOMPATIBILITY  The bindings that deal  with library names,
  library references, search paths and  related stuff have been moved to
  the  library (vicare  libraries),  which is  implemented  by the  boot
  image; such  bindings are no  more reexported by  (vicare), (nausicaa)
  and (nausicaa  mehve).  The relevant  documentation has been  moved to
  the node "libutils".

* BACKWARDS INCOMPATIBILITIES Removed undocumented libraries exported by
  the boot image:

     (chez modules)
     (ikarus symbols)
     (ikarus parameters)

* BACKWARDS INCOMPATIBILITY The library (vicare $posix) has been renamed
  to (vicare language-extensions $posix).

* Added     documentation     for    the     previously     undocumented
  MAKE-COMPILE-TIME-VALUE  and  a  general  explanation of  how  to  use
  compile-time values.  See the documentation node "iklib expander ctv".

* Added syntax  SPLICE-FIRST-EXPAND to (vicare).  See  the documentation
  node "iklib syntaxes splice1st" for details.

* BACKWARDS INCOMPATIBILITY  Nausicaa's support for  experimental nested
  method invocation added  in release 0.3d7 has been removed.   It is no
  more  possible  to use  the  auxiliary  syntax  "=>" to  nest  members
  invocation:

    (define-label <alpha>
      (method ((one <list>) self a b)
        (list self a b)))

    (let (((O <alpha>) 0))
      (O one 10 20
         => map add1)) ;;; ERROR

* It  makes  no   sense  to  develop  Vicare  Scheme  if   it  does  not
  differentiate itself from other  implementations; so with this release
  a somewhat bold syntax is introduced  for the Nausicaa language on top
  of SPLICE-FIRST-EXPAND.

    Whenever an expression  in OOPP syntax appears as  first subform, it
  has a single return value and  such return value is tagged: the result
  of its expansion is spliced in  the enclosing form; this allows a more
  natural OOP--like syntax to access field's tag members.  It is clearly
  not ``Schemey''.  Here are some examples:

     (<spine> L '(0 1 2 3 4))

     (L car)				=> 0
     (L cdr)				=> (1 2 3 4)
     ((L cdr) car)			=> 1
     ((L cdr) cdr)			=> (2 3 4)
     (((L cdr) cdr) car)		=> 2
     (((L cdr) cdr) cdr)		=> (3 4)
     ((((L cdr) cdr) cdr) car)		=> 3
     ((((L cdr) cdr) cdr) cdr)		=> (4)
     (((((L cdr) cdr) cdr) cdr) car)	=> 4
     (((((L cdr) cdr) cdr) cdr) cdr)	=> ()

  more details  in node  "oopp notation  nesting" of  documentation file
  "nausicaa.*".

* BACKWARDS INCOMPATIBILITY For those who  care about Nausicaa (if any):
  sorry  to introduce  this  backwards  incompatibility.  The  predicate
  syntax:

    (<tag>)			==> #<predicate function>

  is no more supported.  To retrieve  the predicate function of a tag we
  can now use the "#:predicate" keyword:

    (<fixnum> #:predicate)	=> fixnum?

  and we can also directly apply the predicate function to the result of
  an expression with the keyword "#:is-a?":

    (<fixnum> #:is-a? 123)	=> #t
    (<fixnum> #:is-a? "123")	=> #f

  the "is-a?" syntax is still available:

    (is-a? 123 <fixnum>)	=> #t
    (is-a? "123" <fixunm>)	=> #f

* A  new "cast"  syntax replaces  the old  predicate syntax.   It is  as
  follows:

     ((?tag) ?expr)

  whenever this  syntax appears as  first subform of an  enclosing form,
  the following chain of expansions takes place:

     (((?tag) ?expr) ?arg ...)
     ==> ((?tag #:nested-oopp-syntax ?expr) ?arg ...)
     ==> (?tag #:oopp-syntax (?expr ?arg ...))

  otherwise the expansion is just:

     ((?tag) ?expr)
     ==> ?expr

    This syntax allows expressions like:

     ((<fixnum>) 123)		=> 123
     (((<fixnum>) 123) add1)	=> 124
     (((<fixnum>) 123) <= 200)	=> #t
     (((<fixnum>) 123) <= 100)	=> #f

* If the maker syntax is used as first subform of an enclosing form, the
  nested OOPP syntax is available.

     ((<pair> (1 2)) car)	=> 1
     ((<pair> (1 2)) cdr)	=> 2

* Added documentation to explain that the following is a perfectly valid
  Vicare program:

     (import (vicare))
     (let ()
       (library (ciao)
         (export a)
         (import (rnrs))
         (define a 1))
       (library (hello)
         (export b)
         (import (rnrs))
         (define b 1))
       (import (ciao))
       (import (hello))
       (display (list a b)))

* Added struct related bindings to (vicare):

     struct-type-descriptor?
     struct-type-and-struct?
     struct-type-field-ref
     struct-type-field-set!
     $struct-type-field-ref
     $struct-type-field-set!

* Extended  RECORD-ACCESSOR  and  RECORD-MUTATOR  to  accept  as  second
  argument either  a relative field  index, as  specified by R6RS,  or a
  symbol representing a  field's name.  In the second case:  the RTD and
  its parents are  searched for the first  matching field specification,
  so    fields    of    the   sub-types    take    precedence.     Added
  UNSAFE-RECORD-ACCESSOR and UNSAFE-RECORD-MUTATOR to (vicare).

* Modified syntax TYPE-DESCRIPTOR to work  on both struct type names and
  R6RS record type names:

     (define-struct color
       (red green blue))

     (type-descriptor color)		=> #<color rtd>

     (define-record-type color1
       (fields red green blue))

     (type-descriptor color1)		=> #[rtd name=color1]

* BACKWARDS INCOMPATIBILITY The  identifier STRUCT-TYPE-DESCRIPTOR is no
  more  an   alias  of   STRUCT-RTD;  instead  it   is  a   syntax  like
  RECORD-TYPE-DESCRIPTOR for structs:

     (define-struct color
       (red green blue))

     (struct-type-descriptor color)	=> #<color rtd>

* Added syntax IS-A? to (vicare):

     (import (vicare))
     (define-struct doublet
       (a b))
     (define-record-type triplet
       (fields a b c))
     (is-a? (make-doublet 1 2) doublet)		=> #t
     (is-a? (make-triplet 1 2 3) triplet)	=> #t
     (is-a? 123 triplet)			=> #f

    Notice  that this  syntax  is re-exported  by  (nausicaa): the  tags
  defined by Nausicaa now interface themselves with IS-A? from (vicare).

* Added syntaxes SLOT-REF, SLOT-SET!, $SLOT-REF, $SLOT-SET! to (vicare);
  they work on both Vicare structs:

    (define-struct color
      (red green blue))
    (define S
      (make-color 1 2 3))
    (slot-set! S red   color 19)
    (slot-set! S green color 29)
    (slot-set! S blue  color 39)
    (slot-ref S red   color)		=> 19
    (slot-ref S green color)		=> 29
    (slot-ref S blue  color)		=> 39

  and R6RS records:

    (define-record-type color
      (fields (mutable red)
              (mutable green)
              (mutable blue)))
    (define S
      (make-color 1 2 3))
    (slot-set! S red   color 19)
    (slot-set! S green color 29)
    (slot-set! S blue  color 39)
    (slot-ref S red   color)		=> 19
    (slot-ref S green color)		=> 29
    (slot-ref S blue  color)		=> 39

    Notice that the syntaxes SLOT-REF  and SLOT-SET!  are re-exported by
  (nausicaa): the tags defined by Nausicaa now interface themselves with
  these syntaxes.

* Modified syntactic  bindings of  Vicare struct  types and  R6RS record
  types to  allow the identifier name  to act as reference  to the maker
  function with a special syntax; that is, for struct types:

     (define-struct color
       (red green blue))

     (color (1 2 3))			=> #["color" 1 2 3]
     (apply (color (...)) 1 '(2 3))	=> #["color" 1 2 3]

  and for R6RS record types:

     (define-record-type color
       (fields red green blue))

     (color (1 2 3))
     => #[r6rs-record: color red=1 green=2 blue=3]

     (apply (color (...)) 1 '(2 3))
     =>  #[r6rs-record: color red=1 green=2 blue=3]

* Added some experimental functions to (vicare):

    syntactic-binding-putprop
    syntactic-binding-getprop
    syntactic-binding-remprop
    syntactic-binding-property-list
    identifier-bound?

* Added experimental syntax DEFINE-ALIAS to (vicare):

    (let ((a 1))
      (define-alias b a)
      b)

  not sure if  it is a good  thing.  Should the full  suite of LET-ALIAS
  and LET*-ALIAS syntaxes be added?

* Added syntax  parameters.  See the documentation  node "iklib expander
  parameters".

* BACKWARDS  INCOMPATIBILITY The  identifier  "__who__" is  now a  fluid
  syntax exported by (vicare).  This change should not cause significant
  problems: most of the code should just work.

* BEGIN-FOR-SYNTAX is  now an  alias for  EVAL-FOR-EXPAND, to  match the
  syntax name used by Racket; in  truth: EVAL-FOR-EXPAND is now an alias
  of BEGIN-FOR-SYNTAX.

* BACKWARDS INCOMPATIBILITY  BEGIN-FOR-SYNTAX is  now a core  syntax and
  allows bindings to be defined in a form and referenced in a later one:

     (begin-for-syntax
       (define a 1))

     (begin-for-syntax
       (define b 2))

     (begin-for-syntax
       (define c (+ a b)))

     (define-syntax (doit stx)
       #`(quote (#,a #,b #,c)))

     (doit)	=> (1 2 3)

  this behaviour was not present in the previous EVAL-FOR-EXPAND.

* Added synonym syntax transformers.

* Extended LIBRARY form with OPTIONS clause.  Implemented library option
  VISIT-UPON-LOADING.

* BACKWARDS  INCOMPATIBILITY The  libraries in  the hierarchy  (nausicaa
  mehve ---)  do not  need to be  initialised anymore;  the INITIALISE-*
  functions are not exported anymore.

* BACKWARDS INCOMPATIBILITY The syntax  CASE-IDENTIFIERS is now exported
  by  (vicare), and  not  more exported  by (vicare  language-extensions
  syntaxes).

* It is  now possible to  compile individual library files,  producing a
  single FASL file;  one FASL file for each LIBRARY  form.  To write the
  FASL file to the repository:

     $ vicare --compile-library libname.sls

  the explicitly select an output file name:

     $ vicare \
        --output libname.vicare-64bit-fasl \
        --compile-library libname.sls

* Added  command  line  options  --verbose and  --silent.   By  default:
  execution is now silent.

* BACKWARDS  INCOMPATIBILITY  The  third   (and  optional)  argument  of
  EXPAND-LIBRARY now must be a function accepting a R6RS library name as
  single argument.

* Added port predicates to (vicare):

    binary-input-port?			textual-input-port?
    binary-output-port?			textual-output-port?
    binary-input/output-port?		textual-input/output-port?

* Added identifier  syntaxes "__file__" and "__line__"  to (vicare); the
  former expands to a string  representing the source code location; the
  latter expands to a number representing the line number.

* BACKWARDS INCOMPATIBILITY The following libraries have been removed:

     (vicare language-extensions identifier-alists)
     (vicare language-extensions identifier-properties)

* Added BRACE to (vicare) and brace lists to the reader.  A fluid syntax
  which  is free  to be  bound to  whatever user  code needs.   When the
  Scheme code  reader is in Vicare  mode: brace lists are  read as BRACE
  forms as follows:

     {}			-> (brace)
     {1 2 3}		-> (brace 1 2 3)
     {1 . 2}		-> (brace 1 . 2)

* The library (vicare) now exports the TRY syntax; see the documentation
  node "iklib syntaxes try".

* The syntaxes LAMBDA*, DEFINE*,  CASE-LAMBDA*, CASE-DEFINE* now use the
  brace  syntax  to  tag  argument and  return  values  with  validation
  predicates.

* The following libraries do not exist anymore:

     (vicare language-extensions infix)
     (vicare language-extensions increments)

* The INFIX syntax  is now exported by (vicare).   See the documentation
  for the syntax and supported operators.

* New fluid syntax bindings are exported by (vicare):

    ? : ! % & ^ ~ << >> ¦

  they are recognised as operators by the INFIX syntax.

* BACKWARDS INCOMPATIBILITY In the library (vicare posix), the structure
  "struct-stat"  has   now  fields  for  file   times  with  nanoseconds
  resolution; they  are used  whenever the underlying  platform supports
  them.  The field names are now:

     st_atime_nsec
     st_mtime_nsec
     st_ctime_nsec

  and the fields with microseconds resolution:

     st_atime_usec
     st_mtime_usec
     st_ctime_usec

  do not exist anymore.

* BACKWARDS  INCOMPATIBILITY The  command  line  options regarding  open
  mvcalls have been removed.

* BACKWARDS  INCOMPATIBILITY The  command line  options about  reporting
  errors at run-time or compile-time have been removed.

* BACKWARDS  INCOMPATIBILITY  Removed  non-Scheme  style  syntaxes  from
  (vicare):

    begin-returnable
    lambda-returnable
    define-returnable

  added:

    returnable


Notes for revision 0.3d7
------------------------

* Boot images have been rotated.

* Added unsafe operations to (vicare system $vectors):

    $vector-map1
    $vector-for-each1
    $vector-for-all1
    $vector-exists1

* Added convenience syntax CASE-DEFINE to (vicare).

    (case-define who ?cl-clause0 cl-clause ...)
    ==> (define who (case-lambda ?cl-clause0 ?cl-clause ...))

* Added to (vicare) the syntaxes:

    let-constants
    let*-constants
    letrec-constants
    letrec*-constants

  like LET, LET*, LETREC, LETREC* but create immutable bindings.

* Added  to   (vicare)  the  experimental  syntaxes   LAMBDA*,  DEFINE*,
  CASE-LAMBDA*,  CASE-DEFINE*.   See   the  documentation  nodes  "iklib
  syntaxes lambdas" and "iklib syntaxes defines".

* Added  to  (vicare)  BYTEVECTOR-HASH   using  the  same  algorithm  of
  STRING-HASH.

* When  the syntax  DEFINE/TAGS  from (nausicaa)  is  used for  function
  definition, the body forms are enclosed in a LET syntax as follows:

    (let-constants ((__who__ (quote ?id))) ?body0 ?body ...)

  so the binding "__who__" is available in the body forms to reference a
  symbol representing the  function's name; this is  useful when raising
  exceptions with  condition type "&who".  Such  non-hygienic definition
  looks  non-Schemey, but  in  many  places in  the  code  there is  the
  pattern:

    (define (doit . args)
      (define who 'doit)
      ---)

  to make the  name of the function available; such  definitions can now
  be cleared.

* Added  CASE-DEFINE to  (nausicaa)  and  CASE-DEFINE/TAGS to  (nausicaa
  language oopp).

* Added   experimental  nested   method  invocation.    When  a   method
  specification has a  single tagged return value,  the following syntax
  is available:

    (define-label <alpha>
      (method ((one <list>) self a b)
        (list self a b)))

    (let (((O <alpha>) 0))
      (O one 10 20
         => map add1))		=> '(1 11 21)

    (let (((O <alpha>) 0))
      (O one 10 20
         => map add1
         => fold-left 0 +))	=> (+ 1 11 21)

    (let (((O <alpha>) 0))
      (O one 10 20
         => map add1
         => map -
         => fold-left 0 +))	=> (+ -1 -11 -21)

  This is not Schemey at all, but many languages have similar syntaxes.

* Added experimental nested getter syntax.  The getter transformer might
  accept additional  forms to  use tag members  from the  runtime getter
  value.

    (define-label <fixnum-vector>
      (parent <vector>)
      (getter
       (lambda (stx)
         (syntax-case stx (=>)
           ((?var ((?index)))
            #'(vector-ref ?var ?index))
           ((?var ((?index)) => ?form0 ?form ...)
            #'(let (((fx <fixnum>) (?var[?index])))
                (fx ?form0 ?form ...)))
           ))))

    (let (((O <fixnum-vector>) '#(0 1 2 3)))
      (O[1] => string))
    => "1"

    (let (((O <fixnum-vector>) '#(0 1 2 3)))
      (O[1] => odd?))
    => #t

    (let (((O <fixnum-vector>) '#(0 1 2 3)))
      (O[2] => * 10))
    => 20

* BACKWARDS  INCOMPATIBILITY  In  the   (nausicaa)  language,  the  "<-"
  auxiliary  syntax is  no  more used  by  DEFINE/TAGS, LAMBDA/TAGS  and
  CASE-LAMBDA/TAGS to  specify validation tags for  returned values.  So
  these are now syntax errors:

    (define fun
      (lambda ((O <pair>))
        (<- <vector>)
        (vector (O car) (O cdr))))

    (define (fun (O <pair>))
      (<- <vector>)
      (vector (O car) (O cdr)))

    (define fun
      (case-lambda
       (((O <pair>))
        (<- <vector>)
        (vector (O car) (O cdr)))))

  we can use the following instead:

    (define fun
      (lambda ((_ <vector>) (O <pair>))
        (vector (O car) (O cdr))))

    (define ((fun <vector>) (O <pair>))
      (vector (O car) (O cdr)))

    (define fun
      (case-lambda
       (((_ <vector>) (O <pair>))
        (vector (O car) (O cdr)))))

* BACKWARDS  INCOMPATIBILITY Some  parser  functions for  IPv4 and  IPv6
  addresses from the hierarchy (nausicaa  parser-tools ---) now return a
  vector rather than a list.

* BACKWARDS INCOMPATIBILITY Some constructor functions for IPv4 and IPv6
  address labels  from the  hierarchy (nausicaa  net addresses  ---) now
  accept a vector as argument rather than a list.

* BACKWARDS INCOMPATIBILITY The function URI-NORMALISE-ENCODING has been
  renamed to NORMALISE-URI-ENCODING.

* BACKWARDS INCOMPATIBILITY The libraries for parsing IP addressing have
  been reorganised and partly rewritten.

* Imported URI libraries from Nausicaa as:

     (nausicaa parser-tools uri ---)
     (nausicaa uri ---)

* Imported file system pathname libraries from Nausicaa as:

     (nausicaa parser-tools unix-pathnames)
     (nausicaa uri pathnames ---)

* Imported the Mehve language.  A new master documentation file has been
  added, "mehve.texi".


Notes for revision 0.3d6
------------------------

* Added libraries:

    (nausicaa language simple-match)
    (nausicaa language infix)

  with  similar API  of  the corresponding  libraries  in the  hierarchy
  (vicare ---),  but recognising  identifiers exported by  the libraries
  in the hierarchy (nausicaa language ---) as auxiliary syntaxes.

* Imported IPv4 and IPv6 address libraries from Nausicaa as:

    (nausicaa parser-tools ipv4-addresses)
    (nausicaa parser-tools ipv6-addresses)
    (nausicaa net addresses ipv4)
    (nausicaa net addresses ipv6)

* Added LET*-SYNTAX to (vicare):

    (let*-syntax () ?body)
    ==> (begin () ?body)

    (let*-syntax ((?lhs ?rhs)) ?body)
    ==> (let-syntax ((?lhs ?rhs)) ?body)

    (let*-syntax ((?lhs0 ?rhs0) (?lhs ?rhs) ...) ?body)
    ==> (let-syntax ((?lhs0 ?rhs0))
          (let*-syntax ((?lhs ?rhs) ...) ?body))


Notes for revision 0.3d5
------------------------

* The boot images have been rotated.

* BACKWARDS INCOMPATIBILITY  The function  MAKE-QUEUE from  (vicare) has
  been renamed MAKE-QUEUE-PROCS.

* Imported libraries  from Nausicaa/OOPP.   Installation of  the library
  hierarchy (nausicaa  ---) is  enabled by default;  it can  be disabled
  with the option "--disable-nausicaa" of the script "configure".

* Documentation  is  now  split   into  3  files:  "vicare-scheme.texi",
  "vicare-libs.texi", "nausicaa.texi".

* Added   condition  object   type  "&procedure-argument-violation"   to
  (vicare).

* Added  condition object  type "&expression-return-value-violation"  to
  (vicare).

* The validation  clauses of  the library (vicare  arguments validation)
  now use  PROCEDURE-ARGUMENT-VIOLATION to raise the  error, rather than
  ASSERTION-VIOLATION.

* Added  syntaxes to  (vicare) to  allow  access to  R6RS record  fields
  through the record type identifier only.

     record-type-field-ref
     record-type-field-set!
     $record-type-field-ref
     $record-type-field-set!

* Added syntax  "record-type-and-record?" to  (vicare) to  allow testing
  the type of a record instance through the record type identifier only.

* Added to (vicare):

    exact-integer?
    bignum-positive?
    bignum-negative?
    bignum-non-negative?
    bignum-non-positive?
    bignum-odd?
    bignum-even?
    least-positive-bignum
    greatest-negative-bignum

* Added  to (vicare)  the experimental  syntax "define-syntax*".   Still
  undocumented.

* Added to (vicare)  the function "vector-empty?" and  to (vicare system
  $vectors) the operation "$vector-empty?".

* Added to (vicare)  the function "string-empty?" and  to (vicare system
  $strings) the operation "string-empty?".

* Added  to (vicare)  the function  "bytevector-empty?"  and  to (vicare
  system $bytevectors) the operation "$bytevector-empty?".

* Added "eval-for-expand" to (vicare).

* Added to (vicare system $numerics):

    $add1-integer	$add1-fixnum	$add1-bignum
    $sub1-integer	$sub1-fixnum	$sub1-bignum

* Fixes,  reorganisation  and  development   of  string  and  bytevector
  pathname functions.  Added to (vicare $posix):

    split-pathname-root-and-tail
    search-file-in-environment-path
    search-file-in-list-path
    split-pathname
    split-pathname-bytevector
    split-pathname-string
    split-search-path
    split-search-path-bytevector
    split-search-path-string
    file-absolute-pathname?
    file-relative-pathname?
    file-pathname?
    file-string-pathname?
    file-bytevector-pathname?
    file-colon-search-path?
    file-string-colon-search-path?
    file-bytevector-colon-search-path?

  which are reexported by (vicare posix).

* Added special validation clause:

    (or false ?validator)

  to the arguments validation library.

* Added library (vicare language-extensions increments).

* Added to Nausicaa classes a syntax to select concrete fields using the
  R6RS records' unsafe accessors and mutators.

* Added to  Nausicaa the  validation of values  returned by  code forms,
  through "begin/tags", "lambda/tags" and "define/tags".

* Added builtin label "<exact-integer>" to (nausicaa).

* Added containers libraries:

     (nausicaa containers lists)
     (nausicaa containers vectors)
     (nausicaa containers strings)
     (nausicaa containers arrays)

  the multidimensional arrays library will  be rewritten with changes in
  the API.

* Added INFIX to the export list of (nausicaa).

* The wrapper  for foreign pointers  now defines also  a "?TYPE-ID-hash"
  function to generate hashtable keys associated to wrapper structures.

* Imported from Nausicaa the libraries:

     (vicare language-extensions identifier-alists)
     (vicare language-extensions identifier-properties)
     (vicare language-extensions makers)

* Imported stacks library from Nausicaa as libraries:

     (vicare containers stacks)
     (nausicaa containers stacks)

* Imported queues library from Nausicaa as libraries:

     (vicare containers queues)
     (nausicaa containers queues)

* Imported iterators library from Nausicaa as:

     (nausicaa containers iterators)

* Imported SILex libraries from Nausicaa as:

     (vicare parser-tools silex ---)

* Imported LALR libraries from Nausicaa as:

     (nausicaa parser-tools lalr ---)


Notes for revision 0.3d4
------------------------

* Strings  loaded from  FASL  files (but  not the  boot  image) are  now
  interned.

* Added CASE-IDENTIFIERS to (vicare langauge-extensions syntaxes).

* Added   callable  objects   as  library   (vicare  language-extensions
  callables), see the documentation node "callables".

* Added environment inquiry functions to (vicare):

    uname
    utsname?
    utsname-sysname
    utsname-nodename
    utsname-release
    utsname-version
    utsname-machine

    implementation-name
    implementation-version
    cpu-architecture
    machine-name
    os-name
    os-version

* Added SRFI 112 libraries:

    (srfi :112)
    (srfi :112 environment-inquiry)

* Imported one-dimension  libraries from Nausicaa as  (vicare containers
  one-dimension-cc) and (vicare containers one-dimension-co).

* Imported  u8 and  s8  bytevectors libraries  from  nausicaa under  the
  hierarchy (vicare containers bytevectors ---).

* Imported getopts library from Nausicaa as (vicare getopts).

* Imported    enumerations   library    from    Nausicaa   as    (vicare
  language-extensions c-enumerations).

* Imported formations library from Nausicaa as (vicare formations).


Notes for revision 0.3d3
------------------------

* Added to (vicare) functions to inspect configuration time options:

    vicare-built-with-srfi-enabled
    vicare-built-with-ffi-enabled
    vicare-built-with-iconv-enabled
    vicare-built-with-posix-enabled
    vicare-built-with-glibc-enabled
    vicare-built-with-linux-enabled

  and to (srfi :0) the associated COND-EXPAND clauses:

    srfi-enabled
    ffi-enabled
    iconv-enabled
    posix-enabled
    glibc-enabled
    linux-enabled

* Added  utility functions  for macro  authoring, see  the documentation
  node "iklib expander utils".

* Added miscellaneous functions to (vicare):

     char-in-ascii-range?
     fixnum-in-character-range?

* Fixed (vicare language-extensions infix) exporting its own binding for
  XOR; it now reexports the binding from (vicare).

* Added libraries:

    (srfi :111)
    (srfi :111 boxes)

* SRFI 106:  added function  SOCKET-DESCRIPTOR; added  garbage collector
  destructor to the socket object.

* BACKWARDS INCOMPATIBILITY  The library  (vicare bytevectors)  has been
  renamed to (vicare containers bytevectors).

* Fixed error in weak hashtables not handling correctly already interned
  keys.

* Imported IrRegex from Nausicaa as (vicare irregex).

* Imported Pregexp from Nausicaa as (vicare pregexp).

* Imported    variables    library     from    Nausicaa    as    (vicare
  language-extensions variables).

* Imported lists library from Nausicaa as (vicare containers lists).

* Imported vectors library from Nausicaa as (vicare containers vectors).

* Imported strings library from Nausicaa as (vicare containers strings).

* Imported  char-sets  library  from   Nausicaa  as  (vicare  containers
  char-sets).

* Imported   KMP   library   from   Nausicaa   as   (vicare   containers
  knuth-morris-pratt).

* Imported  Levenshtein  Distance  library   from  Nausicaa  as  (vicare
  containers levenshtein).

* Imported streams library from  Nausicaa as (vicare language-extensions
  streams).

* Imported loops  library from  Nausicaa as  (vicare language-extensions
  loops).

* Imported   ASCII    chars   library    from   Nausicaa    as   (vicare
  language-extensions ascii-chars).

* Imported    comparisons    library    from   Nausicaa    as    (vicare
  language-extensions comparisons).

* Imported  randomisations libraries  from  Nausicaa  as (vicare  crypto
  randomisations ---).

* Imported object-properties library from Nausicaa as (vicare containers
  object-properties).

* Imported hooks  library from  Nausicaa as  (vicare language-extensions
  hooks).


Notes for revision 0.3d2
------------------------

* Fixed some errors reported by Goran Weinholt.

* Added libraries:

    (srfi :106)
    (srfi :106 socket)


Notes for revision 0.3d1
------------------------

* Miscellaneous error fixes.  A new demonic error revealed itself: issue
  #49; the temporary  workaround is to turn off the  optimiser using the
  command line option "-O0".

* BACKWARDS    INCOMPATIBILITY   The    syntaxes   CASE-WORD-SIZE    and
  CASE-ENDIANNESS  are  now exported  by  the  library (vicare  platform
  words)  rather   than  by  the  library   (vicare  language-extensions
  syntaxes).

* BACKWARDS INCOMPATIBILITY  The unsafe  accessors and mutators  of R6RS
  records are generated  by default by DEFINE-RECORD-TYPE,  but they are
  no more created when the command line option "--strict-r6rs" is used.

* Added arguments validation clauses to (vicare arguments validation):

     GENERAL-C-STRING*/FALSE
     GENERAL-C-BUFFER*/FALSE
     GENERAL-C-STICKY-BUFFER*/FALSE

* Modified ADD-RESULT in (vicare checks) to return its argument.

* DEFINE-SYNTAX now accepts the syntax:

    (define-syntax ?name)
    ==> (define-syntax ?name (syntax-rules ()))

  in addition to the R6RS one and the previously added:

    (define-syntax (?name ?arg) ?body0 ?body ...)
    ==> (define-syntax ?name (lambda (?arg) ?body0 ?body ...))

* The MATCH  syntax from  (vicare language-extensions  simple-match) now
  accepts a  SYNTAX pattern  which works  almost like  the pattern  of a
  SYNTAX-CASE use.

* Fixed bug preventing loading of  libraries with version numbers in the
  name.

* The  syntax ENDIANNESS  now  accepts also  the  symbols "network"  and
  "native"; the former  is automatically converted to  "big", the latter
  to the return value of "(native-endianness)".

* Added functions to (vicare):

     NON-NEGATIVE?
     NON-POSITIVE?

  and unsafe operations to (vicare system $fx):

     $fxnonpositive?
     $fxnonnegative?

  to (vicare system $flonums):

     $flnonpositive?
     $flnonnegative?

  to (vicare system $ratnums):

     $ratnum-positive?
     $ratnum-negative?
     $ratnum-non-positive?
     $ratnum-non-negative?

  to (vicare system bignums):

     $bignum-non-positive?
     $bignum-non-negative?

* Added functions to (vicare):

     string-or-symbol->string
     string-or-symbol->symbol

* Added constants definitions to library (vicare platform constants):

  - from "/usr/include/netinet/in.h": IPPROTO_*, IPPORT_*
  - from "/usr/include/netinet/tcp.h": *TCP*
  - from "/usr/include/netinet/udp.h": *UDP*

  and others related to networking.

* Added the following bindings to (vicare posix):

     sockaddr_in.in_addr.number
     tcp-connect/binary

* Added the following bindings to (vicare glibc):

     IN_CLASSA				IN_CLASSB
     IN_CLASSC				IN_CLASSD
     IN_MULTICAST			IN_EXPERIMENTAL
     IN_BADCLASS
     IN6_IS_ADDR_UNSPECIFIED		IN6_IS_ADDR_LOOPBACK
     IN6_IS_ADDR_LINKLOCAL		IN6_IS_ADDR_SITELOCAL
     IN6_IS_ADDR_V4MAPPED		IN6_IS_ADDR_V4COMPAT
     IN6_IS_ADDR_MULTICAST		IN6_IS_ADDR_MC_NODELOCAL
     IN6_IS_ADDR_MC_LINKLOCAL		IN6_IS_ADDR_MC_SITELOCAL
     IN6_IS_ADDR_MC_ORGLOCAL		IN6_IS_ADDR_MC_GLOBAL
     IN6_ARE_ADDR_EQUAL
     bindresvport			bindresvport6

* Added Ethernet address manipulation routines to (vicare linux):

    ether-ntoa                  ether-aton              ether-ntoa/string
    ether-ntoa-r                ether-aton-r            ether-ntoa-r/string
    ether-ntohost               ether-hostton           ether-ntohost/string
    ether-line                  ether-line/string

* Added library (vicare bytevectors).

* Added library (vicare language-extensions sentinels).

* Added library (vicare language-extensions namespaces).

* Texinfo  files  representing  the  revised  R6RS  standard  have  been
  imported   from  Nausicaa/Scheme   and   are  now   included  in   the
  documentation.


Notes for revision 0.3d0
------------------------

* The version  number has been  bumped to 0.3: this  revision introduces
  backwards INcompatible changes that will force upgrading of almost all
  the packages binding Vicare to foreign libraries.

* The boot images have been rotated.

* Issue 39 should be fixed.

* Changed tarball distribution from .bz2 compression to .xz compression.

* Added command line option -g as alias for --debug.

* Added command line option -F as alias for --fasl-path.

* The  script "configure"  and the  makefiles accept  the user  variable
  VFLAGS  to  set  command  line options  for  "vicare"  when  compiling
  libraries and  running the test  suite.  VFLAGS is  to be used  in the
  same way of CFLAGS for the C compiler.

* Some changes to attempt a fix  for Issue #35 have been implemented see
  "doc/QUEST-FOR-ISSUE-35".

* SRFI 19,  time and date functions,  has been reverted to  the original
  Eddington's port.

* BACKWARDS INCOMPATIBILITY The iconv functions have been moved from the
  library (vicare glibc) into the library (vicare iconv).  Documentation
  and tests also have been moved into modules independent from the Glibc
  ones.

* BACKWARDS  INCOMPATIBILITY  The  following C  functions  have  changed
  signature:

      void ik_enter_c_function (ikpcb* pcb);
      void ik_leave_c_function (ikpcb* pcb);

  which means the  extensions of Vicare binding it  to foreign libraries
  have to be fixed.

* BACKWARDS INCOMPATIBILITY The  library:

     (vicare platform-constants)

  has been removed; use (vicare platform constants) instead.

* BACKWARDS INCOMPATIBILITY The following libraries:

     (vicare installation-configuration)
     (vicare words)
     (vicare errno)
     (vicare unsafe-operations)
     (vicare unsafe-unicode)
     (vicare unsafe-capi)
     (vicare infix)
     (vicare keywords)
     (vicare syntactic-extensions)
     (vicare flonum-formatter)
     (vicare flonum-parser)
     (vicare weak-hashtables)
     (vicare simple-event-looop)

  have been renamed to:

     (vicare platform configuration)
     (vicare platform words)
     (vicare platform errno)
     (vicare unsafe operations)
     (vicare unsafe unicode)
     (vicare unsafe capi)
     (vicare language-extensions infix)
     (vicare language-extensions keywords)
     (vicare language-extensions syntaxes)
     (vicare numerics flonum-formatter)
     (vicare numerics flonum-parser)
     (vicare containers weak-hashtables)
     (vicare posix simple-event-looop)

* BACKWARDS  INCOMPATIBILITY  The  library  (vicare  include)  has  been
  removed.

* Added  automatic  finalisation of  R6RS  records  through the  garbage
  collector  facilities,  see  the  documentation  node  "iklib  records
  final".

* Added $STRING= to (ikarus system $strings).

* Added  functions to  (vicare) to  convert between  bytevectors holding
  octets and  strings or bytevectors  holding the ASCII  hexadecimal and
  base64 encoding of octets:

      hex->bytevector		bytevector->hex
      string-hex->bytevector	bytevector->string-hex
      base64->bytevector	bytevector->base64
      string-base64->bytevector	bytevector->string-base64

* Added  functions to  (vicare) to  convert between  bytevectors holding
  octets and bytevectors holding the corresponding URI percent encoding.

    string->uri-encoding	uri-encoding->string
    uri-encode			uri-decode
    uri-normalise-encoding

* Added functions to (vicare) to manipulate time objects:

      make-time
      time-addition		time-difference
      time=?
      time<?			time<=?
      time>?			time>=?

* Added   functions  PROMISE?,   FOR-EACH-IN-ORDER  and   MAKE-QUEUE  to
  (vicare).

* Added functions to  (vicare) to handle R6RS library  names and version
  numbers:

    library-name?
    library-version-numbers?		library-version-number?
    library-name-decompose
    library-name->identifiers		library-name->version
    library-name-identifiers=?		library-name=?
    library-name<?			library-name<=?
    library-version=?
    library-version<?			library-version<=?

* Added  functions to  (vicare) to  handle R6RS  library references  and
  conformity with library names:

    library-reference?			library-version-reference?
    library-sub-version-reference?	library-sub-version?
    library-reference-decompose
    library-reference->identifiers
    library-reference->version-reference
    library-reference-identifiers=?
    conforming-sub-version-and-sub-version-reference?
    conforming-version-and-version-reference?
    conforming-library-name-and-library-reference?

* Added functions to (vicare) to inspect environment objects:

    environment-labels			environment-libraries
    environment-binding

* Added syntaxes to (vicare):

    receive				receive-and-return
    begin0
    define-values			define-constant-values
    define-constant			define-inline
    define-integrable			define-syntax-rule
    unwind-protect			xor
    include

  the  corresponding  syntaxes have  been  removed  from the  standalone
  syntaxes library.

* Added non-Scheme style syntaxes to (vicare):

    while				until
    continue				break
    for
    return				begin-returnable
    define-returnable			lambda-returnable

* Added compensations API to (vicare), see the documentation node "iklib
  compensations".

* The  I/O ports  now have  property lists,  see the  documentation node
  "iklib io plists".

* The foreign  pointer wrapper strucutres  now have property  lists, see
  the documentation node "ffi foreign wrapper binds".

* BACKWARDS INCOMPATIBILITY In the library (vicare posix): the functions
  READ, PREAD,  RECV and RECVFROM now  accept a generalised C  buffer as
  argument; the  functions WRITE, PWRITE,  SEND and SENDTO now  accept a
  generalised C  string as argument.   When the buffer argument  of such
  functions is  a bytevector: the size  argument must be false,  not the
  number of bytes.

* Added functions to (vicare posix):

     select-port
     select-port-readable?
     select-port-writable?
     select-port-exceptional?

* The syntax DEFINE-SYNTAX now accepts both the formats:

     (define-syntax ?name ?transformer-expr)
     (define-syntax (?name ?arg) ?body0 ?body ...)

  the  syntax  DEFINE-SYNTAX*  has  been  removed  from  the  standalone
  syntaxes library.

* Added DEPREFIX, SUFFIX and DESUFFIX import specification clauses:

     (import (rnrs)
       (rnrs eval))
     (eval '(str.length "ciao")
           (environment
            '(prefix (deprefix (only (rnrs)
                                     string-length
                                     string-append)
                               string-)
                     str.)))
     => 4

* Added  PREFIX,  DEPREFIX,  SUFFIX and  DESUFFIX  export  specification
  clauses:

     (library (demo)
       (export
         (deprefix (yeah.this yeah.that) yeah.)
         (prefix (these those) yeah.))
       (import (rnrs))
       (define (yeah.this) "this")
       (define (yeah.that) "that")
       (define (these) "these")
       (define (those) "those"))

* Added  library  (vicare   language-extensions  cond-expand),  see  the
  documentation node "cond-expand".

* Added  library  (vicare  language-extensions  custom-ports),  see  the
  documentation node "custom-ports".

* Added  library   (vicare  language-extensions  coroutines),   see  the
  documentation node "coroutines".

* Added library (vicare language-extensions  amb), see the documentation
  node "amb".

* Added  library  (vicare  language-extensions  simple-match),  see  the
  documentation node "simple-match".

* Added library (vicare  net channels), see the  documentation node "net
  channels".

* Added  library (vicare  posix pid-files),  see the  documentation node
  "posix pid-files".

* Added  library (vicare  posix lock-pid-files),  see the  documentation
  node "posix lock-pid-files".

* Added  library (vicare  posix log-files),  see the  documentation node
  "posix log-files".

* Added  library (vicare  posix daemonisations),  see the  documentation
  node "posix daemonisations".

* Added library (vicare posix tcp-server-sockets), see the documentation
  node "posix tcp-server-sockets".


Notes for revision 0.2d20
-------------------------

* The boot image has been rotated.

* The files  used by  the GNU  Autotools are  now under  the "autotools"
  subdirectory of the top source directory.   This is to have less files
  in the top directory.  Sorry for the annoyance.

* It may be needed (depending on the platform?) to link with the pthread
  library (using the appropriate "configure"  option) to make use of the
  POSIX semaphore functions.  The  configuration script has been changed
  to make this possible, by including early the pthread linker option.

* The library search path has been fixed; it is now initialised to:

     $(libdir)/scheme/r6rs
     $(libdir)/vicare-scheme

  sorry for the trouble.

* BACKWARDS INCOMPATIBILITY  Starting with  this revision  the libraries
  installed  by the  package are  under "$prefix/vicare-scheme",  rather
  than under "$prefix/scheme".

* Starting  with this  revision, the  SRFI libraries  ported to  R6RS by
  Derick Eddington are included in the distribution.  At present SRFI 19
  (time data types and procedures) is broken.

* Added functions to (vicare):

     printer-integer-radix
     neq?
     flonum->bytevector		bytevector->flonum
     bignum->bytevector		bytevector->bignum
     flzero?/positive		flzero?/negative
     complex-conjugate
     square			cube
     port-uid			port-hash
     exit-hooks

* Modified DEFINE-INLINE-CONSTANT from  (vicare syntactic-extensions) to
  allow the  constant value to be  computed at expand time  by a generic
  expression.

* The  functions EXPAND,  EXPAND/OPTIMIZE,  EXPAND/SCC-LETREC have  been
  removed from the  library (vicare); the function  CORE-EXPAND has been
  renamed     to    EXPAND-FORM-TO-CORE-LANGUAGE,     and    documented;
  EXPAND-LIBRARY  (formerly  LIBRARY-EXPANDER)  has been  added  to  the
  export list of the boot image.

* Added EXPAND-TOP-LEVEL to (vicare).

* Issue 8  is fixed  in an  R6RS incompatible  way.  R6RS  mandates that
  illegal references to  bindings established by LETREC  and LETREC* are
  detected at  run time and cause  an assertion violation to  be raised.
  Vicare detects them at compile time, so some fully R6RS-compliant code
  will not work under Vicare.

    For example,  the following program  (from Flatt's test  suite) will
  run under a R6RS-compliant implementation:

     (import (rnrs))
     (letrec ((x (if (eq? (cons 1 2)
                          (cons 1 2))
                     x
                   1)))
       x)

  because the form X in reference position in the right-hand side of the
  binding is never evaluated; under Vicare this code will rather raise a
  syntax violation at compile time.

* Issue 32 should be fixed.  It was caused by a dumb error of mine while
  rewriting   code  for   readability  in   "ik_collect()"  to   compute
  "new_heap_size".

* Added  parameter   $SOURCE-OPTIMIZER-PASSES-COUNT  and   command  line
  argument --optimizer-passes-count  to select the number  of passes the
  source optimizer has to perform.

* Added command line options:

     --enable-open-mvcalls
     --disable-open-mvcalls

  to enable or  disable inlining of calls  to CALL-WITH-VALUES.  Default
  to disable.

* Documented  the basic  time functions  exported by  (vicare), see  the
  documentation node "iklib time".

* Added documentation for the functions: WARNING and DIE.

* Added convenience function TCP-CONNECT to (vicare posix).

* BACKWARDS INCOMPATIBILITY The functions from (vicare glibc):

     glibc-sinh		glibc-cosh	glibc-tanh
     glibc-asinh	glibc-acosh	glibc-atanh

  have been renamed to:

     sinh		cosh		tanh
     asinh		acosh		atanh

* The following bindings have been added to (ikarus system $ratnums):

     $ratnum-num
     $ratnum-den

* Bindings  for  unsafe numerics  operations  are  exported by  the  new
  library (ikarus system $numerics).  See the documentation node "syslib
  numerics".

* Added  library  (vicare  numerics constants)  exporting  bindings  for
  constants related to the greek pi.

* The reader in #!vicare mode now accepts symbols starting with "+g" and
  "-g",  to  allow   reading  "+greek-pi",  "+greek-pi/2",  "-greek-pi",
  "-greek-pi/2",  etc.   See  the  documentation  node  "iklib  numerics
  constants" for how  to display such symbols with  Unicode glyphs under
  GNU Emacs.

* Added documentation for the library (vicare platform features).


Notes for revision 0.2d19
-------------------------

* Fixed   IMPORT    and   EXPORT   syntaxes   in    body.    Thanks   to
  https://github.com/sunderroy.

* Library (vicare posix): network port numbers are now automatically and
  appropriately converted to  network byte order when  stored in "struct
  sockaddr_in" and  "struct sockaddr_in6" values, and  converted back to
  host byte order when extracted, by the functions:

    make-sockaddr_in		make-sockaddr_in6
    sockaddr_in.in_port		sockaddr_in6.in6_port

* Added functions to (vicare posix):

    htonl	htons
    ntohl	ntohs

* For completeness, added the C functions:

    int8_t   ik_integer_to_sint8  (ikptr X)
    int16_t  ik_integer_to_sint16 (ikptr X)
    uint8_t  ik_integer_to_uint8  (ikptr X)
    uint16_t ik_integer_to_uint16 (ikptr X)
    ikptr    ika_integer_from_sint8  (ikpcb * pcb, int8_t   N)
    ikptr    ika_integer_from_sint16 (ikpcb * pcb, int16_t  N)
    ikptr    ika_integer_from_uint8  (ikpcb * pcb, uint8_t  N)
    ikptr    ika_integer_from_uint16 (ikpcb * pcb, uint16_t N)

  they are equivalent to IK_FIX() and IK_UNFIX().

* Added library (vicare platform utilities).

* While the  library (vicare  platform-constants) is  still distributed,
  its use is now deprecated; use (vicare platform constants) instead.

* Added library (vicare arguments validation).

* Added library (vicare arguments general-c-buffers).

* Added the following function aliases:

    string->pathname-func = string->filename-func
    pathname->string-func = filename->string-func

* Instances of MEMORY-BLOCK are now garbage collected using the built in
  struct  destruction  mechanism,  rather   than  using  an  independent
  guardian.

* Log  functions registered  in STRUCT-GUARDIAN-LOGGER  must support  an
  additional operation: registration; see the documentation for details.


Notes for revision 0.2d18
-------------------------

* Reimplemented and extended the  garbage collection avoidance API.  The
  following functions were broken and have been removed:

    scheme-object->pointer
    pointer->scheme-object

* Fixed unsafe accessors and mutators for R6RS records.

* Added variants of SELECT function acting on fd_set instances.


Notes for revision 0.2d17
-------------------------

* The distributed boot images have been rotated.

* A data structure  automatic destruction protocol has  been added; this
  is about Vicare's structs, not R6RS records (although R6RS records are
  structs).

    A field has been added to the RTD of structs:

  - Whenever the  field holds a  procedure, instances of the  struct are
    registered (upon  creation) into an internal  guardian; whenever the
    guardian  collects   the  instance,  a  post-GC   hook  applies  the
    destructor to the instance.

  - If the field holds #f: nothing happens.

    For  details   see  the   "Automatic  finalisation   of  structures"
  subheading of the "iklib structs rtd" documentation node.

* The addition  of the struct  destructors causes  Issue #35 to  show up
  much more often than  before[1].  This is very bad and  I hate it, but
  that is the way it is.  This bug  is from code I have not yet studied,
  so it is very unlikely that I will be able to fix it anytime soon.

  [1] <https://github.com/marcomaggi/vicare/issues/35>

* Added  size_t, ssize_t,  off_t,  ptrdiff_t as  type  specifiers for  C
  language callouts and callbacks.

* Added limits to the library (vicare words):

    greatest-c-size_t			least-c-size_t
    greatest-c-ssize			least-c-ssize_t
    greatest-c-off_t			least-c-off_t
    greatest-c-ptrdiff_t		least-c-ptrdiff_t
    greatest-c-size_t*			least-c-size_t*
    greatest-c-ssize_t			least-c-ssize_t*
    greatest-c-off_t*			least-c-off_t*
    greatest-c-ptrdiff_t*		least-c-ptrdiff_t*

* Added  raw memory  setters and  getters for  C language  types size_t,
  ssize_t, off_t, ptrdiff_t.

* Reorganised IK_VOIDP_FROM and similar C preprocessor macros.

* Added automatic generation of unsafe  accessor and mutator syntaxes to
  DEFINE-STRUCT; in the following example:

    (define-struct color
      (red green blue))

  in addition to the safe accessor and mutator definitions for:

    color-red		set-color-red!
    color-green		set-color-green!
    color-blue		set-color-blue!

  unsafe accessors and mutator definitions for:

    $color-red		$set-color-red!
    $color-green	$set-color-green!
    $color-blue		$set-color-blue!

  are generated with code like:

    (define-syntax $color-red
      (syntax-rules ()
        ((_ x)
	 ($struct-ref x 0))))

    (define-syntax $set-color-red!
      (syntax-rules ()
        ((_ x v)
	 ($struct-set! x 0 v))))

  at the Scheme level it cannot be faster than this.

* Added automatic generation of unsafe  accessor and mutator syntaxes to
  DEFINE-RECORD-TYPE  as  extension (and  violation?)  of  R6RS; in  the
  following example:

    (define-record-type color
      (fields (mutable red)
              (mutable green)
	      (mutable blue)))

  in addition to the safe accessor and mutator definitions for:

    color-red		color-red-set!
    color-green		color-green-set!
    color-blue		color-blue-set!

  unsafe accessors and mutator definitions for:

    $color-red		$color-red-set!
    $color-green	$color-green-set!
    $color-blue		$color-blue-set!

  are generated with code like:

    (define-syntax $color-red
      (syntax-rules ()
        ((_ x)
	 ($struct-ref x 0))))

    (define-syntax $color-red-set!
      (syntax-rules ()
        ((_ x v)
	 ($struct-set! x 0 v))))

* Added new  documentation node "overview extensions"  for extensions to
  R6RS.

* CASE-FIXNUMS and CASE-INTEGERS  from (vicare syntactic-extensions) now
  accept multiple datums in the same clause.


Notes for revision 0.2d16
-------------------------

* Added C language preprocessor macros:

    IK_IS_BOOLEAN
    IK_BOOLEAN_TO_INT
    IK_BOOLEAN_FROM_INT

  along with others documented in the "objects misc" node.

* Added functions to convert immediate  Scheme objects and references to
  Scheme objects to pointer objects:

    pointer->scheme-object
    scheme-object->pointer

  such functions allow to hand a  Scheme object to a foreign function as
  opaque value.   Such functions  are meant  to be  used along  with the
  garbage collection avoidance API.

* Changed STRUCT-RESET to set all the fields of a struct to void, rather
  than to false.

* Added functions to convert from  raw memory strings in UTF-16 encoding
  to bytevectors and Scheme strings:

    cstring16->bytevector
    cstring16n->string
    cstring16le->string
    cstring16be->string

* Fixed bug in BYTEVECTOR->CSTRING  erroneously using "strncpy()" rather
  than a verbatim copy of the bytes.

* When the  reader is in "#!vicare" mode: "++" and "--" are now accepted
  identifiers.

* Added (vicare infix) providing an infix to prefix transformer.

* Added data structure MEMORY-BLOCK to reference a raw memory block with
  both  a pointer  and its  size.   Many functions  accepting a  pointer
  object as argument now accept a memory block too.

* MALLOC, REALLOC, CALLOC, MEMCPY,  MEMMOVE, MEMSET, MEMCMP, STRNCMP and
  STRNDUP now accept a "size_t"  exact integer as count argument, rather
  than a fixnum.

* Fixed bug  in GUARDED-REALLOC  causing the return  value to  be always
  NULL.

* Added functions to poke and peek  values to and from raw memory arrays
  (like POINTER-SET  and POINTER-REF,  but ARRAY-SET and  ARRAY-REF with
  scaled offsets).

* Added inclusive and  exclusive limits for C language  types in (vicare
  words).


Notes for revision 0.2d15
-------------------------

* NULL-POINTER now returns a newly allocated pointer object, rather than
  returning always the same one.

* Fixed missing normalisation of some FASL pathnames.

* "make installcheck" should now work (I hope definitely).

* When running "make vfasl" to precompile libraries from the build tree:
  the FASL files are now created under $(builddir)/lib/fasl, rather than
  polluting a system FASL cache directory.

* More constants as identifiers syntaxes in (vicare words):

    SIZEOF_CHAR
    SIZEOF_SHORT        SIZEOF_INT
    SIZEOF_LONG         SIZEOF_LONG_LONG
    SIZEOF_SIZE_T       SIZEOF_SSIZE_T
    SIZEOF_OFF_T
    SIZEOF_FLOAT        SIZEOF_DOUBLE
    SIZEOF_POINTER

* The following symbols substitutions have been imposed on the C code:

    false_object	-> IK_FALSE_OBJECT
    true_object		-> IK_TRUE_OBJECT
    null_object		-> IK_NULL_OBJECT
    eof_object		-> IK_EOF_OBJECT
    void_object		-> IK_VOID_OBJECT
    unbound_object	-> IK_UNBOUND_OBJECT
    bwp_object		-> IK_BWP_OBJECT

  and the following aliases defined: IK_FALSE, IK_TRUE, IK_NULL, IK_EOF,
  IK_VOID, IK_UNBOUND, IK_BWP.

* Added STRUCT-RESET  to (vicare), to  reset to #f  all the fields  of a
  structure.

* Added REGCOMP/DISOWN to (vicare glibc).

* Added syntaxes to (vicare syntactic-extensions):

    case-integers
    define-exact-integer->symbol-function

* Added experimental API to avoid garbage collection of objects:

	register-to-avoid-collecting
	forget-to-avoid-collecting
	collection-avoidance-list
	purge-collection-avoidance-list

* Added documentation  for some, but  not all, the syntaxes  exported by
  (vicare syntactic-extensions).


Notes for revision 0.2d14
-------------------------

* Added  library (vicare  platform  features)  exporting one  identifier
  syntax for each HAVE_ constant  defined by "configure".  At present it
  is maintained by hand.

* Fixed distributions of Scheme libraries and test files.

* Fixed GNU  Automake stuff to  have the "make distcheck"  rule complete
  successfully despite some test failures.


Notes for revision 0.2d13
-------------------------

* More platform  constants in  (vicare platform-constants),  which means
  that running "configure" takes longer (sorry).  But, when POSIX, Glibc
  and  Linux are  disabled: the  associated platform  constants are  not
  checked anymore, making running "configure" much faster.

* Added POSIX timers API to (vicare posix).

* Added resource usage and limits API to (vicare posix).

* Added PRLIMIT to (vicare linux).

* Added functions  to (vicare posix):  CLOCK-GETCPUCLOCKID, SIGWAITINFO,
  SIGTIMEDWAIT.

* Added inotify API to (vicare linux).


Notes for revision 0.2d12
-------------------------

* The runtime program "vicare" is now linked with -lrt.

* Added miscellaneous functions to (vicare posix): TRUNCATE, FTRUNCATE.

* Added  realtime  clock  functions  to  (vicare  posix):  CLOCK-GETRES,
  CLOCK-GETTIME, CLOCK-SETTIME.

* Added POSIX message queue API to (vicare posix).

* Added POSIX shared memory API to (vicare posix).

* Added POSIX semaphores API to (vicare posix).

* Added timerfd API to (vicare linux).

* Added the function STRUCT=? to (vicare).

* Miscellaneous bug fixes (a killer one in MMAP).


Notes for revision 0.2d11
-------------------------

* The function GET-CHAR-AND-TRACK-TEXTUAL-POSITION increments the column
  number by 8 when a tab character is read, rather than by 1.

* When exiting a running Vicare process from the debugger by typing "q":
  the exit status is now 99 rather than 0.

* The function  SYNTAX-VIOLATION no more  flattens the form  and subform
  arguments from syntax objects  to symbolic expressions, syntax objects
  are kept.

* Added PRETTY-PRINT*, like  PRETTY-PRINT but accepts some configuration
  arguments.

* Multiple FASL  directories are now supported.  Files  are now searched
  in a path to allow  both system precompiled files and user precompiled
  files.   The  environment   variable  VICARE_FASL_PATH  allows  adding
  directories to the search path.

* Added command line options:  --fasl-directory, to override the default
  value of the parameter FASL-DIRECTORY; --fasl-path, to add directories
  to the default value of the parameter FASL-SEARCH-PATH.

* Added command line option --print-loaded-libraries, to print pathnames
  of loaded libraries.

* The documentation file has been renamed to "vicare-scheme.texi".


Notes for revision 0.2d10
-------------------------

* Changed  FASL-DIRECTORY  pathname validator  to  accept only  existent
  string pathnames.

* Added  keyword objects  handling  to the  boot  image.  Added  library
  (vicare keywords) with facilities for keyword objects.

* BACKWARDS INCOMPATIBILITY The reader syntax:

    #:symbol

  is now used to read keyword objects wrapping the SYMBOL rather than to
  build a  gensym using SYMBOL as  pretty name.  At present  there is no
  more a syntax to read a gensym with a given pretty name.

* Added documentation for:

    TRACE-DEFINE-SYNTAX
    TRACE-LET-SYNTAX
    TRACE-LETREC-SYNTAX

* Added dangerous inspection functions to (vicare):

    INTEGER->MACHINE-WORD
    MACHINE-WORD->INTEGER

* Added library  (vicare parser-logic) exposing the  parser builder used
  internally for  both STRING->NUMBER  and the string-to-number  code in
  the reader.

* Added functions to (vicare posix):

    split-search-path
    split-search-path-bytevector
    split-search-path-string
    split-pathname
    split-pathname-bytevector
    split-pathname-string
    find-executable-as-bytevector
    find-executable-as-string
    vicare-executable-as-bytevector
    vicare-executable-as-string


Notes for revision 0.2d9
------------------------

* The package  name, selected in  "configure.ac", has been  changed from
  "vicare" to "vicare-scheme".

* Added built in library  (vicare language-extensions) exporting all the
  bindings exported by (vicare) not exported by (rnrs (6)).

* Added to (vicare ffi) more system-agnostic functions to load a foreign
  shared library.

* Added raw  memory allocation functions  raising exceptions in  case of
  error.

* Documentation was written for  some of the libraries distributed under
  the hierarchy (vicare ---).

* Added documentation  appendix showing how  to exchange raw  and Scheme
  data among Vicare processes using mmapped interprocess shared memory.

* BACKWARDS INCOMPATIBILITY  The functions SYSCONF,  PATHCONF, FPATHCONF
  and CONFSTR  have been  moved from the  library (vicare glibc)  to the
  library (vicare posix).

* Added to (vicare posix) functions: SETITIMER, GETITIMER, ALARM, MLOCK,
  MUNLOCK,   MLOCKALL,  MUNLOCKALL,   MPROTECT,  SELECT-FD-EXCEPTIONAL?,
  SELECT-FD-WRITABLE?, SELECT-FD-READABLE?.

* Added to (vicare linux) functions: SIGNALFD.

* Added library (vicare simple-event-loop).


Notes for revision 0.2d8
------------------------

* Added  configuration  option  "--with-pthread"  to link  the  "vicare"
  executable with the pthread library.  The executable was always linked
  with pthread before, now it is *not* by default.

* Changed default  for configuration option "--with-iconv"  from "no" to
  "check", when  the option is  not specified: the  configuration script
  checks if  an iconv library is available,  but it does not  fail if it
  does not find it.

* CONFIGURATION  BACKWARDS   INCOMPATIBILITY  The  configuration  option
  "--enable-libffi"  has been renamed  to "--with-libffi".   Its default
  value  has  changed from  "no"  to "check",  when  the  option is  not
  specified:  the configuration  script checks  if a  libffi  library is
  available, but it does not fail if it does not find it.

* Added   configuration  option   "--with-readline"  enabling   a  basic
  interface to GNU Readline or compatible library.  By default, when the
  option  is  not  specified:  the  configuration  script  checks  if  a
  compatible library is  available, but it does not fail  if it does not
  find  it.   The  following  bindings  are  exported  by  (vicare)  and
  (icarus):

     readline-enabled?
     readline
     make-readline-input-port

* The C language functions allocating Scheme bytevectors by copying from
  raw memory blocks will *silently  truncate* the input if its length is
  greater than the most positive fixnum.  (This is dirty, I know.)

* BACKWARDS INCOMPATIBILITY Libraries in  the (vicare ---) hierarchy are
  now   installed    under   "$(libdir)/scheme"   rather    than   under
  "$(libdir)/vicare"; the LIBRARY-PATH parameter now includes both these
  directories.     The   boot   image    is   still    installed   under
  "$(libdir)/vicare".

* Added  reader syntax  "#ve(<encoding> <data>)"  to read  bytevector in
  some  form of  encoding.   At present  it  supports converting  Scheme
  strings to  bytevectors using the  conversion function: string->ascii,
  string->latin1, string->utf8, etc.  Example:

     #ve(ascii "hello\n") => #vu8(104 101 108 108 111 10)

* Added  reader syntaxes "#ci<form>"  and "#cs<form>"  to read  the next
  form with case insensitive or case sensitive identifiers.  When a case
  insensitive  identifier is  read: its  string name  is  passed through
  STRING-FOLDCASE.   (These  syntaxes should  be  like  the Chicken  and
  Racket ones.)

* Added reader syntaxes for custom named characters:

    ;define "lambda" as synonym for #\x0E88
    #!(char-names (lambda . #\x0E88))

    ;standalone character
    #\{lambda}		=> #\x0E88

    ;character embedded in string
    "\{lambda}"		=> "\x0E88;"

* Added support for epoll API to (vicare linux).


Notes for revision 0.2d7
------------------------

* Boot images were regenerated.

* Added PARAMETRISE as alias for PARAMETERIZE.

* Parameter functions now accept 0, 1 or 2 values and work as follows:

    (let ((the-value <init-value>)
          (guard <guard-func>))
      (case-lambda
        (()
         the-value)
        ((new-value)
         (set! the-value (guard new-value)))
        ((new-value guard?)
         (if guard?
             (set! the-value (guard new-value))
           (set! the-value new-value)))))

* BACKWARDS INCOMPATIBILITY The  function MAKE-PARAMETER does *not* pass
  the  parameter's  initialisation  value  through  the  guard  function
  anymore.

* POSSIBLE BACKWARDS INCOMPATIBILITY The PARAMETERIZE syntax applies the
  parameter's guard  function when setting  a new value, but  does *not*
  apply it when restoring the original parameter's value.

* Added  command  line  option  to  the "vicare"  executable  to  enable
  entering a  debugging REPL whenever the interprocess  signal SIGINT is
  received.  It was enabled by default, now it is disabled by default.

* Added  functions  ASCII->STRING and  STRING->ASCII  to convert  Scheme
  strings to and from bytevectors holding ASCII representations.

* Functions acting  on pointers, allocating  raw memory and acting  on C
  strings, that  were exported by (vicare  ffi) but do  not need Libffi,
  are  now exported  by (vicare)  and  (ikarus) and  also reexported  by
  (vicare ffi).  This change should be backwards compatible.

* Syntax  bindings associated  to  the "errno"  variable, including  the
  error  code constants,  are now  exported by  the new  library (vicare
  errno).     The   constants   are    also   reexported    by   (vicare
  platform-constants).   The  CASE-ERRNO  and  ERRNO-CODE  syntaxes  are
  reexported  by   (vicare  ffi).   This  change   should  be  backwards
  compatible.

* Added library (vicare weak-hashtables) implementing hashtables holding
  weak references to keys and strong references to values.

* Added   "--disable-posix",  "--disable-glibc"   and  "--disable-linux"
  options  to  the "configure"  script  to  disable  inclusion of  POSIX
  bindings, GNU C Library specific bindings and Linux specific bindings.

* BACKWARDS  INCOMPATIBILITY Scheme  functions for  POSIX  bindings have
  been  moved out  of the  boot  image; they  are only  exported by  the
  (vicare  posix) library.   POSIX functions  whose names  were prefixed
  with "posix-" to avoid collision are now unprefixed:

     posix-read		-> read
     posix-write	-> write
     posix-remove	-> remove
     posix-time		-> time

  RAISE-SIGNAL has been renamed  to RAISE.  Collision between names from
  (vicare) and  names from  (vicare posix) can  be avoided  by prefixing
  bindings from (vicare posix) in the import spec; example:

     (import (vicare)
       (prefix (vicare posix) px.))

* Added POSIX functions for memory-mapped input/output:

    mmap		munmap
    msync		mremap
    madvise

* Added POSIX function POLL.

* Added  to  (vicare  posix)  simple  block/unblock  (BUB)  interprocess
  signals API.

* When "--enable-libffi"  is not used:  the library (vicare ffi)  is not
  installed   anymore.     Fixed   bug   causing    build   error   when
  "--enable-libffi" is not used.


Notes for revision 0.2d6
------------------------

* Big C code review to fix  bad handling of allocated Scheme object with
  respect to garbage collection.

* The documentation of the  C language internals for manipulating Scheme
  objects  has  been reviewed  and  extended  (it  is still  incomplete,
  though).

* The Scheme  code for the glibc  and linux functions has  been moved in
  standalone libraries, out of the  boot image.  The public interface to
  these libraries is unchanged.

* Added  support   for  autoloading  foreign   libraries  associated  to
  precompiled  library files.   The packaging  infrastructure  needs GNU
  Libtool now.

* Optional support for the Iconv API has been added to (vicare glibc) by
  linking with  Libiconv.  By default  disabled, to enable it:  give the
  --with-iconv option to the "configure" script.

* Optional  binding to  the CRE2  library  has been  added.  By  default
  disabled, to enable it use the "--with-cre2" configuration option.

* Added reader syntaxes  to read bytevectors of flonums  and cflonums in
  single and double precision:

    #vf4l #vf4b #vf4n		#vf8l #vf8b #vf8n
    #vc4l #vc4b #vc4n		#vc8l #vc8b #vc8n

* Added conversion  functions between lists of flonums  and cflonums and
  bytevectors:

    f4l-list->bytevector	bytevector->f4l-list
    f4b-list->bytevector	bytevector->f4b-list
    f4n-list->bytevector	bytevector->f4n-list
    f8l-list->bytevector	bytevector->f8l-list
    f8b-list->bytevector	bytevector->f8b-list
    f8n-list->bytevector	bytevector->f8n-list

    c4l-list->bytevector	bytevector->c4l-list
    c4b-list->bytevector	bytevector->c4b-list
    c4n-list->bytevector	bytevector->c4n-list
    c8l-list->bytevector	bytevector->c8l-list
    c8b-list->bytevector	bytevector->c8b-list
    c8n-list->bytevector	bytevector->c8n-list


Notes for revision 0.2d5
------------------------

* Added users and groups, process control, time related functions to the
  POSIX API.

* Some functions where added to (vicare glibc).

* Better  use of  GNU  Autotools and  better  tracking of  files in  the
  repository.

* The "main()" function now calls:

     setlocale(LC_ALL, "")

* The FFI library is now  (vicare ffi).  FFI code and documentation have
  been reviewed.  They need more testing.

* A toy library to build and  load shared libraries at runtime using GCC
  has been added, (vicare gcc).


Notes for revision 0.2d4
------------------------

* The POSIX API  is exported by the (vicare posix)  library, and also by
  (ikarus) and (vicare).

* The GNU C Library API is exported by the (vicare glibc) library.

* The Linux API is exported by the (vicare linux) library.

* Socket functions have been added to the POSIX API.

* Some documentation on handling Scheme  objects at the C language level
  has been written.


Notes for revision 0.2d3
------------------------

* The configuration process is now really long (sorry).

* Restructured most of the POSIX API, in a way non-backwards compatible.
  Still no sockets API available in this release.

* Added the functions:

    make-binary-file-descriptor-input-port
    make-binary-file-descriptor-input-port*
    make-binary-file-descriptor-output-port
    make-binary-file-descriptor-output-port*
    make-binary-file-descriptor-input/output-port
    make-binary-file-descriptor-input/output-port*
    make-textual-file-descriptor-input-port
    make-textual-file-descriptor-input-port*
    make-textual-file-descriptor-output-port
    make-textual-file-descriptor-output-port*
    make-textual-file-descriptor-input/output-port
    make-textual-file-descriptor-input/output-port*
    port-fd

* Added  experimental boot image  for 64-bit  platforms, generated  on a
  32-bit machine.  Hope it works.


Notes for revision 0.2d2
------------------------

* Tarballs extracted from GitHub's  "extract tagged revision" feature do
  not work because of missing files,  so this project is back on relying
  only  on  full repository  checkouts  and  release  tarballs from  the
  download area.

* The  default   list  of  library   file  extensions  now   holds  just
  ".vicare.sls" and ".sls"; the new option --more-file-extensions allows
  to restore  the old  behaviour of searching  for many  file extensions
  plus the "main" file trick.

* Some documentation has been written; other reviewed.

* More code reviewed with support for optional arguments validation.

* Updated  functions to  properly rely  on I/O  port's own  buffer mode;
  DISPLAY, WRITE, NEWLINE do not force a flush anymore.

* Added  SET-PORT-BUFFER-MODE! to  reconfigure the  mode of  an existing
  port.


Notes for revision 0.2d1
------------------------

* It  appears that  Ikarus' mailing  list is  working no  more,  so this
  project  now   has  its  own   mailing  list  for   announcements  and
  discussions:

	     <http://groups.google.com/group/vicare-users>

* Added library (vicare) exporting the same bindings of (ikarus).

* Review of bytevector functions.

* Introduced  the configuration  option "--disable-arguments-validation"
  to exclude  at expansion-time code validating  arguments to functions.
  At present only a few modules support this feature.

* Review  of command line  options and  execution modes.   Added options
  "--print-assembly"  and "--print-optimizer",  at present  neither very
  useful, nor human-friendly.


### end of file
# Local Variables:
# coding: utf-8-unix
# mode: text
# fill-column: 72
# paragraph-start: "*"
# End: