Embeddable Common-Lisp

Hello,

the attached patch:

- fixes make-load-form for cl-yacc which now passes its self-tests when
compiled.

- comments a section of the documentation out, because it seems bogus.

- adds a --with-gmp-prefix configure argument where
--with-gmp-prefix=/usr/local is a shorthand to
--with-gmp-incdir=/usr/local/include --with-gmp-libdir=/usr/local/lib.

Regards,
-- 
Julian Stecklina

Being really good at C++ is like being really good at using rocks to
sharpen sticks. - Thant Tessman

Hi Julian,

the patch below should not be required. If the list contains objects
that must be built using MAKE-LOAD-FORM then the compiler should detect
it. Otherwise, one setf statement per array element is an overkill.

Can you show me a code that breaks with the current version?

Juanjo

On Fri, 2006-05-26 at 05:17 +0200, Julian Stecklina wrote:
> RCS file: /project/ecl/cvsroot/ecl/src/clos/print.lsp,v
> retrieving revision 1.11
> diff -u -r1.11 print.lsp
> --- src/clos/print.lsp  17 May 2006 15:17:29 -0000      1.11
> +++ src/clos/print.lsp  26 May 2006 02:42:04 -0000
> @@ -79,10 +79,11 @@
>        (array
>         (values `(make-array ',(array-dimensions object)
>                  :element-type ',(array-element-type object)
> -                :adjustable ',(adjustable-array-p object)
> -                :initial-contents ',(loop for i from 0 below
> (array-total-size object)
> -                                          collect (row-major-aref
> object i)))
> -              init))
> +                :adjustable ',(adjustable-array-p object))
> +              `(loop for i from 0 below ,(array-total-size object)
> +                     for v in ',(loop for i from 0 below
> (array-total-size object)
> +                                      collect (row-major-aref object
> i))
> +                     do (setf (row-major-aref ,(maybe-quote object)
> i) v))))
>        (cons
>         (values `(cons ,(maybe-quote (car object)) nil)
>                (and (rest object) `(rplacd ,(maybe-quote
> object) ,(maybe-quote (cdr object))))))

Juan Jose Garcia Ripoll <lisp@...> writes:

> Hi Julian,
>
> the patch below should not be required. If the list contains objects
> that must be built using MAKE-LOAD-FORM then the compiler should detect
> it. Otherwise, one setf statement per array element is an overkill.
>
> Can you show me a code that breaks with the current version?

See below.

> On Fri, 2006-05-26 at 05:17 +0200, Julian Stecklina wrote:
>> RCS file: /project/ecl/cvsroot/ecl/src/clos/print.lsp,v
>> retrieving revision 1.11
>> diff -u -r1.11 print.lsp
>> --- src/clos/print.lsp  17 May 2006 15:17:29 -0000      1.11
>> +++ src/clos/print.lsp  26 May 2006 02:42:04 -0000
>> @@ -79,10 +79,11 @@
>>        (array
>>         (values `(make-array ',(array-dimensions object)
>>                  :element-type ',(array-element-type object)
>> -                :adjustable ',(adjustable-array-p object)
>> -                :initial-contents ',(loop for i from 0 below
>> (array-total-size object)
>> -                                          collect (row-major-aref
>> object i)))
>> -              init))

init is not declared. But you could return nil as second value. But this
has another problem, when the array in question references it self. When
you compile and load the following example, (aref *blub* 1) will be 0,
which is clearly wrong. The struct in the array is needed, because
otherwise this code path would not be executed. (On a sidenote: If you
compile this file, start a new instance of ECL and load it, it will
complain about a missing class FOO. Bug?)

;; Don't forget to set *print-circle* to T. ;)
(eval-when (load compile eval)
  (defstruct foo
    zop)

  (defmacro bar ()
    (let ((v (make-array 2)))
      (setf (aref v 0) (make-foo)
	    (aref v 1) v)))

  )

(defparameter *blub* (bar))

Regards,
-- 
Julian Stecklina

Being really good at C++ is like being really good at using rocks to
sharpen sticks. - Thant Tessman

On Fri, 2006-05-26 at 17:44 +0200, Julian Stecklina wrote:
> Juan Jose Garcia Ripoll <lisp@...> writes:
> > the patch below should not be required. If the list contains objects
> > that must be built using MAKE-LOAD-FORM then the compiler should detect
> > it. Otherwise, one setf statement per array element is an overkill.
> >
> > Can you show me a code that breaks with the current version?
>=20
> See below. [...]
> init is not declared. But you could return nil as second value. But this
> has another problem, when the array in question references it self. When
> you compile and load the following example, (aref *blub* 1) will be 0,
> which is clearly wrong. The struct in the array is needed, because
> otherwise this code path would not be executed.

Ok, I see the typo in the original code. But I think it is much simpler
to create a constant list with the initial data except for sites which
reference the array itself or other non-printable structures. The latter
would then appear in a smaller number of initialization statements. I
will code that later.

> (On a sidenote: If you
> compile this file, start a new instance of ECL and load it, it will
> complain about a missing class FOO. Bug?)

I will look into that.

Juanjo

Juan Jose Garcia Ripoll <lisp@...> writes:

> On Fri, 2006-05-26 at 17:44 +0200, Julian Stecklina wrote:
>> Juan Jose Garcia Ripoll <lisp@...> writes:
>> > the patch below should not be required. If the list contains objects
>> > that must be built using MAKE-LOAD-FORM then the compiler should detect
>> > it. Otherwise, one setf statement per array element is an overkill.
>> >
>> > Can you show me a code that breaks with the current version?
>> 
>> See below. [...]
>> init is not declared. But you could return nil as second value. But this
>> has another problem, when the array in question references it self. When
>> you compile and load the following example, (aref *blub* 1) will be 0,
>> which is clearly wrong. The struct in the array is needed, because
>> otherwise this code path would not be executed.
>
> Ok, I see the typo in the original code. But I think it is much simpler
> to create a constant list with the initial data except for sites which
> reference the array itself or other non-printable structures. The latter
> would then appear in a smaller number of initialization statements. I
> will code that later.

Does this cover the case where the array is not trivially
self-referential? Say if it contains a structure or cons which in turn
references the array?

What do you mean with just using a constant list? The patch moves the
constant list from the creation form to the initialization form. It does
not look to me as if it is making the code worse at all.

Regards,
-- 
Julian Stecklina

Being really good at C++ is like being really good at using rocks to
sharpen sticks. - Thant Tessman

On Fri, 2006-05-26 at 20:38 +0200, Julian Stecklina wrote:
> Juan Jose Garcia Ripoll <lisp@...> writes:
> > Ok, I see the typo in the original code. But I think it is much simpler
> > to create a constant list with the initial data except for sites which
> > reference the array itself or other non-printable structures. The latte=
r
> > would then appear in a smaller number of initialization statements. I
> > will code that later.
>=20
> Does this cover the case where the array is not trivially
> self-referential? Say if it contains a structure or cons which in turn
> references the array?

The way ECL's compiler handle complex constants is as follows:

     1. Add the constant to a hash table with an index to the position
        in the constant data table that is built at run time
     2. If the constant does not require a load form, add it to the
        string from which constant data is read at run time.
     3. If the constant requires a load form
             1. Invoke MAKE-LOAD-FORM to obtain a "make" and an
                "initialization" form.
             2. Compile the "make" form
             3. Compile the "init" form

As you see, the process is recursive. When the object that requires a
load form appears again in the construction ("make") or in the
initialization ("init") forms, the compiler will already know where to
fetch it from.

Juanjo

Today, in CVS:

+ The compiler fixes I promised have been finally committed. I don't
know what happened last time, but they did not get uploaded.

+ I have included Brian Spilsbury's patches for handling unicode
strings. Though extensive, these patches are limited to the introduction
of a new data structure for (ARRAY CHARACTER), the separation between
BASE-CHAR and EXTENDED-CHAR (the former being limited to unicode
codepoints <=3D 255).

+ Almost the whole of the library is guaranteed to work with at least
base-strings and many of the functions will complain if passed strings
with extended characters. This is the case of functions dealing with
symbols, or pathnames, or FFI.

+ There is no support for reading or writing unicode strings. Currently
the only way to create them is with the array functions, coercion of
base strings, etc. The reason is that streams do not yet understand
external formats.

+ The unicode patch can be activated with --enable-unicode. The
non-unicode version is expected to remain as stable as it was and at
least it passes the tests with the same number of well known errors as
before.

Regards,

Juanjo

On Mon, 2006-05-29 at 09:56 +0200, Juan Jose Garcia Ripoll wrote:
> On Fri, 2006-05-26 at 20:38 +0200, Julian Stecklina wrote:
> > Juan Jose Garcia Ripoll <lisp@...> writes:
> > > Ok, I see the typo in the original code. But I think it is much simpl=
er
> > > to create a constant list with the initial data except for sites whic=
h
> > > reference the array itself or other non-printable structures. The lat=
ter
> > > would then appear in a smaller number of initialization statements. I
> > > will code that later.
> >=20
> > Does this cover the case where the array is not trivially
> > self-referential? Say if it contains a structure or cons which in turn
> > references the array?

The fix has been implemented:

jlr@...$ ecl
ECL (Embeddable Common-Lisp) 0.9h
Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya
Copyright (C) 1993 Giuseppe Attardi
Copyright (C) 2000 Juan J. Garcia-Ripoll
ECL is free software, and you are welcome to redistribute it
under certain conditions; see file 'Copyright' for details.
Type :h for Help.  Broken at EVAL.
> (si::system "cat foo.lsp")
(eval-when (compile)
  (setf *a* (make-array 10))
  (setf (row-major-aref *a* 1) *a*))

(let ((*print-circle* t)
      (a #.*a*))
  (format t "Self referential: ~A~%" (eq a (row-major-aref a 1))))

0
> (load (compile-file "foo" :verbose nil) :verbose nil)
;;; Loading #P"/home/jlr/lib/ecl/cmp.fas"
;;; Loading #P"/home/jlr/lib/ecl/sysfun.lsp"
Self referential: T
"/home/jlr/src/ecls-new/build/foo.fas"
>=20

Juan Jose Garcia Ripoll <lisp@...> writes:

> The way ECL's compiler handle complex constants is as follows:
>
>      1. Add the constant to a hash table with an index to the position
>         in the constant data table that is built at run time
>      2. If the constant does not require a load form, add it to the
>         string from which constant data is read at run time.
>      3. If the constant requires a load form
>              1. Invoke MAKE-LOAD-FORM to obtain a "make" and an
>                 "initialization" form.
>              2. Compile the "make" form
>              3. Compile the "init" form
>
> As you see, the process is recursive. When the object that requires a
> load form appears again in the construction ("make") or in the
> initialization ("init") forms, the compiler will already know where to
> fetch it from.

Thanks for the clarification.

Regards,
-- 
Julian Stecklina

Being really good at C++ is like being really good at using rocks to
sharpen sticks. - Thant Tessman

Juan Jose Garcia Ripoll <lisp@...> writes:

>> > Does this cover the case where the array is not trivially
>> > self-referential? Say if it contains a structure or cons which in turn
>> > references the array?
>
> The fix has been implemented:

Thanks! Is there a chance that you commit the --with-gmp-prefix
configure.in part of the original patch? At least on my machine this
reduces configuring to ./configure --with-gmp-prefix=/usr/local
--with-tcp.

Btw, is there any reason to not building the TCP code by default? I
guess, some people will be quite puzzled why an ECL built with default
parameters is unable to communicate with SLIME.

Regards,
-- 
Julian Stecklina

Being really good at C++ is like being really good at using rocks to
sharpen sticks. - Thant Tessman

On Tue, 2006-05-30 at 12:06 +0200, Julian Stecklina wrote:
> Thanks! Is there a chance that you commit the --with-gmp-prefix
> configure.in part of the original patch? At least on my machine this
> reduces configuring to ./configure --with-gmp-prefix=3D/usr/local
> --with-tcp.

Sorry, I missed that part. I thought it was the same thing you had
submitted previously for --with-gmp-incdir, --with-gmp-libdir,... The
new flag is now included.

> Btw, is there any reason to not building the TCP code by default? I
> guess, some people will be quite puzzled why an ECL built with default
> parameters is unable to communicate with SLIME.

None. I now see that TCP suppport is available on all platforms in which
ECL works, including windows. I have activated it.

Juanjo