hmm, this is in lib/_repl.scm

and I see:


(define-prim (##trace proc)                                                             
                                                                                        
  (define (setup hook)                                                                  
    (let ((settings (##closure-ref hook 1)))                                            
      (##vector-set! settings 1 #t)                                                     
      (if (##not (##memq proc ##trace-list))                                            
        (set! ##trace-list (##cons proc ##trace-list)))))                               
                                                                                        
  (let ((hook (##interp-procedure-default-entry-hook proc)))                            
    (if hook                                                                            
      (setup hook)                                                                      
      (let ((new-hook (##make-default-entry-hook)))                                     
        (##interp-procedure-entry-hook-set! proc new-hook)                              
        (setup new-hook)))))


is "##interp-procedure-entry-hook-set!" a function that gets called whenever a function gets hit with 'eval' ?


On Fri, Feb 20, 2009 at 8:21 PM, lowly coder <lowlycoder@huoyanjinjing.com> wrote:
Okay, so I almost think I have a solution to this.

Can I have something like "trace", where instead of printing the argument line, it passes it to a function?

Like a function uber-trace

where:

(trace foo) = (uber-trace foo (lambda (args) (pp args)))




On Fri, Feb 20, 2009 at 8:04 PM, lowly coder <lowlycoder@huoyanjinjing.com> wrote:
Code:

~/code/irc$ cat trace.scm
(define (foo x) x)

(define (bar) (foo 0))

(define (test)
  (foo 1)
  (bar))
 
(trace foo)

(test)
~/code/irc$ gsi trace.scm
| > (foo 1)
| 1
| > (foo 0)
| 0


Problem:

Can I control trace where I can say "trace foo, but not when it's called by bar".

I.e. rather than just saying "trace this function", I would like to be able to say:


(trace foo predicate)

where predicate is a function that takes as input the "stack" frame, and as output creates a #t / #f, which decides whether this particular trace should be printed



On a side note -- all the cool debugging functions in Gambit -- is this part of the 100K LOC scheme or 50K LOC hand written C? (hoping it's the former)