Subject: cl-series: Build error: illegal function call
From: "Karl M. Hegbloom" <[email-masked]>
To: Debian Bug Tracking System <[email-masked]>
Date: Thu, 01 May 2003 19:57:11 -0700

Package: cl-series
Version: 1:2.2.7-1
Severity: normal

Hello

This is the clc-build-daemon reporting a build failure.

While recompiling package series for compiler sbcl I got the error code 1
If you want to retry the compilation and possibly report this as a bug
then please read /usr/share/doc/common-lisp-controller/REPORTING-BUGS

The command to retry the recompilation is:
clc-send-command --verbose remove series sbcl ; echo returns: $?
clc-send-command --verbose recompile series sbcl ; echo returns: $?

After this message I will append the last few lines of output.

Thanks for your attention
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::ARG)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN OFF-LINE-MERGE
; compiling top level form: 
; compiling COMMON-LISP:DEFUN OFF-LINE-MERGE: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN OFF-LINE-MERGE
;     (SERIES::FR SERIES::A)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.
; [Last message occurs 2 times.]

;     (SERIES::FR SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN SPLIT-AFTER
; compiling top level form: 
; compiling COMMON-LISP:DEFUN SPLIT-AFTER: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN SPLIT-AFTER
;     (SERIES::PRV SERIES::A)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::R)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.
; [Last message occurs 3 times.]

;     (SERIES::NXTS SERIES::R)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::A)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (FUNCALL SERIES::CROSSABLE SERIES::R SERIES::A)
; --> SB-C::%FUNCALL 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;         optimize away possible call to FDEFINITION at runtime
;       due to type uncertainty:
;         The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (SERIES::FR SERIES::A)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.
; [Last message occurs 2 times.]

; compiling top level form: 
; recognizing DEFUN DO-NON-SERIES-DFLOW-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DO-NON-SERIES-DFLOW-SPLIT: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN DO-NON-SERIES-DFLOW-SPLIT
;     (SERIES::FR SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::ARG)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; compiling DEFMACRO DOING-SPLITTING: 
; compiling top level form: 
; compiling DEFMACRO DOING-SPLITTING1: 
; compiling top level form: 
; recognizing DEFUN NON-SERIES-DFLOW-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN NON-SERIES-DFLOW-SPLIT: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN NON-SERIES-DFLOW-SPLIT
;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::ARG)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN DISCONNECTED-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DISCONNECTED-SPLIT: 
; compiling top level form: 
; recognizing DEFUN ORDER-NUM
; compiling top level form: 
; compiling DEFINLINE ORDER-NUM: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: DEFINLINE ORDER-NUM
;     (POSITION (CAR (LAST SERIES::FRAGS)) SERIES::*GRAPH*)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a VECTOR.

; compiling top level form: 
; recognizing DEFUN REORDER-FRAGS
; compiling top level form: 
; compiling COMMON-LISP:DEFUN REORDER-FRAGS: 
; compiling top level form: 
; recognizing DEFUN INSERT-OFF-LINE-DUMMY-FRAG
; compiling top level form: 
; compiling COMMON-LISP:DEFUN INSERT-OFF-LINE-DUMMY-FRAG: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN INSERT-OFF-LINE-DUMMY-FRAG
;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR (CAR (SERIES::NXTS SERIES::RET)))
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN DO-OFF-LINE-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DO-OFF-LINE-SPLIT: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN DO-OFF-LINE-SPLIT
;     (SERIES::FR SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::ARG)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN OFF-LINE-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN OFF-LINE-SPLIT: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN OFF-LINE-SPLIT
;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::ARG)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN NON-SERIES-SPLIT
; compiling top level form: 
; compiling COMMON-LISP:DEFUN NON-SERIES-SPLIT: 
; compiling top level form: 
; recognizing DEFUN DO-SPLITTING
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DO-SPLITTING: 
; compiling top level form: 
; recognizing DEFUN AUX-ORDERING
; compiling top level form: 
; compiling COMMON-LISP:DEFUN AUX-ORDERING: 
; compiling top level form: 
; recognizing DEFUN USE-USER-NAMES
; compiling top level form: 
; compiling COMMON-LISP:DEFUN USE-USER-NAMES: 
; compiling top level form: 
; recognizing DEFUN LIFTABLE-VAR-P
; compiling top level form: 
; compiling COMMON-LISP:DEFUN LIFTABLE-VAR-P: 
; compiling top level form: 
; recognizing DEFUN FIND-OUT-VARS
; compiling top level form: 
; compiling COMMON-LISP:DEFUN FIND-OUT-VARS: 
; compiling top level form: 
; recognizing DEFUN FIND-INITIALIZERS
; compiling top level form: 
; in: LAMBDA NIL
;     (FIND (SECOND (FIRST LIST)) SERIES::VARS-TO-INIT)
; --> NTH-VALUE MULTIPLE-VALUE-BIND LET 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a VECTOR.
; compiling COMMON-LISP:DEFUN FIND-INITIALIZERS: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN FIND-INITIALIZERS
;     (FIND (SECOND (FIRST LIST)) SERIES::VARS-TO-INIT)
; --> NTH-VALUE MULTIPLE-VALUE-BIND LET 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;         expand inline
;       due to type uncertainty:
;         The second argument is a SEQUENCE, not a VECTOR.

; compiling top level form: 
; recognizing DEFUN REMOVE-INITIALIZERS
; compiling top level form: 
; compiling COMMON-LISP:DEFUN REMOVE-INITIALIZERS: 
; compiling top level form: 
; recognizing DEFUN LIFT-OUT-VARS
; compiling top level form: 
; compiling COMMON-LISP:DEFUN LIFT-OUT-VARS: 
; compiling top level form: 
; compiling top level form: 
; compiling top level form: 
; compiling top level form: 
; recognizing DEFUN CODIFY
; compiling top level form: 
; compiling COMMON-LISP:DEFUN CODIFY: 
; compiling top level form: 
; recognizing DEFUN PRECOMPUTE-FRAG->PHYSICAL
; compiling top level form: 
; compiling COMMON-LISP:DEFUN PRECOMPUTE-FRAG->PHYSICAL: 
; compiling top level form: 
; recognizing DEFUN F->P-OFF-LINE
; compiling top level form: 
; compiling COMMON-LISP:DEFUN F->P-OFF-LINE: 
; compiling top level form: 
; recognizing DEFUN F->P-ON-LINE
; compiling top level form: 
; compiling COMMON-LISP:DEFUN F->P-ON-LINE: 
; compiling top level form: 
; recognizing DEFUN IMAGE-OF-NON-NULL-DATUM-TH
; compiling top level form: 
; compiling COMMON-LISP:DEFUN IMAGE-OF-NON-NULL-DATUM-TH: 
; compiling top level form: 
; compiling top level form: 
; compiling COMMON-LISP:DEFUN CAR-IMAGE-OF-NON-NULL-DATUM-TH: 
; compiling top level form: 
; recognizing DEFUN SERIES-FRAG->PHYSICAL
; compiling top level form: 
; compiling COMMON-LISP:DEFUN SERIES-FRAG->PHYSICAL: 
; compiling top level form: 
; recognizing DEFUN FRAG->PHYSICAL
; compiling top level form: 
; compiling COMMON-LISP:DEFUN FRAG->PHYSICAL: 
; compiling top level form: 
; recognizing DEFUN MERGIFY
; compiling top level form: 
; compiling COMMON-LISP:DEFUN MERGIFY: 
; compiling top level form: 
; recognizing DEFUN PREPROCESS-BODY
; compiling top level form: 
; compiling COMMON-LISP:DEFUN PREPROCESS-BODY: 

; file: /usr/share/common-lisp/source/series/s-code.lisp
; in: COMMON-LISP:DEFUN PREPROCESS-BODY
;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SETF (SERIES::PRV SERIES::ARG) NIL)
; --> LET* MULTIPLE-VALUE-BIND LET SB-KERNEL:%ASET LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::NXTS SERIES::RET)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

;     (SERIES::FR SERIES::A)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;         avoid runtime dispatch on array element type
;       because:
;         Upgraded element type of array is not known at compile time.

; compiling top level form: 
; recognizing DEFUN COMPUTE-OPTIMIZABLE-SERIES-FN
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-OPTIMIZABLE-SERIES-FN: 
; compiling top level form: 
; recognizing DEFUN DEFINE-OPTIMIZABLE-SERIES-FN
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DEFINE-OPTIMIZABLE-SERIES-FN: 
; compiling top level form: 
; recognizing DEFUN UNDEFINE-OPTIMIZABLE-SERIES-FN
; compiling top level form: 
; compiling COMMON-LISP:DEFUN UNDEFINE-OPTIMIZABLE-SERIES-FN: 
; compiling top level form: 
; compiling DEFMACRO DEFUN: 
; compiling top level form: 
; recognizing DEFUN COMPUTE-PROLOGING-MACFORM
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-PROLOGING-MACFORM: 
; compiling top level form: 
; recognizing DEFUN COMPUTE-SERIES-FUNFORM
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-SERIES-FUNFORM: 
; compiling top level form: 
; recognizing DEFUN COMPUTE-SERIES-MACFORM-2
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-SERIES-MACFORM-2: 
; compiling top level form: 
; recognizing DEFUN COMPUTE-SERIES-MACFORM-1
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-SERIES-MACFORM-1: 
; compiling top level form: 
; recognizing DEFUN COMPUTE-SERIES-MACFORM
; compiling top level form: 
; compiling COMMON-LISP:DEFUN COMPUTE-SERIES-MACFORM: 
; compiling top level form: 
; recognizing DEFUN DEFS-1
; compiling top level form: 
; compiling COMMON-LISP:DEFUN DEFS-1: 
; compiling top level form: 
; compiling DEFMACRO DEFS: 
; compiling top level form: 
; compiling DEFMACRO SLET1: 
; compiling top level form: 
; compiling DEFMACRO SLET*: 
; compiling top level form: 
; recognizing DEFUN APPLY-LITERAL-FRAG
; compiling top level form: 
; compiling COMMON-LISP:DEFUN APPLY-LITERAL-FRAG: 
; compiling top level form: 
; compiling DEFMACRO OPTIF: 
; compiling top level form: 
; compiling DEFMACRO EOPTIF: 
; compiling top level form: 
; compiling DEFMACRO EOPTIF-Q: 
; compiling top level form: 
; compiling DEFMACRO OPTIF-Q: 
; compiling top level form: 
; compiling DEFMACRO NON-OPTQ: 
; compiling top level form: 
; compiling DEFMACRO OPTQ: 
; compiling top level form: 
; recognizing DEFUN APPLY-PHYSICAL-FRAG
; compiling top level form: 
; compiling COMMON-LISP:DEFUN APPLY-PHYSICAL-FRAG: 
; compiling top level form: 
; recognizing DEFUN FUNCALL-PHYSICAL-FRAG
; compiling top level form: 
; compiling COMMON-LISP:DEFUN FUNCALL-PHYSICAL-FRAG: 
; compiling top level form: 
; compiling top level form: 
; recognizing DEFUN UNOPT-FRAGL
; compiling top level form: 
; compiling COMMON-LISP:DEFUN UNOPT-FRAGL: 
; compiling top level form: 
; recognizing DEFUN OPT-FRAGL
; compiling top level form: 
; compiling COMMON-LISP:DEFUN OPT-FRAGL: 
; compiling top level form: 
; recognizing DEFUN FRAGL-2
; compiling top level form: 
; compiling COMMON-LISP:DEFUN FRAGL-2: 
; compiling top level form: 
; compiling DEFMACRO EFRAGL: 
; compiling top level form: 
; compiling top level form: 
; recognizing DEFUN FRAGL-1
; compiling top level form: 
; compiling COMMON-LISP:DEFUN FRAGL-1: 
; compiling top level form: 
; recognizing DEFUN SUBLIS-LIMITS
; compiling top level form: 
; compiling COMMON-LISP:DEFUN SUBLIS-LIMITS: 
; compiling top level form: 
; recognizing DEFUN *FRAGL-1
; compiling top level form: 
; compiling COMMON-LISP:DEFUN *FRAGL-1: 
; compiling top level form: 
; compiling DEFMACRO FRAGL: 
; compiling top level form: 
; compiling DEFMACRO *FRAGL: 
; compiling top level form: 
; compiling DEFS COLLECT: 
; compiling top level form: 
; compiling top level form: 
; compilation aborted after 0:00:21
; compilation unit aborted
;   caught 3 fatal ERROR conditions
;   caught 1 STYLE-WARNING condition
;   printed 218 notes
Build error: illegal function call
Build failure 
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)

-- System Information:
Debian Release: testing/unstable
Architecture: i386
Kernel: Linux bittersweet.hegbloom.net 2.4.20.1-smp #1 SMP Mon Feb 17 15:19:24 PST 2003 i686
Locale: LANG=C, LC_CTYPE=C (ignored: LC_ALL set)

Versions of packages cl-series depends on:
ii  cl-asdf                       1.68       Another System Definition Facility
ii  common-lisp-controller        3.61       This is a Common Lisp source and c

-- no debconf information