Emacs - Debug

1. Introduzione
2. Codici di esempio
- 2.1. Conto alla rovescia
- 2.2. Formattazione in HTML di tabelle ORG
3. Metodo trace
- 3.1. Descrizione delle Funzioni Principali
4. Metodo edebug
- 4.1. Descrizione delle Funzioni Principali
5. Esempio metodo trace
6. Eesempio edebug

1. Introduzione

In emacs ho sperimentato due modi per effettuare il debug :

trace : visualizzazione nel trace-buffer l'ouput delle funzioni che sono state tracciate;
edebug : evoluzione del debug di emacs che permette di visualizzare nel call-stack buffer la chiamata alla funzione corrente;

Entrambi i modi verranno applicate ai seguenti codici di esempio.

2. Codici di esempio

2.1. Conto alla rovescia

(defun my-countdown (n)
  "Conto alla rovescia da N a 0."
  (debug)

  (while (> n 0)
    (message "Counting down: %d" n)
    (setq n (1- n))
    )
  (message "Countdown finished!")
)


;; inizio tracciamento funzione
(trace-function 'my-countdown)
(trace-function 'message)

;; avvio della funzione
(my-countdown 3)

;; fine del tracciamento delle funzioni
(untrace-all)

2.2. Formattazione in HTML di tabelle ORG

(defun org-translate-table-to-html (tbl-name)
  "Traduci una tabella con nome TBL-NAME in codice HTML."
  (debug)
  (message "esecuzione blocco 'org-translate-table-to-html' su %s" tbl-name)
  (save-excursion

    (goto-char (point-min))

    (if (search-forward (concat "#+tblname: " tbl-name) nil t)
        (let ((table-start (line-beginning-position)))
          (org-table-end)
          (let ((table-end (point)))
            (with-temp-buffer
              (insert-buffer-substring (current-buffer) table-start table-end)
              (org-table-export (buffer-string) "html")
              )
            )
          )
      (error "Tabella %s non trovata" tbl-name)
      )
    )
  )

;; imposta le funzioni da tracciare 
(trace-function 'org-translate-table-to-html)
(trace-function 'insert-buffer-substring)
(trace-function 'search-forward)

;; richiama la funzione principale
(org-translate-table-to-html "prova")

;; fine del tracciamento delle funzioni
(untrace-all)


riga1	img.jpg	prova
jaskjdk	kljlkj	ljklkòj

3. Metodo trace

Funzione	Descrizione
`trace-function`	Traccia le chiamate a una funzione specifica.
`untrace-function`	Rimuove il tracciamento da una funzione specifica.
`trace-function-background`	Traccia le chiamate a una funzione, mostrando solo le informazioni di background.
`untrace-function-background`	Rimuove il tracciamento di background da una funzione specifica.
`trace-function-foreground`	Traccia le chiamate a una funzione, mostrando solo le informazioni di foreground.
`untrace-function-foreground`	Rimuove il tracciamento di foreground da una funzione specifica.
`trace-all-functions`	Traccia tutte le funzioni.
`untrace-all`	Rimuove il tracciamento da tutte le funzioni.
`trace-function-args`	Traccia le chiamate a una funzione, mostrando gli argomenti passati.
`trace-function-result`	Traccia le chiamate a una funzione, mostrando il risultato restituito.
`trace-function-callstack`	Traccia la chiamata di una funzione, mostrando l'intero callstack.
`trace-function-message`	Traccia le chiamate a una funzione, loggando i messaggi associati.
`trace-function-quit`	Rimuove il tracciamento delle funzioni specificate quando viene invocato `C-g`.
`trace-buffer`	Mostra il buffer che contiene l'output del tracciamento delle funzioni.
`trace-remove`	Rimuove il tracciamento da una funzione o tutte le funzioni.
`trace-preserve-trace-output`	Preserva l'output del tracciamento anche dopo la rimozione della funzione.
`trace-expand-macro`	Traccia l'espansione di una macro, mostrando le chiamate sottostanti.

3.1. Descrizione delle Funzioni Principali

trace-function : Permette di monitorare l'esecuzione di una funzione specifica. Ogni chiamata alla funzione verrà registrata in un buffer apposito.
trace-all-functions : Abilita il tracciamento su tutte le funzioni, utile per il debugging globale, ma può generare molto output.
untrace-all : Disabilita il tracciamento su tutte le funzioni precedentemente tracciate.
trace-function-args : Mostra gli argomenti passati a una funzione durante ogni chiamata, fornendo informazioni dettagliate su come la funzione viene invocata.
trace-function-result : Registra e mostra il valore di ritorno di una funzione ogni volta che viene chiamata.
trace-buffer : Apre il buffer dove viene registrato l'output del tracciamento, permettendo di visualizzare e analizzare i log generati.

4. Metodo edebug

Funzione	Descrizione
`edebug-defun`	Abilita il debugging interattivo per la funzione attuale o la definizione sotto il cursore.
`edebug-all-defs`	Abilita il debugging per tutte le funzioni attualmente caricate.
`edebug-eval-defun`	Esegue e traccia la funzione sotto il cursore (come `eval-defun`).
`edebug-eval-expression`	Valuta un'espressione con `edebug`, permettendo di tracciare il suo comportamento.
`edebug-mode`	Attiva o disattiva la modalità `edebug`.
`edebug-step-mode`	Abilita il passaggio passo-passo (step mode) durante il debugging.
`edebug-continue-mode`	Continua l'esecuzione fino al prossimo punto di break (breakpoint).
`edebug-next-mode`	Passa al successivo espressione da eseguire nel debugging.
`edebug-go-mode`	Esegue la funzione fino alla fine, o fino al prossimo punto di break.
`edebug-set-breakpoint`	Imposta o rimuove un punto di break alla posizione corrente del cursore.
`edebug-unset-breakpoints`	Rimuove tutti i punti di break nella funzione corrente.
`edebug-trace-mode`	Abilita il tracciamento delle funzioni durante il debugging, mostrando ogni passaggio.
`edebug-backtrace`	Mostra il backtrace (stack trace) attuale di `edebug`.
`edebug-where`	Mostra la posizione attuale di esecuzione in `edebug`.
`edebug-stop`	Termina il debugging e ripristina il comportamento normale della funzione.
`edebug-continue-kbd-macro`	Continua l'esecuzione di una macro da tastiera durante il debugging.
`edebug-view-outside`	Mostra il codice esterno al punto di debugging corrente senza uscire da `edebug`.
`edebug-visit-eval-list`	Permette di visitare ed esplorare la lista delle espressioni valutate in `edebug`.
`edebug-display-freq-count`	Mostra la frequenza con cui ogni espressione è stata valutata durante il debugging.
`edebug-save-windows`	Salva e ripristina lo stato delle finestre prima e dopo il debugging.

4.1. Descrizione delle Funzioni Principali

edebug-defun: Compila la funzione attuale per il debugging interattivo. Quando la funzione viene eseguita, `edebug` interviene, permettendo di seguire passo-passo l'esecuzione.
edebug-all-defs: Abilita `edebug` per tutte le funzioni definite nel buffer corrente, rendendo possibile il debugging su vasta scala.
edebug-set-breakpoint: Imposta un punto di break alla posizione corrente del cursore. Quando il codice raggiunge questo punto, `edebug` ferma l'esecuzione.
edebug-continue-mode: Continua l'esecuzione del codice fino al prossimo punto di break, utile per saltare sezioni non interessanti.
edebug-trace-mode: Fornisce un log dettagliato dell'esecuzione della funzione durante il debugging, mostrando ogni passaggio compiuto.
edebug-backtrace: Mostra la traccia di chiamate (call stack) corrente, utile per capire la sequenza di chiamate che ha portato al punto attuale.
edebug-stop: Interrompe il debugging, ripristinando l'esecuzione normale del codice senza ulteriori interventi di `edebug`.

5. Esempio metodo trace

Eseguendo il codice countdown ottengo il seguente output in cui si vede l'output della funzione 'message'. Attenzione se non si rimuove il tracciamento dell funzione questa verra tracciata ogniqualvota nel codice elisp viene invocata.

====================================================================
1 -> (message "Counting down: %d" 3)
1 <- message: "Counting down: 3"
====================================================================
1 -> (message "Counting down: %d" 2)
1 <- message: "Counting down: 2"
====================================================================
1 -> (message "Counting down: %d" 1)
1 <- message: "Counting down: 1"
====================================================================
1 -> (message "Countdown finished!")
1 <- message: "Countdown finished!"
====================================================================

Eseguendo il codice per la conversione delle tabelle org ottengo il seguente risultato in cui il livello 1 è la funzione più esterna mentre le altre due sono allo stesso livello che nel tracciamento corrispondo al secondo livello.

1 -> (org-translate-table-to-html "prova")
| 2 -> (search-forward "#+tblname: prova" nil t)
| 2 <- search-forward: 2062
| 2 -> (insert-buffer-substring #<buffer *temp*> 2046 2062)
| 2 <- insert-buffer-substring: !non-local\ exit!
1 <- org-translate-table-to-html: !non-local\ exit!

6. Eesempio edebug

Decommentando l'istruzione \((debug)\) nel codice countdown e avviando la funzione ottengo q