Home / Browse / Steel Bank Common Lisp / Mail / Archive

Steel Bank Common Lisp

Email Archive: sbcl-help (read-only)

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Martin Rubey <martin.rubey@un...> - 2008-01-20 13:30

"Nikodemus Siivola" <nikodemus@...> writes:

> On 20 Jan 2008 10:21:49 +0100, Martin Rubey <martin.rubey@...> wrote:
> 
> > )se br query
> > for i in 1..100000 repeat i^2; "hi"
> >
> > doesn't allow you to abort the computation other than quitting axiom.  Without
> > the *debugger-hook* below one can do this by typing TOP, although this throws
> > another error:
> >
> >   attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER
> >
> 
> This is interesting. When in the debugger for this error, please type
> 
>   ba
> 
> an the terminal to obtain a backtrace. I should like to see it -- something
> moderately odd is going on it TOPLEVEL-CATCHER catch tag isn't there.

Here you go. I hope it's useful, even if it looks cryptic to me...

Martin

martin@...:~$ cd ax-build/target/i686-pc-linux/
martin@...$ export AXIOM=$(pwd)
martin@...$ bin/axiom 
Checking for foreign routines
AXIOM="/home/martin/ax-build/target/i686-pc-linux"
spad-lib="/home/martin/ax-build/target/i686-pc-linux/lib/libspad.so"
sock-fasl="/home/martin/ax-build/target/i686-pc-linux/autoload/ffi-func.fasl"
foreign routines found
openServer result 0
                 FriCAS (AXIOM fork) Computer Algebra System 
                         Version: FriCAS 2008-01-18
              Timestamp: Saturday January 19, 2008 at 16:03:25 
-----------------------------------------------------------------------------
   Issue )copyright to view copyright notices.
   Issue )summary for a summary of useful system commands.
   Issue )quit to leave FriCAS and return to shell.
-----------------------------------------------------------------------------
 

"Hi, running |spad|" (1) -> 
(1) -> for i in 1..100000 repeat i^2; "hi"
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/MONOID-.fasl 
      for domain Monoid& 
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/ORDSET-.fasl 
      for domain OrderedSet& 
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/SGROUP-.fasl 
      for domain SemiGroup& 
Condition: Interactive interrupt at #x9A84ADF. 
 me: #<FUNCTION {912949D}> 
 
   >> System error:
   Interactive interrupt at #x9A84ADF.

(1) -> )se br br
(1) -> for i in 1..100000 repeat i^2; "hi"
Condition: Interactive interrupt at #x965CE44. 
 me: #<FUNCTION {912949D}> 
Finished: Interactive interrupt at #x965CE44. 
 me: #<FUNCTION {912949D}> 

debugger invoked on a SB-SYS:INTERACTIVE-INTERRUPT in thread #<THREAD "initial thread" {B8DFB51}>:
  Interactive interrupt at #x965CE44.

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE] Return from SB-UNIX:SIGINT.

(SB-THREAD:INTERRUPT-THREAD
 #<SB-THREAD:THREAD "initial thread" {B8DFB51}>
 #<CLOSURE (FLET SB-UNIX::INTERRUPT-IT) {C0B7315}>)
0] top

"Hi, I'm in spad-system-error-handler" 
"Hi, I'm in spad-system-error-handler" Condition: attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER 
 me: #<FUNCTION {912949D}> 
Finished: attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER 
 me: #<FUNCTION {912949D}> 

debugger invoked on a SB-INT:SIMPLE-CONTROL-ERROR in thread #<THREAD "initial thread" {B8DFB51}>:
  attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [ABORT   ] Reduce debugger level (to debug level 1).
  1: [CONTINUE] Return from SB-UNIX:SIGINT.

("no debug information for frame")
0[2] ba

0: ("no debug information for frame")
1: (SB-DEBUG::DEBUG-LOOP-FUN)
2: (SB-DEBUG::DEBUG-LOOP-FUN)
3: (SB-DEBUG:INTERNAL-DEBUG)
4: (SB-DEBUG::%INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
5: ((LAMBDA ()))
6: (SB-IMPL::CALL-WITH-SANE-IO-SYNTAX #<CLOSURE (LAMBDA #) {C0B9BBD}>)
7: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA #) {C0B9B9D}>)
8: (INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
9: (INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
10: (SB-INT:%BREAK
     SB-UNIX:SIGINT
     SB-SYS:INTERACTIVE-INTERRUPT
     :CONTEXT
     #<SB-ALIEN-INTERNALS:ALIEN-VALUE :SAP #XB79DA49C :TYPE (*
                                                             (SB-ALIEN:STRUCT
                                                              SB-VM::OS-CONTEXT-T-STRUCT))>
     :ADDRESS
     157666884)
11: (SB-THREAD:INTERRUPT-THREAD
     #<SB-THREAD:THREAD "initial thread" {B8DFB51}>
     #<CLOSURE (FLET SB-UNIX::INTERRUPT-IT) {C0B7315}>)
12: ((FLET #:WITHOUT-INTERRUPTS-BODY-3))
13: (SB-SYS:INVOKE-INTERRUPTION #<CLOSURE (LAMBDA #) {C0B7305}>)
14: ("foreign function: #x806374C")
15: ("foreign function: #x8051D22")
16: ("foreign function: #x8055F6A")
17: (KEYWORDP #<unavailable argument>)
18: (SB-KERNEL:SPECIFIER-TYPE |i|)
19: (SB-INT:ABOUT-TO-MODIFY-SYMBOL-VALUE |i|)
20: (SET |i| 6240)
21: (SB-EVAL::EVAL-SETQ (|i| (QSADD1 |i|)) #<SB-EVAL::ENV {C2D36E9}>)
22: (SB-EVAL::EVAL-TAGBODY
     ((SPADLET |i| 1) G190 (COND ((QSGREATERP |i| 100000) (GO G191)))
      (SEQ (EXIT (SPADCALL |i| 2 '(# . #)))) (SETQ |i| (QSADD1 |i|)) (GO G190)
      G191 (RETURN-FROM SEQ (EXIT NIL)))
     #<SB-EVAL::ENV {C2D3639}>)
23: (SB-EVAL::EVAL-BLOCK
     (SEQ
      (TAGBODY
        (SPADLET |i| 1)
       G190
        (COND ((QSGREATERP |i| 100000) (GO G191)))
        (SEQ (EXIT (SPADCALL |i| 2 '#)))
        (SETQ |i| (QSADD1 |i|))
        (GO G190)
       G191
        (RETURN-FROM SEQ (EXIT NIL))))
     #<SB-EVAL::ENV {C2D30C9}>)
24: (SB-EVAL::EVAL-LET
     (((#:G14877 (REPEAT (STEP |i| 1 1 100000) (SPADCALL |i| 2 '#))))
      (IF #:G14877 #:G14877 (OR (|voidValue|))))
     #<SB-EVAL::ENV {C2D30C9}>)
25: (SB-EVAL:EVAL-IN-NATIVE-ENVIRONMENT
     (OR
      (REPEAT (STEP |i| 1 1 100000)
              (SPADCALL |i| 2 '(# . #(# # NIL 0 # NIL # # # # # # ...))))
      (|voidValue|))
     #<NULL-LEXENV>)
26: (|timedEVALFUN|
     (OR
      (REPEAT (STEP |i| 1 1 100000)
              (SPADCALL |i| 2 '(# . #(# # NIL 0 # NIL # # # # # # ...))))
      (|voidValue|)))
27: (|evalREPEAT|
     #(REPEAT NIL NIL NIL NIL)
     ((STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^)))))
     (|Void|))
28: (|upREPEAT1|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
29: (|upREPEAT0|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
30: (|upREPEAT|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
31: (|bottomUp|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
32: (|upSEQ|
     (#(SEQ NIL NIL NIL NIL)
      (#(REPEAT NIL NIL NIL NIL)
       (STEP
        |i|
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 100000) (#) NIL))
       (#(^ NIL (# SPADCALL |i| 2 '#) (#) NIL)
        #(|i| (|PositiveInteger|) (# . |i|) (#) (# # #))
        #(|--immediateData--| NIL (# . 2) (#) (# # #))))
      #(|--immediateData--| NIL ((|String|) . "hi") NIL NIL)))
33: (|bottomUp|
     (#(SEQ NIL NIL NIL NIL)
      (#(REPEAT NIL NIL NIL NIL)
       (STEP
        |i|
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 100000) (#) NIL))
       (#(^ NIL (# SPADCALL |i| 2 '#) (#) NIL)
        #(|i| (|PositiveInteger|) (# . |i|) (#) (# # #))
        #(|--immediateData--| NIL (# . 2) (#) (# # #))))
      #(|--immediateData--| NIL ((|String|) . "hi") NIL NIL)))
34: (|interpret1|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     NIL
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
35: (|interpret|)
36: (|interpretTopLevel|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
37: (|processInteractive1|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
38: (|processInteractive|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
39: (|phInterpret|
     ((|carrier| (|ok?| . T)
       (|ptreePremacro| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|ptree| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|lines| ((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|messages|) (|stepNumber| . 1))))
40: (|ncConversationPhase|
     #<FUNCTION |phInterpret|>
     (((|carrier| (|ok?| . T) (|ptreePremacro| |Sequence| (|listOf| # #))
        (|ptree| |Sequence| (|listOf| # #))
        (|lines| (# . "for i in 1..100000 repeat i^2; \"hi\"")) (|messages|)
        (|stepNumber| . 1)))))
41: (|intloopSpadProcess,interp|
     ((|carrier| (|ok?| . T)
       (|ptreePremacro| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|ptree| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|lines| ((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|messages|) (|stepNumber| . 1)))
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi")))
     T)
42: (|intloopSpadProcess|
     1
     ((((0 "for i in 1..100000 repeat i^2; \"hi\"" 1 1 "strings") . 1)
       . "for i in 1..100000 repeat i^2; \"hi\""))
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi")))
     T)
43: (|intloopProcess|
     1
     T
     (((((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|Sequence| (|listOf| (|Loop| #) (# . "hi"))))
      |nonnullstream| #<FUNCTION |incAppend1|> NIL
      (|nonnullstream| # #
       (|nonnullstream| # NIL (|nonnullstream| # # (|nullstream|))))))
44: (|intloopReadConsole| "" 1)
45: (|SpadInterpretStream| 1 (TIM DALY ?) T)
46: (|intloop|)
47: (|ncIntLoop|)
48: (|ncTopLevel|)
49: (|runspad|)
50: (|spad|)
51: (AXIOM-RESTART)
52: ((LAMBDA ()))
53: ((LABELS SB-IMPL::RESTART-LISP))

0[2]

Thread View

Thread	Author	Date
Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl	Martin Rubey <martin.rubey@un...>

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Martin Rubey <martin.rubey@un...> - 2008-01-19 23:38

Martin Rubey <martin.rubey@...> writes:

> Problem statement:
> =================
> in gcl based axiom, hitting Ctrl-c in the interpreter will print
> 
>    >> System error:
>    Console interrupt.
> 
> and resume, while in sbcl, one falls into the debugger.  I would like to switch
> that off.  

Am I right that *debugger-hook* is my friend?  I did the following experiment
(deleting some compiler messages):

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
* (defun mydebug (a b) (print "hi there") (invoke-restart 'abort))

MYDEBUG
* (let ((*debugger-hook* #'mydebug)) (+ 3 'a))
; in: LAMBDA NIL
;     +
; 
; note: deleting unreachable code
; 
; caught WARNING:
;   Asserted type NUMBER conflicts with derived type (VALUES (MEMBER A)
&OPTIONAL).
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; compilation unit finished
;   caught 1 WARNING condition
;   printed 1 note

"hi there" 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I guess now, that I would have to set *debugger-hook* to a function which is a
little more intelligent, similar to the gcl version...

Looks like a lot of work.

Martin

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Martin Rubey <martin.rubey@un...> - 2008-01-20 08:27

The following message is a courtesy copy of an article
that has been posted to comp.lang.lisp as well.

Excuse crossposting please, it now seems that it's just a lisp question, and
not sbcl related.  So, those who were already following can skip the first
part.

;;PART 1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

I am one of the developers of a computer algebra system called FriCAS/axiom.
It is originally gcl-based, but meanwhile sbcl support is pretty good.  I have
one annoying problem, however, and hope you can help me a little.  Please bear
with me, my lisp skills are of rather basic nature, I have no knowledge at all
of things like error handling...

Problem statement:
=================
in gcl based axiom, hitting Ctrl-c in the interpreter will print

   >> System error:
   Console interrupt.

and resume, while in sbcl, one falls into the debugger.  I would like to switch
that off.  More precisely, gcl based axiom supports a variety of settings:


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(1) -> )set break
-------------------------- The breakmode Option ---------------------------

 Description: execute break processing on error

 The breakmode option may be followed by any one of the following:

 -> nobreak
    break
    query
    resume
    fastlinks

 The current setting is indicated within the list.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
As far as I know, this setting is stored in the variable |$BreakMode|

Current knowledge:
=================

Meanwhile I know from our chief maintainer Waldek:

> FriCAS takes over gcl exception handling, for other Lisps we use Ansi
> condition system to catch errors.

(I have no idea what the "ANSI condition system" is, I must admit)

The code handling errors is below, I believe that I'm interested in the very
last eval-when.  Concerning $inLispVM, there is a comment:

The $inLispVM is set to NIL in spad. LispVM is a non-common lisp that runs on
IBM/370 mainframes. This is probably dead code.  It appears that this list has
the same structure as an argument to the LispVM rdefiostream function.

(Note that (boundp $inLispVM) gives T)

;;PART 2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Assuming that *debugger-hook* is the way to go, I tried the following in
spaderror.lisp:

#-(or :GCL :CCL)
(eval-when (load eval)
  (setq *debugger-hook* 
        (lambda (a b)
          (|systemError| (error-format a)))))

This seems to be roughly working.  I guess it remains to copy the semantics of
the form below.  Help is greatly appreciated:

1) I do not know what embed/unembed does.  Definitions at the end of this
   message
2) I guess that I only need to implement the 

   (and (boundp '|$inLispVM|) (boundp '|$BreakMode|))

  branch of the if, or could it happen that '|$BreakMode| is not bound?

3) are |validate|, |trapNumerics| dead code?

Martin

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; parts of spaderror.lisp, containing the error handler for gcl.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

#+:GCL
(eval-when
 (load eval)
 (unembed 'system:universal-error-handler)
 (embed 'system:universal-error-handler
            '(lambda (type correctable? op
                           continue-string error-string &rest args)
               (block
                nil
                (setq |$NeedToSignalSessionManager| T)
                (if (and (boundp '|$inLispVM|) (boundp '|$BreakMode|))
                    (progn
                      (cond ((eq |$BreakMode| '|validate|)
                             (|systemError| (error-format error-string args)))
                            ((and (eq |$BreakMode| '|trapNumerics|)
                                  (eq type :ERROR))
                             (setq |$BreakMode| nil)                         
                             (throw '|trapNumerics| |$numericFailure|))
                            ((and (eq |$BreakMode| '|trapNumerics|)
                                  (boundp '|$oldBreakMode|)
                                  (setq |$BreakMode| |$oldBreakMode|)
                                  nil)) ;; resets error handler
                            ((and (null |$inLispVM|)
                                  (memq |$BreakMode| '(|nobreak| |query| |resume|)))
                             (let ((|$inLispVM| T)) ;; turn off handler
                               (return
                                (|systemError| (error-format error-string args)))))
                            ((eq |$BreakMode| '|letPrint2|)
                             (setq |$BreakMode| nil)
                             (throw '|letPrint2| nil)))))
                (apply system:universal-error-handler type correctable? op
                       continue-string error-string args )))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; parts of vmlisp.lisp, containing definitions for embed and unembed
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 46.0 Call tracing


(defun EMBEDDED () (mapcar #'car *embedded-functions*))

(defun EMBED (CURRENT-BINDING NEW-DEFINITION)
  (PROG
#+:CCL (OP BV BODY OLD-DEF *COMP)
#-:CCL (OP BV BODY OLD-DEF)
      (COND
        ( (NOT (IDENTP CURRENT-BINDING))
          (SETQ CURRENT-BINDING
                (error (format nil "invalid argument ~s to EMBED"
  CURRENT-BINDING))) ) )
      (SETQ OLD-DEF (symbol-function CURRENT-BINDING))
      (SETQ NEW-DEFINITION
          (COND
            ( (NOT (consp NEW-DEFINITION))
              NEW-DEFINITION )
            ( (AND
                (DCQ (OP BV . BODY) NEW-DEFINITION)
                (OR (EQ OP 'LAMBDA) (EQ OP 'MLAMBDA)))
              (COND
                ( (NOT (MEMQ CURRENT-BINDING (FLAT-BV-LIST BV)))
                 `(,OP ,BV ((LAMBDA (,CURRENT-BINDING) . ,BODY) ',OLD-DEF))
                   )
                ( 'T
                  NEW-DEFINITION ) ) )
            ( 'T
              `((LAMBDA (,CURRENT-BINDING) ,NEW-DEFINITION) ',OLD-DEF)))
            )
      (SETF NEW-DEFINITION (COERCE NEW-DEFINITION 'FUNCTION))
      (SETF (symbol-function CURRENT-BINDING) NEW-DEFINITION)
#+:CCL (IF (CONSP NEW-DEFINITION) (SETQ NEW-DEFINITION (CDR NEW-DEFINITION)))
      (push (LIST CURRENT-BINDING NEW-DEFINITION OLD-DEF) *embedded-functions*)
      (RETURN CURRENT-BINDING) ) )

(defun UNEMBED (CURRENT-BINDING)
    (PROG
#+:CCL  (TMP E-LIST CUR-DEF *COMP)
#-:CCL  (TMP E-LIST CUR-DEF)
      (SETQ E-LIST *embedded-functions*)
      (SETQ CUR-DEF (symbol-function CURRENT-BINDING))
#+:CCL (IF (CONSP CUR-DEF) (SETQ CUR-DEF (CDR CUR-DEF)))
      (COND
        ( (NOT (consp E-LIST))
          NIL )
        ( (ECQ ((CURRENT-BINDING CUR-DEF)) E-LIST)
          (SETF (symbol-function CURRENT-BINDING) (QCADDAR E-LIST))
          (SETQ *embedded-functions* (QCDR E-LIST))
          (RETURN CURRENT-BINDING) )
        ( 'T
          (SEQ
            (SETQ TMP E-LIST)
        LP  (COND
              ( (NOT (consp (QCDR TMP)))
                (EXIT NIL) )
              ( (NULL (ECQ ((CURRENT-BINDING CUR-DEF)) (QCDR TMP)))
                (SETQ TMP (QCDR TMP))
                (GO LP) )
              ( 'T
                (SETF (symbol-function  CURRENT-BINDING) (QCAR (QCDDADR TMP)))
                (RPLACD TMP (QCDDR TMP))
                (RETURN CURRENT-BINDING) ) ) ) ) )
      (RETURN NIL) ))

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Martin Rubey <martin.rubey@un...> - 2008-01-20 09:21

The following seems to exhibit similar behaviour as the gcl variant.
Curiously, both do not continue computation in interpreter when told to do. For
example, hitting Ctrl-C during the loop in

)se br resume
for i in 1..100000 repeat i^2; "hi"

doesn't print the "hi".  Well, I don't care too much.  In input files, it still
seems to work.

More serious is the following

)se br query
for i in 1..100000 repeat i^2; "hi"

doesn't allow you to abort the computation other than quitting axiom.  Without
the *debugger-hook* below one can do this by typing TOP, although this throws
another error: 

  attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER

I have no idea how to fix that properly, but I guess it has to do with entering
the error handler again...  Although, really, there should be a restart that
aborts the computation, but (compute-restarts) doesn't find it...

Should I commit this?  How could I test it more thoroughly?

Martin

#-(or :GCL :CCL)
(eval-when (load eval)
  (setq *debugger-hook* 
        (lambda (condition me-or-my-encapsulation)
          (block nil
            (setq |$NeedToSignalSessionManager| T)
            (if (and (boundp '|$inLispVM|) (boundp '|$BreakMode|))
                (cond ((eq |$BreakMode| '|validate|)
                       (|systemError| (error-format condition)))
                      ((and (eq |$BreakMode| '|trapNumerics|)
                            (typep condition 'error))
                       (setq |$BreakMode| nil)                         
                       (throw '|trapNumerics| |$numericFailure|))
                      ((and (eq |$BreakMode| '|trapNumerics|)
                            (boundp '|$oldBreakMode|)
                            (setq |$BreakMode| |$oldBreakMode|)
                            nil)) ;; resets error handler
                      ((and (null |$inLispVM|)
                            (memq |$BreakMode| '(|nobreak| |query| |resume|)))
                       (let ((|$inLispVM| T)) ;; turn off handler
                         (return
                          (|systemError| (error-format condition)))))
                      ((eq |$BreakMode| '|letPrint2|)
                       (setq |$BreakMode| nil)
                       (throw '|letPrint2| nil))))))))

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Nikodemus Siivola <nikodemus@ra...> - 2008-01-20 13:12

On 20 Jan 2008 10:21:49 +0100, Martin Rubey <martin.rubey@...> wrote:

> )se br query
> for i in 1..100000 repeat i^2; "hi"
>
> doesn't allow you to abort the computation other than quitting axiom.  Without
> the *debugger-hook* below one can do this by typing TOP, although this throws
> another error:
>
>   attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER
>

This is interesting. When in the debugger for this error, please type

  ba

an the terminal to obtain a backtrace. I should like to see it -- something
moderately odd is going on it TOPLEVEL-CATCHER catch tag isn't there.

Cheers,

 -- Nikodemus

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Martin Rubey <martin.rubey@un...> - 2008-01-20 13:30

"Nikodemus Siivola" <nikodemus@...> writes:

> On 20 Jan 2008 10:21:49 +0100, Martin Rubey <martin.rubey@...> wrote:
> 
> > )se br query
> > for i in 1..100000 repeat i^2; "hi"
> >
> > doesn't allow you to abort the computation other than quitting axiom.  Without
> > the *debugger-hook* below one can do this by typing TOP, although this throws
> > another error:
> >
> >   attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER
> >
> 
> This is interesting. When in the debugger for this error, please type
> 
>   ba
> 
> an the terminal to obtain a backtrace. I should like to see it -- something
> moderately odd is going on it TOPLEVEL-CATCHER catch tag isn't there.

Here you go. I hope it's useful, even if it looks cryptic to me...

Martin

martin@...:~$ cd ax-build/target/i686-pc-linux/
martin@...$ export AXIOM=$(pwd)
martin@...$ bin/axiom 
Checking for foreign routines
AXIOM="/home/martin/ax-build/target/i686-pc-linux"
spad-lib="/home/martin/ax-build/target/i686-pc-linux/lib/libspad.so"
sock-fasl="/home/martin/ax-build/target/i686-pc-linux/autoload/ffi-func.fasl"
foreign routines found
openServer result 0
                 FriCAS (AXIOM fork) Computer Algebra System 
                         Version: FriCAS 2008-01-18
              Timestamp: Saturday January 19, 2008 at 16:03:25 
-----------------------------------------------------------------------------
   Issue )copyright to view copyright notices.
   Issue )summary for a summary of useful system commands.
   Issue )quit to leave FriCAS and return to shell.
-----------------------------------------------------------------------------
 

"Hi, running |spad|" (1) -> 
(1) -> for i in 1..100000 repeat i^2; "hi"
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/MONOID-.fasl 
      for domain Monoid& 
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/ORDSET-.fasl 
      for domain OrderedSet& 
   Loading 
      /home/martin/ax-build/target/i686-pc-linux/algebra/SGROUP-.fasl 
      for domain SemiGroup& 
Condition: Interactive interrupt at #x9A84ADF. 
 me: #<FUNCTION {912949D}> 
 
   >> System error:
   Interactive interrupt at #x9A84ADF.

(1) -> )se br br
(1) -> for i in 1..100000 repeat i^2; "hi"
Condition: Interactive interrupt at #x965CE44. 
 me: #<FUNCTION {912949D}> 
Finished: Interactive interrupt at #x965CE44. 
 me: #<FUNCTION {912949D}> 

debugger invoked on a SB-SYS:INTERACTIVE-INTERRUPT in thread #<THREAD "initial thread" {B8DFB51}>:
  Interactive interrupt at #x965CE44.

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE] Return from SB-UNIX:SIGINT.

(SB-THREAD:INTERRUPT-THREAD
 #<SB-THREAD:THREAD "initial thread" {B8DFB51}>
 #<CLOSURE (FLET SB-UNIX::INTERRUPT-IT) {C0B7315}>)
0] top

"Hi, I'm in spad-system-error-handler" 
"Hi, I'm in spad-system-error-handler" Condition: attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER 
 me: #<FUNCTION {912949D}> 
Finished: attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER 
 me: #<FUNCTION {912949D}> 

debugger invoked on a SB-INT:SIMPLE-CONTROL-ERROR in thread #<THREAD "initial thread" {B8DFB51}>:
  attempt to THROW to a tag that does not exist: SB-INT:TOPLEVEL-CATCHER

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [ABORT   ] Reduce debugger level (to debug level 1).
  1: [CONTINUE] Return from SB-UNIX:SIGINT.

("no debug information for frame")
0[2] ba

0: ("no debug information for frame")
1: (SB-DEBUG::DEBUG-LOOP-FUN)
2: (SB-DEBUG::DEBUG-LOOP-FUN)
3: (SB-DEBUG:INTERNAL-DEBUG)
4: (SB-DEBUG::%INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
5: ((LAMBDA ()))
6: (SB-IMPL::CALL-WITH-SANE-IO-SYNTAX #<CLOSURE (LAMBDA #) {C0B9BBD}>)
7: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA #) {C0B9B9D}>)
8: (INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
9: (INVOKE-DEBUGGER #<SB-SYS:INTERACTIVE-INTERRUPT {C0B75C9}>)
10: (SB-INT:%BREAK
     SB-UNIX:SIGINT
     SB-SYS:INTERACTIVE-INTERRUPT
     :CONTEXT
     #<SB-ALIEN-INTERNALS:ALIEN-VALUE :SAP #XB79DA49C :TYPE (*
                                                             (SB-ALIEN:STRUCT
                                                              SB-VM::OS-CONTEXT-T-STRUCT))>
     :ADDRESS
     157666884)
11: (SB-THREAD:INTERRUPT-THREAD
     #<SB-THREAD:THREAD "initial thread" {B8DFB51}>
     #<CLOSURE (FLET SB-UNIX::INTERRUPT-IT) {C0B7315}>)
12: ((FLET #:WITHOUT-INTERRUPTS-BODY-3))
13: (SB-SYS:INVOKE-INTERRUPTION #<CLOSURE (LAMBDA #) {C0B7305}>)
14: ("foreign function: #x806374C")
15: ("foreign function: #x8051D22")
16: ("foreign function: #x8055F6A")
17: (KEYWORDP #<unavailable argument>)
18: (SB-KERNEL:SPECIFIER-TYPE |i|)
19: (SB-INT:ABOUT-TO-MODIFY-SYMBOL-VALUE |i|)
20: (SET |i| 6240)
21: (SB-EVAL::EVAL-SETQ (|i| (QSADD1 |i|)) #<SB-EVAL::ENV {C2D36E9}>)
22: (SB-EVAL::EVAL-TAGBODY
     ((SPADLET |i| 1) G190 (COND ((QSGREATERP |i| 100000) (GO G191)))
      (SEQ (EXIT (SPADCALL |i| 2 '(# . #)))) (SETQ |i| (QSADD1 |i|)) (GO G190)
      G191 (RETURN-FROM SEQ (EXIT NIL)))
     #<SB-EVAL::ENV {C2D3639}>)
23: (SB-EVAL::EVAL-BLOCK
     (SEQ
      (TAGBODY
        (SPADLET |i| 1)
       G190
        (COND ((QSGREATERP |i| 100000) (GO G191)))
        (SEQ (EXIT (SPADCALL |i| 2 '#)))
        (SETQ |i| (QSADD1 |i|))
        (GO G190)
       G191
        (RETURN-FROM SEQ (EXIT NIL))))
     #<SB-EVAL::ENV {C2D30C9}>)
24: (SB-EVAL::EVAL-LET
     (((#:G14877 (REPEAT (STEP |i| 1 1 100000) (SPADCALL |i| 2 '#))))
      (IF #:G14877 #:G14877 (OR (|voidValue|))))
     #<SB-EVAL::ENV {C2D30C9}>)
25: (SB-EVAL:EVAL-IN-NATIVE-ENVIRONMENT
     (OR
      (REPEAT (STEP |i| 1 1 100000)
              (SPADCALL |i| 2 '(# . #(# # NIL 0 # NIL # # # # # # ...))))
      (|voidValue|))
     #<NULL-LEXENV>)
26: (|timedEVALFUN|
     (OR
      (REPEAT (STEP |i| 1 1 100000)
              (SPADCALL |i| 2 '(# . #(# # NIL 0 # NIL # # # # # # ...))))
      (|voidValue|)))
27: (|evalREPEAT|
     #(REPEAT NIL NIL NIL NIL)
     ((STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^)))))
     (|Void|))
28: (|upREPEAT1|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
29: (|upREPEAT0|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
30: (|upREPEAT|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
31: (|bottomUp|
     (#(REPEAT NIL NIL NIL NIL)
      (STEP
       |i|
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 1)
         ((|PositiveInteger|)) NIL)
       #(|--immediateData--| NIL ((|PositiveInteger|) . 100000)
         ((|PositiveInteger|)) NIL))
      (#(^ NIL ((|PositiveInteger|) SPADCALL |i| 2 '(# . #))
         ((|PositiveInteger|)) NIL)
       #(|i| (|PositiveInteger|) ((|PositiveInteger|) . |i|)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 1) (|callingFunction| . ^)))
       #(|--immediateData--| NIL ((|PositiveInteger|) . 2)
         ((|PositiveInteger|))
         ((|totalArgs| . 2) (|argumentNumber| . 2) (|callingFunction| . ^))))))
32: (|upSEQ|
     (#(SEQ NIL NIL NIL NIL)
      (#(REPEAT NIL NIL NIL NIL)
       (STEP
        |i|
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 100000) (#) NIL))
       (#(^ NIL (# SPADCALL |i| 2 '#) (#) NIL)
        #(|i| (|PositiveInteger|) (# . |i|) (#) (# # #))
        #(|--immediateData--| NIL (# . 2) (#) (# # #))))
      #(|--immediateData--| NIL ((|String|) . "hi") NIL NIL)))
33: (|bottomUp|
     (#(SEQ NIL NIL NIL NIL)
      (#(REPEAT NIL NIL NIL NIL)
       (STEP
        |i|
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 1) (#) NIL)
        #(|--immediateData--| NIL (# . 100000) (#) NIL))
       (#(^ NIL (# SPADCALL |i| 2 '#) (#) NIL)
        #(|i| (|PositiveInteger|) (# . |i|) (#) (# # #))
        #(|--immediateData--| NIL (# . 2) (#) (# # #))))
      #(|--immediateData--| NIL ((|String|) . "hi") NIL NIL)))
34: (|interpret1|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     NIL
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
35: (|interpret|)
36: (|interpretTopLevel|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
37: (|processInteractive1|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
38: (|processInteractive|
     (SEQ (REPEAT (STEP |i| 1 1 100000) (^ |i| 2)) "hi")
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi"))))
39: (|phInterpret|
     ((|carrier| (|ok?| . T)
       (|ptreePremacro| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|ptree| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|lines| ((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|messages|) (|stepNumber| . 1))))
40: (|ncConversationPhase|
     #<FUNCTION |phInterpret|>
     (((|carrier| (|ok?| . T) (|ptreePremacro| |Sequence| (|listOf| # #))
        (|ptree| |Sequence| (|listOf| # #))
        (|lines| (# . "for i in 1..100000 repeat i^2; \"hi\"")) (|messages|)
        (|stepNumber| . 1)))))
41: (|intloopSpadProcess,interp|
     ((|carrier| (|ok?| . T)
       (|ptreePremacro| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|ptree| |Sequence| (|listOf| (|Loop| #) (# . "hi")))
       (|lines| ((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|messages|) (|stepNumber| . 1)))
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi")))
     T)
42: (|intloopSpadProcess|
     1
     ((((0 "for i in 1..100000 repeat i^2; \"hi\"" 1 1 "strings") . 1)
       . "for i in 1..100000 repeat i^2; \"hi\""))
     (|Sequence|
      (|listOf| (|Loop| (|listOf| (|Forin| # #) (|Do| #)))
       ((|string| (|posn| # . 31)) . "hi")))
     T)
43: (|intloopProcess|
     1
     T
     (((((# . 1) . "for i in 1..100000 repeat i^2; \"hi\""))
       (|Sequence| (|listOf| (|Loop| #) (# . "hi"))))
      |nonnullstream| #<FUNCTION |incAppend1|> NIL
      (|nonnullstream| # #
       (|nonnullstream| # NIL (|nonnullstream| # # (|nullstream|))))))
44: (|intloopReadConsole| "" 1)
45: (|SpadInterpretStream| 1 (TIM DALY ?) T)
46: (|intloop|)
47: (|ncIntLoop|)
48: (|ncTopLevel|)
49: (|runspad|)
50: (|spad|)
51: (AXIOM-RESTART)
52: ((LAMBDA ()))
53: ((LABELS SB-IMPL::RESTART-LISP))

0[2]

Re: [Sbcl-help] [fricas-devel] Re: interrupt in sbcl

From: Nikodemus Siivola <nikodemus@ra...> - 2008-01-20 14:55

On 20 Jan 2008 14:30:37 +0100, Martin Rubey <martin.rubey@...> wrote:

> Here you go. I hope it's useful, even if it looks cryptic to me...

Thanks. The trouble is that SBCL debugger expects SB-INT:TOPLEVEL-CATCHER to
be there, but since Axiom provides its own toplevel function (via
SAVE-LISP-AND-DIE),
it is not.

Either SBCL has to document the requirement to bind SB-INT:TOPLEVEL-CATCHER, or
it needs to provide around the call to user-defined toplevel function.
(Or detect
the lack of the same and act different, or...)

Cheers,

 -- Nikodemus