From: Rene de Visser
Subject: slime: clisp stack trace
Date: 
Message-ID: <cnki5j$s8v$1@news.sap-ag.de>
When I do a stack trace direct in clisp (win32 version 2.33.1) after a
particular simple error occurs, I get a stack trace with 71 stack frames.

In slime I only get the two top most frames.

Also in slime I don't see the parameter values of the functions calls.

A known problem? Or a user error?

Rene.

From: Pascal Bourguignon
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <87fz35kfys.fsf@thalassa.informatimago.com>
"Rene de Visser" <··············@hotmail.de> writes:

> When I do a stack trace direct in clisp (win32 version 2.33.1) after a
> particular simple error occurs, I get a stack trace with 71 stack frames.
> 
> In slime I only get the two top most frames.
> 
> Also in slime I don't see the parameter values of the functions calls.
> 
> A known problem? Or a user error?

Slime adds frames when you move the cursor down the backtrace.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
The world will now reboot; don't bother saving your artefacts.
From: Rene de Visser
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <cnl4mm$e28$1@news.sap-ag.de>
"Pascal Bourguignon" <····@mouse-potato.com> wrote in message
···················@thalassa.informatimago.com...
> "Rene de Visser" <··············@hotmail.de> writes:
>
> > When I do a stack trace direct in clisp (win32 version 2.33.1) after a
> > particular simple error occurs, I get a stack trace with 71 stack
frames.
> >
> > In slime I only get the two top most frames.
> >
> > Also in slime I don't see the parameter values of the functions calls.
> >
> > A known problem? Or a user error?
>
> Slime adds frames when you move the cursor down the backtrace.
>
> -- 
> __Pascal Bourguignon__                     http://www.informatimago.com/
> The world will now reboot; don't bother saving your artefacts.

Not in this case I think. For starters I want to move up and not down.

I have a frame 0 which is (compile-file "...")

However if I execute outside of slime i have a further 71 stack frames above
this which show
where the error occured inside of (compile-file "...").

i.e. executing outside of slime (compile-file "...") is frame 71.

Its like slime has already unwound the stack to this point.

For example if I use 'B' to get to the normal clisp debugger, the frames
aren't there either.

Its like they have been unwound already.

It only works properly if I don't have slime running at all.

Maybe slime over-rides compile-file with its own version that has some bad
side effects for debugging?

Rene.
From: Rene de Visser
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <cnl5aq$ek4$1@news.sap-ag.de>
"Rene de Visser" <··············@hotmail.de> wrote in message
·················@news.sap-ag.de...
>

> For example if I use 'B' to get to the normal clisp debugger, the frames
> aren't there either.

Correction to that. They ARE there in the clisp debugger. Just for some
reason they don't show up in slime.

Rene.
From: Pascal Bourguignon
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <87actdk6dg.fsf@thalassa.informatimago.com>
"Rene de Visser" <··············@hotmail.de> writes:

> "Pascal Bourguignon" <····@mouse-potato.com> wrote in message
> ···················@thalassa.informatimago.com...
> > "Rene de Visser" <··············@hotmail.de> writes:
> >
> > > When I do a stack trace direct in clisp (win32 version 2.33.1) after a
> > > particular simple error occurs, I get a stack trace with 71 stack
> frames.
> > >
> > > In slime I only get the two top most frames.
> > >
> > > Also in slime I don't see the parameter values of the functions calls.
> > >
> > > A known problem? Or a user error?
> >
> > Slime adds frames when you move the cursor down the backtrace.
> >
> > -- 
> > __Pascal Bourguignon__                     http://www.informatimago.com/
> > The world will now reboot; don't bother saving your artefacts.
> 
> Not in this case I think. For starters I want to move up and not down.
> 
> I have a frame 0 which is (compile-file "...")
> 
> However if I execute outside of slime i have a further 71 stack frames above
> this which show
> where the error occured inside of (compile-file "...").
> 
> i.e. executing outside of slime (compile-file "...") is frame 71.
> 
> Its like slime has already unwound the stack to this point.
> 
> For example if I use 'B' to get to the normal clisp debugger, the frames
> aren't there either.
> 
> Its like they have been unwound already.
> 
> It only works properly if I don't have slime running at all.
> 
> Maybe slime over-rides compile-file with its own version that has some bad
> side effects for debugging?
> 
> Rene.
> 


CLISP TEST> (defun fact (x) (if (= 0 x) (/ x 0) (* x (fact (1- x)))))
FACT
CLISP TEST> (fact 4)

--> sldb:
 
division by zero
   [Condition of type SYSTEM::SIMPLE-DIVISION-BY-ZERO]

Restarts:
  0: [ABORT] Abort handling SLIME request.

Backtrace:
  0: frame binding variables (~ = dynamically):
  | ~ SYSTEM::*FASOUTPUT-STREAM* <--> NIL
  1: EVAL frame for form (/ X 0)
  2: EVAL frame for form (IF (= 0 X) (/ X 0) (* X (FACT (1- X))))
  3: APPLY frame for call (FACT '0)
  4: EVAL frame for form (FACT (1- X))
  5: EVAL frame for form (* X (FACT (1- X)))
  6: EVAL frame for form (IF (= 0 X) (/ X 0) (* X (FACT (1- X))))
  7: APPLY frame for call (FACT '1)
  8: EVAL frame for form (FACT (1- X))
  9: EVAL frame for form (* X (FACT (1- X)))
  10: EVAL frame for form (IF (= 0 X) (/ X 0) (* X (FACT (1- X))))
  11: APPLY frame for call (FACT '2)
  12: EVAL frame for form (FACT (1- X))
  13: EVAL frame for form (* X (FACT (1- X)))
  14: EVAL frame for form (IF (= 0 X) (/ X 0) (* X (FACT (1- X))))
  15: APPLY frame for call (FACT '3)
  16: EVAL frame for form (FACT (1- X))
  17: EVAL frame for form (* X (FACT (1- X)))
  18: EVAL frame for form (IF (= 0 X) (/ X 0) (* X (FACT (1- X))))
  19: APPLY frame for call (FACT '4)
  20: EVAL frame for form (FACT 4)
  21: EVAL frame for form (SWANK:LISTENER-EVAL "(fact 4)
")
  22: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")
  23: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")



CLISP TEST> (compile 'fact)
--> sldb (during compilation):

division by zero
   [Condition of type SYSTEM::SIMPLE-DIVISION-BY-ZERO]

Restarts:
  0: [ABORT] Abort handling SLIME request.

Backtrace:
  0: frame binding variables (~ = dynamically):
  | ~ SYSTEM::*FASOUTPUT-STREAM* <--> NIL
  1: EVAL frame for form (COMPILE 'FACT)
  2: EVAL frame for form (SWANK:LISTENER-EVAL "(compile 'fact)
")
  3: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")
  4: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")



CLISP TEST> (defun fact (x) (if (= 0 x) (/ x *var*) (* x (fact (1- x)))))
FACT
CLISP TEST> (compile 'fact)

WARNING in FACT :
*VAR* is neither declared nor bound,
it will be treated as if it were declared SPECIAL.
FACT
1
1
CLISP TEST> (defvar *var* 0)
*VAR*
CLISP TEST> (fact 4)

--> sldb:

division by zero
   [Condition of type SYSTEM::SIMPLE-DIVISION-BY-ZERO]

Restarts:
  0: [ABORT] Abort handling SLIME request.

Backtrace:
  0: frame binding variables (~ = dynamically):
  | ~ SYSTEM::*FASOUTPUT-STREAM* <--> NIL
  1: EVAL frame for form (FACT 4)
  2: EVAL frame for form (SWANK:LISTENER-EVAL "(fact 4)
")
  3: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")
  4: EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")


So, is that this difference between the first backtrace and this later
backtrace you're complaining about?  It does not depend on slime, it's
the way clisp works.  It has simplified tail-recursion (and can simply
some other tail-calls and other stack frames) in compiled code.



Even if you go back to the clisp debugger,  the interperter backtrace
is more informative than the compiled backtrace:


interpreted:


*** - division by zero
The following restarts are available:
ABORT          :R1      Abort handling SLIME request.

Break 1 [3]> :bt

<1> #<SYSTEM-FUNCTION EXT:SHOW-STACK>
<2> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE>
<3> #<SYSTEM-FUNCTION SYSTEM::READ-EVAL-PRINT>
<4> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2-1>
<5> #<SYSTEM-FUNCTION SYSTEM::SAME-ENV-AS>
<6> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2>
<7> #<SYSTEM-FUNCTION SYSTEM::DRIVER>
<8> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP>
<9> #<SYSTEM-FUNCTION INVOKE-DEBUGGER>
<10> #<SYSTEM-FUNCTION /> 1
<11> #<SPECIAL-OPERATOR IF>
EVAL frame for form (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X))))
APPLY frame for call (FACT '0)
EVAL frame for form (FACT (1- X))
<12> 
#<CLOSURE FACT (X) (DECLARE (SYSTEM::IN-DEFUN FACT))
  (BLOCK FACT (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X)))))> 1
EVAL frame for form (* X (FACT (1- X)))
<13> #<SPECIAL-OPERATOR IF>
EVAL frame for form (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X))))
APPLY frame for call (FACT '1)
EVAL frame for form (FACT (1- X))
<14> 
#<CLOSURE FACT (X) (DECLARE (SYSTEM::IN-DEFUN FACT))
  (BLOCK FACT (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X)))))> 1
EVAL frame for form (* X (FACT (1- X)))
<15> #<SPECIAL-OPERATOR IF>
EVAL frame for form (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X))))
APPLY frame for call (FACT '2)
EVAL frame for form (FACT (1- X))
<16> 
#<CLOSURE FACT (X) (DECLARE (SYSTEM::IN-DEFUN FACT))
  (BLOCK FACT (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X)))))> 1
EVAL frame for form (* X (FACT (1- X)))
<17> #<SPECIAL-OPERATOR IF>
EVAL frame for form (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X))))
APPLY frame for call (FACT '3)
EVAL frame for form (FACT (1- X))
<18> 
#<CLOSURE FACT (X) (DECLARE (SYSTEM::IN-DEFUN FACT))
  (BLOCK FACT (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X)))))> 1
EVAL frame for form (* X (FACT (1- X)))
<19> #<SPECIAL-OPERATOR IF>
EVAL frame for form (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X))))
APPLY frame for call (FACT '4)
EVAL frame for form (FACT 4)
<20> 
#<CLOSURE FACT (X) (DECLARE (SYSTEM::IN-DEFUN FACT))
  (BLOCK FACT (IF (= 0 X) (/ X *VAR*) (* X (FACT (1- X)))))> 1
EVAL frame for form 
(SWANK:LISTENER-EVAL
 "(fact 4)
")
<21> #<SYSTEM-FUNCTION EVAL>
<22> #<COMPILED-CLOSURE SWANK::EVAL-REGION>
<23> #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
<24> #<COMPILED-CLOSURE #:|(DEFINTERFACE CALL-WITH-SYNTAX-HOOKS (FN) ...)-29-3-1-1|>
<25> #<GENERIC-FUNCTION SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS>
<26> #<COMPILED-CLOSURE SWANK:LISTENER-EVAL>
EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")
<27> #<SYSTEM-FUNCTION EVAL>
<28> #<COMPILED-CLOSURE SWANK::EVAL-FOR-EMACS>
<29> #<SYSTEM-FUNCTION FUNCALL> 3
<30> #<COMPILED-CLOSURE SWANK::READ-FROM-EMACS>
<31> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
<32> #<COMPILED-CLOSURE SWANK::CALL-WITH-REDIRECTED-IO>
<33> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST>
<34> #<COMPILED-CLOSURE SWANK::SIMPLE-SERVE-REQUESTS>
<35> #<COMPILED-CLOSURE SWANK::SERVE-REQUESTS>
<36> #<COMPILED-CLOSURE SWANK::SERVE-CONNECTION>
<37> #<COMPILED-CLOSURE SWANK::SETUP-SERVER>
<38> #<COMPILED-CLOSURE SWANK:START-SERVER>
Printed 38 frames
Break 1 [3]> 


compiled:

*** - division by zero
The following restarts are available:
ABORT          :R1      Abort handling SLIME request.

Break 1 TEST[4]> :bt

<1> #<SYSTEM-FUNCTION EXT:SHOW-STACK>
<2> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE>
<3> #<SYSTEM-FUNCTION SYSTEM::READ-EVAL-PRINT>
<4> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2-1>
<5> #<SYSTEM-FUNCTION SYSTEM::SAME-ENV-AS>
<6> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2>
<7> #<SYSTEM-FUNCTION SYSTEM::DRIVER>
<8> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP>
<9> #<SYSTEM-FUNCTION INVOKE-DEBUGGER>
<10> #<SYSTEM-FUNCTION /> 1
<11> #<COMPILED-CLOSURE FACT>
<12> #<COMPILED-CLOSURE FACT>
<13> #<COMPILED-CLOSURE FACT>
<14> #<COMPILED-CLOSURE FACT>
<15> #<COMPILED-CLOSURE FACT>
EVAL frame for form 
(SWANK:LISTENER-EVAL
 "(fact 4)
")
<16> #<SYSTEM-FUNCTION EVAL>
<17> #<COMPILED-CLOSURE SWANK::EVAL-REGION>
<18> #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
<19> #<COMPILED-CLOSURE #:|(DEFINTERFACE CALL-WITH-SYNTAX-HOOKS (FN) ...)-29-3-1-1|>
<20> #<GENERIC-FUNCTION SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS>
<21> #<COMPILED-CLOSURE SWANK:LISTENER-EVAL>
EVAL frame for form (SWANK:START-SERVER "/tmp/slime.22876")
<22> #<SYSTEM-FUNCTION EVAL>
<23> #<COMPILED-CLOSURE SWANK::EVAL-FOR-EMACS>
<24> #<SYSTEM-FUNCTION FUNCALL> 3
<25> #<COMPILED-CLOSURE SWANK::READ-FROM-EMACS>
<26> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
<27> #<COMPILED-CLOSURE SWANK::CALL-WITH-REDIRECTED-IO>
<28> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST>
<29> #<COMPILED-CLOSURE SWANK::SIMPLE-SERVE-REQUESTS>
<30> #<COMPILED-CLOSURE SWANK::SERVE-REQUESTS>
<31> #<COMPILED-CLOSURE SWANK::SERVE-CONNECTION>
<32> #<COMPILED-CLOSURE SWANK::SETUP-SERVER>
<33> #<COMPILED-CLOSURE SWANK:START-SERVER>
Printed 33 frames
Break 1 TEST[4]> 


with 5 frames less.


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
The world will now reboot; don't bother saving your artefacts.
From: Rene de Visser
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <cnqt8b$65p$04$1@news.t-online.com>
"Pascal Bourguignon" <····@mouse-potato.com> schrieb im Newsbeitrag 
···················@thalassa.informatimago.com...
> "Rene de Visser" <··············@hotmail.de> writes:
>
>> "Pascal Bourguignon" <····@mouse-potato.com> wrote in message
>> ···················@thalassa.informatimago.com...
>> > "Rene de Visser" <··············@hotmail.de> writes:

>
> Even if you go back to the clisp debugger,  the interperter backtrace
> is more informative than the compiled backtrace:
>

 In Slime I get the following:

SYSTEM::%STRUCTURE-REF: NIL is not a structure of type DBOBJECT
   [Condition of type SIMPLE-TYPE-ERROR]

Restarts:
  0: [ABORT] Abort handling SLIME request.

Backtrace:
  0: frame binding variables (~ = dynamically):
  | ~ SYSTEM::*FASOUTPUT-STREAM* <--> #<OUTPUT BUFFERED FILE-STREAM 
CHARACTER #P"C:\\lisp\\ap5\\clisp-bin\\relation.fsl">
  1: EVAL frame for form (COMPILE-FILE (SOURCE FILE) :OUTPUT-FILE (BIN 
FILE))
  2: EVAL frame for form (COND (INFO) ((ASK " ? ") (COMPILE-FILE (SOURCE 
FILE) :OUTPUT-FILE (BIN FILE)) (SHOW-TIME) T))
  3: EVAL frame for form (PROGN (LOADFILE FILE RELOAD) (FORMAT T 
"~%Compiling ~A" (SOURCE FILE)) (COND (INFO) ((ASK " ? ") (COMPILE-FILE # 
:OUTPUT-FILE #) (SHOW-TIME) T)))
  4: APPLY frame for call (COMPILE-FILE* '"relations" 'T)
  5: EVAL frame for form (COMPILE-FILE* FILE T)
  6: EVAL frame for form (AND (COMPILE? FILE) (COMPILE-FILE* FILE T))
  7: EVAL frame for form (COND ((AND (COMPILE? FILE) (COMPILE-FILE* FILE 
T))) (T (FASLOAD* FILE T)))
  8: EVAL frame for form (WHEN (AND (START? FILE) (NOTSTOP? FILE)) (FORMAT T 
"~2%Load-Compile or Load file: ~a" FILE) (COND ((AND # #)) (T (FASLOAD* FILE 
T))))
... (chopped for posting)
  15: APPLY frame for call (COMPILE-AP5)
  16: EVAL frame for form (COMPILE-AP5)
  17: EVAL frame for form (SWANK:LISTENER-EVAL "(compile-ap5)
")
  18: EVAL frame for form (SWANK:START-SERVER 
"C:\\DOKUME~1\\Rened\\LOKALE~1\\Temp\\slime.2088")

These look like all interpreted frames to me. Note that the top frame is 
compile-file.
Switching to Clisp with Shift B.

Break 1 AP5[3]> :bt5

<1> #<SYSTEM-FUNCTION EXT:SHOW-STACK>
<2> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE>
<3> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE-5>
<4> #<SYSTEM-FUNCTION SYSTEM::READ-EVAL-PRINT>
<5> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2-1>
<6> #<SYSTEM-FUNCTION SYSTEM::SAME-ENV-AS>
<7> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2>
<8> #<SYSTEM-FUNCTION SYSTEM::DRIVER>
<9> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP>
<10> #<SYSTEM-FUNCTION INVOKE-DEBUGGER>
<11> #<SYSTEM-FUNCTION SYSTEM::%STRUCTURE-REF>
<12> #<COMPILED-CLOSURE GETBASEDATA>
<13> #<COMPILED-CLOSURE |Test-INLINEREL|>
<14> #<COMPILED-CLOSURE TESTREL>
<15> #<COMPILED-CLOSURE INLINEREL?>
<16> #<COMPILED-CLOSURE EXPANDDESCRIPTION-EXPANDWFF-6>
<17> #<COMPILED-CLOSURE MAP-WFF-INTERNAL>
<18> #<SYSTEM-FUNCTION MAPCAR> 0
<19> #<COMPILED-CLOSURE MAP-COPY-WFF-2>
<20> #<COMPILED-CLOSURE MAP-WFF-INTERNAL>
<21> #<COMPILED-CLOSURE MAP-COPY-WFF>
<22> #<COMPILED-CLOSURE EXPANDDESCRIPTION-EXPANDWFF>
<23> #<COMPILED-CLOSURE EXPANDDESCRIPTION>
<24> #<COMPILED-CLOSURE TRANSLATE??>
<25> #<COMPILED-CLOSURE ??>
<26> #<COMPILED-CLOSURE SYSTEM::%EXPAND-MACRO>
...chopped fpr posting
<73> #<COMPILED-CLOSURE SYSTEM::%EXPAND-FORM>
<74> #<COMPILED-CLOSURE EXT:EXPAND-FORM>
<75> #<COMPILED-CLOSURE MEXPAND-ALL>
<76> #<COMPILED-CLOSURE DEFUN>
<77> #<SYSTEM-FUNCTION FUNCALL> 2
<78> #<COMPILED-CLOSURE SYSTEM::COMPILE-TOPLEVEL-FORM>
<79> #<COMPILED-CLOSURE COMPILE-FILE>
SYSTEM::%STRUCTURE-REF: NIL is not a structure of type DBOBJECT
   [Condition of type SIMPLE-TYPE-ERROR]

------------------------------------
Note that with :bt5 conpile-file is the bottom frame. Strange!
or

Break 1 AP5[3]> :bt1

<1> #<SYSTEM-FUNCTION EXT:SHOW-STACK>
<2> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE>#
<3> #<COMPILED-CLOSURE SYSTEM::DEBUG-BACKTRACE-1>
<4> #<SYSTEM-FUNCTION SYSTEM::READ-EVAL-PRINT>
<5> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2-1>
<6> #<SYSTEM-FUNCTION SYSTEM::SAME-ENV-AS>
<7> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP-2>
<8> #<SYSTEM-FUNCTION SYSTEM::DRIVER>
- T
<9> #<COMPILED-CLOSURE SYSTEM::BREAK-LOOP>
- #<SIMPLE-TYPE-ERROR #x19F514CD>
- NIL
- #<SIMPLE-TYPE-ERROR #x19F514CD>
<10> #<SYSTEM-FUNCTION INVOKE-DEBUGGER>
frame binding variables (~ = dynamically):
  | ~ SYSTEM::*PRIN-STREAM* <--> #<UNBOUND>
frame binding variables (~ = dynamically):
  | ~ *PRINT-READABLY* <--> NIL
frame binding variables (~ = dynamically):
  | ~ *PRINT-ESCAPE* <--> T
- #<SIMPLE-TYPE-ERROR #x19F514CD>
- 2
<11> #<SYSTEM-FUNCTION SYSTEM::%STRUCTURE-REF>
- NIL
- DBOBJECT
- #<COMPILED-CLOSURE GETBASEDATA>
- NIL
<12> #<COMPILED-CLOSURE GETBASEDATA>
- #<COMPILED-CLOSURE |Test-INLINEREL-1|>
- NIL
- #(NIL (#,(relationp 'RELATION)))
- INHERIT
- #<COMPILED-CLOSURE |Test-INLINEREL|>
- #,(relationp 'RELATION)
<13> #<COMPILED-CLOSURE |Test-INLINEREL|>
- |Test-INLINEREL|
- #,(relationp 'INLINEREL)
- #<COMPILED-CLOSURE TESTREL>
- (#,(relationp 'RELATION))

... chopped for posting

<81> #<SPECIAL-OPERATOR PROGN>
EVAL frame for form
(PROGN (LOADFILE FILE RELOAD) (FORMAT T "~%Compiling ~A" (SOURCE FILE))
 (COND (INFO)
  ((ASK " ? ") (COMPILE-FILE (SOURCE FILE) :OUTPUT-FILE (BIN FILE)) 
(SHOW-TIME)
   T)))
- NIL
frame binding environments
  VAR_ENV <--> #<ADDRESS #x00C0140C>
  FUN_ENV <--> NIL
  BLOCK_ENV <--> NIL
  GO_ENV <--> NIL
  DECL_ENV <--> ((DECLARATION OPTIMIZE DECLARATION))
frame binding variables #<ADDRESS #x00C014A4> binds (~ = dynamically):
  |  RELOAD <--> T
  |  FILE <--> "relations"
  Next environment: NIL
APPLY frame for call (COMPILE-FILE* '"relations" 'T)
-
#<CLOSURE COMPILE-FILE* (FILE &OPTIONAL RELOAD)
  (DECLARE (SYSTEM::IN-DEFUN COMPILE-FILE*))
  (BLOCK COMPILE-FILE* (LOADFILE FILE RELOAD)
   (FORMAT T "~%Compiling ~A" (SOURCE FILE))
   (COND (INFO)
    ((ASK " ? ") (COMPILE-FILE (SOURCE FILE) :OUTPUT-FILE (BIN FILE))
     (SHOW-TIME) T)))>
<82>
#<CLOSURE COMPILE-FILE* (FILE &OPTIONAL RELOAD)
  (DECLARE (SYSTEM::IN-DEFUN COMPILE-FILE*))
  (BLOCK COMPILE-FILE* (LOADFILE FILE RELOAD)
   (FORMAT T "~%Compiling ~A" (SOURCE FILE))
   (COND (INFO)
    ((ASK " ? ") (COMPILE-FILE (SOURCE FILE) :OUTPUT-FILE (BIN FILE))
     (SHOW-TIME) T)))> 2
EVAL frame for form (COMPILE-FILE* FILE T)
- NIL
<83> #<SPECIAL-OPERATOR AND>
EVAL frame for form (AND (COMPILE? FILE) (COMPILE-FILE* FILE T))
- NIL
- ((T (FASLOAD* FILE T)))
<84> #<SPECIAL-OPERATOR COND>
EVAL frame for form (COND ((AND (COMPILE? FILE) (COMPILE-FILE* FILE T))) (T 
(FASLOAD* FILE T)))
- NIL
<85> #<SPECIAL-OPERATOR WHEN>
EVAL frame for form
(WHEN (AND (START? FILE) (NOTSTOP? FILE))
 (FORMAT T "~2%Load-Compile or Load file: ~a" FILE)
 (COND ((AND (COMPILE? FILE) (COMPILE-FILE* FILE T))) (T (FASLOAD* FILE 
T))))
- NIL
frame binding environments
  VAR_ENV <--> #<ADDRESS #x00C01388>
  FUN_ENV <--> NIL
  BLOCK_ENV <--> NIL
  GO_ENV <--> NIL
  DECL_ENV <--> ((DECLARATION OPTIMIZE DECLARATION))
frame binding variables #<ADDRESS #x00C0140C> binds (~ = dynamically):
  |  FILE <--> "relations"
  Next environment: NIL
APPLY frame for call (LOAD-COMPILE-OR-LOAD '"relations")
- ("relations" "types" "rulerels" "ruledeclare")
<86>
#<CLOSURE LOAD-COMPILE-OR-LOAD (FILE)
  (DECLARE (SYSTEM::IN-DEFUN LOAD-COMPILE-OR-LOAD))
  (BLOCK LOAD-COMPILE-OR-LOAD
   (WHEN (AND (START? FILE) (NOTSTOP? FILE))
    (FORMAT T "~2%Load-Compile or Load file: ~a" FILE)
    (COND ((AND (COMPILE? FILE) (COMPILE-FILE* FILE T)))
     (T (FASLOAD* FILE T)))))> 1
- ("types" "rulerels" "ruledeclare")
<87> #<SYSTEM-FUNCTION MAPC> 0

... chopped for posting

- #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
- #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
<95> #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
- #<COMPILED-CLOSURE #:|(DEFINTERFACE CALL-WITH-SYNTAX-HOOKS (FN) 
...)-29-3-1-1|>
- #<COMPILED-CLOSURE SWANK::LISTENER-EVAL-1>
<96> #<COMPILED-CLOSURE #:|(DEFINTERFACE CALL-WITH-SYNTAX-HOOKS (FN) 
...)-29-3-1-1|>
<97> #<GENERIC-FUNCTION SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS>
frame binding variables (~ = dynamically):
  | ~ *PACKAGE* <--> #<PACKAGE COMMON-LISP-USER>
-
#(NIL
  "(compile-ap5)
")
- #<COMPILED-CLOSURE SWANK:LISTENER-EVAL>
-
"(compile-ap5)
"
<98> #<COMPILED-CLOSURE SWANK:LISTENER-EVAL>
- #<COMPILED-CLOSURE SWANK:LISTENER-EVAL>
EVAL frame for form
(SWANK:LISTENER-EVAL
 "(compile-ap5)
")
frame binding environments
  VAR_ENV <--> NIL
  FUN_ENV <--> NIL
  BLOCK_ENV <--> NIL
  GO_ENV <--> NIL
  DECL_ENV <--> ((DECLARATION OPTIMIZE DECLARATION))
frame binding variables (~ = dynamically):
  | ~ SWANK::*BUFFER-PACKAGE* <--> #<UNBOUND>
<99> #<SYSTEM-FUNCTION EVAL>
frame binding variables (~ = dynamically):
  | ~ SWANK::*BUFFER-READTABLE* <--> #<UNBOUND>
- #<PACKAGE AP5>
unwind-protect frame
- NIL
- NIL
frame binding variables (~ = dynamically):
  | ~ *DEBUGGER-HOOK* <--> #<COMPILED-CLOSURE SWANK:SWANK-DEBUGGER-HOOK>
- #<COMPILED-CLOSURE SWANK::EVAL-FOR-EMACS>
- 36
<100> #<COMPILED-CLOSURE SWANK::EVAL-FOR-EMACS>
<101> #<SYSTEM-FUNCTION FUNCALL> 3
- "AP5"
-
(SWANK:LISTENER-EVAL
 "(compile-ap5)
")
- SWANK::EVAL-FOR-EMACS
- #<SYSTEM-FUNCTION FUNCALL>
- #<COMPILED-CLOSURE SWANK::READ-FROM-EMACS>
frame binding variables (~ = dynamically):
  | ~ SYSTEM::*ACTIVE-RESTARTS* <--> NIL
<102> #<COMPILED-CLOSURE SWANK::READ-FROM-EMACS>
catch frame for tag #:G17263
frame binding variables (~ = dynamically):
  | ~ *DEBUGGER-HOOK* <--> NIL
- #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
- #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
<103> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
frame binding variables (~ = dynamically):
  | ~ *TERMINAL-IO* <--> #<IO SYNONYM-STREAM SWANK::*CURRENT-TERMINAL-IO*>
frame binding variables (~ = dynamically):
  | ~ *STANDARD-INPUT* <--> #<IO SYNONYM-STREAM 
SWANK::*CURRENT-STANDARD-INPUT*>
frame binding variables (~ = dynamically):
  | ~ *QUERY-IO* <--> #<IO SYNONYM-STREAM SWANK::*CURRENT-QUERY-IO*>
frame binding variables (~ = dynamically):
  | ~ *DEBUG-IO* <--> #<IO SYNONYM-STREAM SWANK::*CURRENT-DEBUG-IO*>
frame binding variables (~ = dynamically):
  | ~ *TRACE-OUTPUT* <--> #<IO SYNONYM-STREAM SWANK::*CURRENT-TRACE-OUTPUT*>
frame binding variables (~ = dynamically):
  | ~ *ERROR-OUTPUT* <--> #<IO SYNONYM-STREAM SWANK::*CURRENT-ERROR-OUTPUT*>
frame binding variables (~ = dynamically):
  | ~ *STANDARD-OUTPUT* <--> #<IO SYNONYM-STREAM 
SWANK::*CURRENT-STANDARD-OUTPUT*>
- #<IO UNBUFFERED SOCKET-STREAM CHARACTER 0.0.0.0:2294>
- #<SWANK-BACKEND::SLIME-INPUT-STREAM #x19EC303D>
-
#<IO TWO-WAY-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM #x19EC303D>
  #<IO UNBUFFERED SOCKET-STREAM CHARACTER 0.0.0.0:2294>>
- #<COMPILED-CLOSURE SWANK::CALL-WITH-REDIRECTED-IO>
- #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST-3>
<104> #<COMPILED-CLOSURE SWANK::CALL-WITH-REDIRECTED-IO>
- #<SWANK::CONNECTION #x19EC2615>
catch frame for tag SWANK::SLIME-TOPLEVEL
frame binding variables (~ = dynamically):
  | ~ SWANK::*EMACS-CONNECTION* <--> NIL
frame binding variables (~ = dynamically):
  | ~ *DEBUGGER-HOOK* <--> #<COMPILED-CLOSURE SWANK:SWANK-DEBUGGER-HOOK>
frame binding variables (~ = dynamically):
  | ~ SWANK::*SWANK-STATE-STACK* <--> NIL
- #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST>
- #<SWANK::CONNECTION #x19EC2615>
<105> #<COMPILED-CLOSURE SWANK::HANDLE-REQUEST>
handler frame for conditions SWANK::SLIME-PROTOCOL-ERROR
compiled tagbody frame for #(NIL)
- 49
- NIL
- #<IO UNBUFFERED SOCKET-STREAM CHARACTER 0.0.0.0:2291>
- #<COMPILED-CLOSURE SWANK::SIMPLE-SERVE-REQUESTS>
- #<SWANK::CONNECTION #x19EC2615>
<106> #<COMPILED-CLOSURE SWANK::SIMPLE-SERVE-REQUESTS>
- #<COMPILED-CLOSURE SWANK::SIMPLE-SERVE-REQUESTS>
- #<COMPILED-CLOSURE SWANK::SERVE-REQUESTS>
- #<SWANK::CONNECTION #x19EC2615>
<107> #<COMPILED-CLOSURE SWANK::SERVE-REQUESTS>
- #<SWANK::CONNECTION #x19EC2615>
- #<IO UNBUFFERED SOCKET-STREAM CHARACTER 0.0.0.0:2291>
- #<COMPILED-CLOSURE SWANK::SERVE-CONNECTION>
- NIL
<108> #<COMPILED-CLOSURE SWANK::SERVE-CONNECTION>
- NIL
- #<CLOSED SOCKET-SERVER 0.0.0.0:2291>
unwind-protect frame
- NIL
- 2291
- #(#(NIL NIL NIL) #<CLOSED SOCKET-SERVER 0.0.0.0:2291>)
- #(NIL NIL NIL)
- #<COMPILED-CLOSURE SWANK::SETUP-SERVER>
- NIL
<109> #<COMPILED-CLOSURE SWANK::SETUP-SERVER>
- NIL
- #<COMPILED-CLOSURE SWANK::START-SERVER-1>
- 0
- #(NIL "C:\\DOKUME~1\\Rened\\LOKALE~1\\Temp\\slime.2088")
- #<COMPILED-CLOSURE SWANK:START-SERVER>
- NIL
<110> #<COMPILED-CLOSURE SWANK:START-SERVER>
- NIL
- "C:\\DOKUME~1\\Rened\\LOKALE~1\\Temp\\slime.2088"
- #<COMPILED-CLOSURE SWANK:START-SERVER>
EVAL frame for form (SWANK:START-SERVER 
"C:\\DOKUME~1\\Rened\\LOKALE~1\\Temp\\slime.2088")
- #<IO TERMINAL-STREAM>
<111> #<SYSTEM-FUNCTION SYSTEM::READ-EVAL-PRINT>
- #<IO TERMINAL-STREAM>
Printed 111 frames
Break 1 AP5[3]>

-------------------
So with :bt1 we have everything that slime has, plus about another 100 
frames extra...

So it looks to me more than the difference between compile and interpreted 
code to me.

In slime none of the frames that are of interest seem to be available, and I 
am not sure why.

Rene.
From: Helmut Eller
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <m23bz2gimw.fsf@stud3.tuwien.ac.at>
"Rene de Visser" <··············@hotmail.com> writes:

> So with :bt1 we have everything that slime has, plus about another 100 
> frames extra...
>
> So it looks to me more than the difference between compile and interpreted 
> code to me.
>
> In slime none of the frames that are of interest seem to be available, and I 
> am not sure why.

Yes, that's a "known problem".  It's also mentioned in the PROBLEMS
file.  The reason is that CLISP has, AFAIK, no debugger interface for
compiled functions.  All there is, is a function like "print the frame
and all local variables to a stream".  That's not enough for SLIME.
And that function is written in C.  (It's C-Lisp after all :) I once
tried to write a better interface, but understanding CLISP's C code is
beyond by capabilities.

The information to produce a useful backtrace is obviously there, but
it is not easily accessible from Lisp.  Writing the code to make it
available would be a nice contribution.

Helmut.
From: Rene de Visser
Subject: Re: slime: clisp stack trace
Date: 
Message-ID: <cnssh8$jcg$1@news.sap-ag.de>
"Helmut Eller" <········@stud3.tuwien.ac.at> wrote in message
···················@stud3.tuwien.ac.at...
> "Rene de Visser" <··············@hotmail.com> writes:

> Yes, that's a "known problem".  It's also mentioned in the PROBLEMS
> file.  The reason is that CLISP has, AFAIK, no debugger interface for

I had read the problems file.

It says "The backtrace for compiled functions is not very informative."

I had read this to say: The backtrace should be there,  just not so
readable.

The problems file could be changed to say:

"The backtrace for compiled functions can not be displayed in some
situations."

>
> The information to produce a useful backtrace is obviously there, but
> it is not easily accessible from Lisp.  Writing the code to make it
> available would be a nice contribution.

I don't normally use CLisp, so I'm not motivated to do this myself.

Rene.