[Gcl-devel] Re: an even poorer excuse for a bug report

[Camm Maguire]

Greetings!

(DEFCONSTANT *1*SHELL-QUOTE-MARK (QUOTE *1*QUOTE))

The form looks like
(list *1*SHELL-QUOTE-MARK BTM-FN-SYMB)

The compiler expanded *1*SHELL-QUOTE-MARK to its constant value when
writing the code for list -- do not know why this has never occurred
before.

Of course, I could be confused, as its late :-).

Take care,

Robert Boyer <address@hidden> writes:

> There may be a bug in the compilation by the most recent GCL 2.7.0 of the
> Nqthm function ADD-SHELL-ROUTINES which is causing (QUOTE
> *1*SHELL-QUOTE-MARK) to be replaced with *1*SHELL-QUOTE-MARK when it
> shouldn't.
> 
> I'm not yet sure what the nature of the problem is.
> 
> If I try the simplest 'proveall', basic/proveall.events, it breaks because
> *1*PUSH has been created with the mistake mentioned above -- evaluation is
> attempted of a symbol that has no value.  If I load the interpreted
> version of ADD-SHELL-ROUTINES, it runs ok, and if I recompile
> ADD-SHELL-ROUTINES it runs ok.  Crazy!
> 
> Below is the code for the function in question.  I've put !!! near where I
> think the problem may be.
> 
> I have disabled all Nqthm proclaiming.
> 
> Bob
> 
> (DEFUN ADD-SHELL-ROUTINES (SHELL-NAME BTM-FN-SYMB RECOGNIZER 
> DESTRUCTOR-TUPLES)
>   (PROG
>    NIL
>    (COND (IN-BOOT-STRAP-FLG
>           (ITERATE FOR NAME
>                    IN (CONS SHELL-NAME
>                             (CONS RECOGNIZER
>                                   (APPEND (ITERATE FOR X IN DESTRUCTOR-TUPLES
>                                                    COLLECT (CAR X))
>                                           (COND (BTM-FN-SYMB
>                                                  (LIST BTM-FN-SYMB))
>                                                 (T NIL)))))
>                    DO (ADD-FACT NAME (QUOTE LISP-CODE)
>                                 (PACK (LIST PREFIX-FOR-FUNCTIONS NAME)))
>                    (GUARANTEE-CITIZENSHIP
>                     (PACK (LIST PREFIX-FOR-FUNCTIONS NAME))))
>           (RETURN NIL)))
>    (AND BTM-FN-SYMB
>         (ADD-DCELL BTM-FN-SYMB
>                    (PACK (LIST PREFIX-FOR-FUNCTIONS BTM-FN-SYMB))
>                    (SUB-PAIR (QUOTE (*1*SHELL-QUOTE-MARK BTM))
>                              (LIST *1*SHELL-QUOTE-MARK BTM-FN-SYMB)
>                              (QUOTE (LAMBDA NIL
>                                       (QUOTE (*1*SHELL-QUOTE-MARK BTM)))))))
>    (ADD-DCELL
>     RECOGNIZER
>     (PACK (LIST PREFIX-FOR-FUNCTIONS RECOGNIZER))
>     (COND (BTM-FN-SYMB
>            (SUB-PAIR (QUOTE (SHELL-NAME BTM))
>                      (LIST SHELL-NAME BTM-FN-SYMB)
>                      (QUOTE (LAMBDA (X)
>                               (COND ((AND (CONSP X)
>                                           (EQ (CAR X)
>                                               *1*SHELL-QUOTE-MARK)
>                                           (OR (EQ (CADR X)
>                                                   (QUOTE SHELL-NAME))
>                                               (EQ (CADR X)
>                                                   (QUOTE BTM))))
>                                      *1*T)
>                                     (T *1*F))))))
>           (T (SUB-PAIR (QUOTE (SHELL-NAME))
>                        (LIST SHELL-NAME)
>                        (QUOTE (LAMBDA (X)
>                                 (COND ((AND (CONSP X)
>                                             (EQ (CAR X)
>                                                 *1*SHELL-QUOTE-MARK)
>                                             (EQ (CADR X)
>                                                 (QUOTE SHELL-NAME)))
>                                        *1*T)
>                                       (T *1*F))))))))
>    (ITERATE FOR TUPLE IN DESTRUCTOR-TUPLES AS I FROM 2 DO
>             (ADD-DCELL
>              (CAR TUPLE)
>              (PACK (LIST PREFIX-FOR-FUNCTIONS (CAR TUPLE)))
>              (SUB-PAIR (QUOTE (R CELL DV BTM))
>                        (LIST (PACK (LIST PREFIX-FOR-FUNCTIONS RECOGNIZER))
>                              (CELL I (QUOTE X))
>                              (PACK (LIST PREFIX-FOR-FUNCTIONS (CADDR TUPLE)))
>                              BTM-FN-SYMB)
>                        (COND (BTM-FN-SYMB
>                               (QUOTE (LAMBDA (X)
>                                        (COND ((AND (EQ (R X) *1*T)
>                                                    (NOT (EQ (CADR X)
>                                                             (QUOTE BTM))))
>                                               (CAR CELL))
>                                              (T (DV))))))
>                              (T (QUOTE (LAMBDA (X)
>                                          (COND ((EQ (R X) *1*T)
>                                                 (CAR CELL))
>                                                (T (DV))))))))))
>    (ADD-DCELL
>     SHELL-NAME
>     (PACK (LIST PREFIX-FOR-FUNCTIONS SHELL-NAME))
>     (LIST
>      (QUOTE LAMBDA)
>      (ITERATE FOR X IN DESTRUCTOR-TUPLES COLLECT (CAR X))
>      (CONS
>       (QUOTE LIST)
>       (CONS
>        (QUOTE *1*SHELL-QUOTE-MARK)   ;;;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
>        (CONS
>         (LIST (QUOTE QUOTE)
>               SHELL-NAME)
>         (ITERATE FOR TUPLE IN DESTRUCTOR-TUPLES WITH TEMP
>                  COLLECT
>                  (PROGN
>                    (SETQ
>                     TEMP
>                     (CONS (QUOTE OR)
>                           (ITERATE FOR R IN (CDR (CADR TUPLE))
>                                    COLLECT (LIST (QUOTE EQ)
>                                                  (QUOTE *1*T)
>                                                  (LIST
>                                                   (PACK
>                                                    (LIST
>                                                     PREFIX-FOR-FUNCTIONS R))
>                                                   (CAR TUPLE))))))
>                    (COND ((NULL (CDR TEMP))
>                           (COND ((EQ (CAR (CADR TUPLE))
>                                      (QUOTE ONE-OF))
>                                  (LIST (PACK (LIST PREFIX-FOR-FUNCTIONS
>                                                    (CADDR TUPLE)))))
>                                 (T (CAR TUPLE))))
>                          (T (LIST (QUOTE IF)
>                                   (COND ((EQ (CAR (CADR TUPLE))
>                                              (QUOTE ONE-OF))
>                                          TEMP)
>                                         (T (LIST (QUOTE NOT)
>                                                  TEMP)))
>                                   (CAR TUPLE)
>                                   (LIST (PACK (LIST PREFIX-FOR-FUNCTIONS
>                                                     (CADDR TUPLE))))))))))))))
>     
>    (RETURN NIL)))
> 
> 
> 
> 

-- 
Camm Maguire                                            address@hidden
==========================================================================
"The earth is but one country, and mankind its citizens."  --  Baha'u'llah