Gestire errori, Stop e Pause nel Debugger Octave
Nel Debugger nativo di GNU Octave, un Job può terminare correttamente, arrestarsi per un errore dello script oppure essere annullato dall’utente. Sono situazioni differenti: PAUSED significa che il programma è fermo e può avanzare; FAILED indica un’esecuzione fallita; CANCELLED indica l’interruzione richiesta tramite Stop.
Questa guida mostra il comportamento delle tre condizioni nel GX-TXT Octave Script Workspace 1.8.3, usando l’interfaccia della distribuzione DEV112-P005. Le schermate riproducono l’applicazione effettiva: editor High Contrast Dark, controlli e pannelli Tk/ttk con colori nativi.
1. Preparare un esempio che produce un errore controllato
Aprire Octave Script Workspace con una Session attiva. Selezionare File → New Script e salvare con File → Save il sorgente seguente, assegnandogli un identificativo Session. È un esempio didattico: non accede a strumenti, Dataset o file di input.
% Synthetic Octave error for learning the managed native debugger.
1; % Permit local functions in an executable Octave script.
function value = calibration_probe(sample)
calibration_gain = 2.5;
preliminary = sample * calibration_gain;
evidence_vector = [sample, preliminary, 7];
error('O23_SYNTHETIC_ERROR: deliberately invalid reference');
value = preliminary;
endfunction
input_value = 4;
result = calibration_probe(input_value);
fprintf('O23_UNEXPECTED_SUCCESS=%g\n', result);
La funzione calibration_probe prepara alcuni valori e poi richiama esplicitamente error. Quest’istruzione genera una condizione di errore GNU Octave, con messaggio identificabile. Il prodotto preliminary vale 10, ma l’istruzione value = preliminary non viene raggiunta nell’esecuzione che prosegue oltre l’errore.

2. Impostare il breakpoint e distinguere Pause da Stop
Posizionare il cursore sulla riga 7, contenente error(…), e premere F9 per inserire il breakpoint. Aprire Run → Debug Session script…. La scheda Breakpoints permette di controllare il punto di arresto prima di avviare il Job; il pulsante Start Debug avvia la revisione dello script salvata nella Session.
Nel debugger Octave di questa versione, Pause non è disponibile come sospensione asincrona. Il controllo risulta disabilitato e l’informazione associata spiega che l’adattatore CLI non offre una pausa asincrona verificata. Per esaminare il codice si usano invece breakpoint e comandi Step; per interrompere definitivamente un Job si usa Stop.

3. Fermarsi prima dell’errore e leggere le variabili
Premere Start Debug. L’esecuzione raggiunge il breakpoint alla riga 7 e si ferma nello stato PAUSED. La freccia nel margine del sorgente individua la posizione in cui l’interprete è effettivamente sospeso.
Aprire View → Call Stack e View → Variables / Locals, quindi la scheda Stack and variables. Qui le variabili osservate prima dell’errore includono sample = 4, calibration_gain = 2.5, preliminary = 10 ed evidence_vector = [4, 10, 7]. Il pannello mostra tipo, dimensioni e un riepilogo dei valori: non è un interprete interattivo di espressioni.

4. Che cosa succede se si modifica il sorgente durante PAUSED
Il Job è associato a una revisione immutabile del sorgente salvato. Modificare nel frattempo il contenuto dell’editor non modifica il codice del Job già avviato. Quando l’editor contiene differenze non salvate rispetto alla revisione eseguita, Continue, Step Into, Step Over e Step Out vengono disabilitati per evitare di attribuire l’esecuzione a righe non più corrispondenti.
Questo vincolo si applica anche a una piccola modifica al testo. Stop rimane disponibile, perché l’annullamento del Job non richiede che il buffer coincida con lo snapshot eseguito.

5. Ripristinare il sorgente e recuperare i comandi
Annullare la modifica introdotta nel buffer, riportando il testo esattamente alla versione salvata. Quando il sorgente torna pulito e corrispondente alla revisione del Job, i controlli di avanzamento diventano nuovamente disponibili.
Un cambiamento del sorgente può invalidare i breakpoint impostati sulle vecchie posizioni. Prima di iniziare un nuovo Job, verificare sempre che i marcatori desiderati siano ancora presenti e, se necessario, ricrearli con F9. Il ripristino del buffer senza un nuovo salvataggio non crea automaticamente una nuova revisione del Registry.

6. Eseguire l’istruzione error e riconoscere FAILED
Con il Job ancora PAUSED sulla riga 7, premere Continue. GNU Octave esegue la chiamata error(…). Il Job termina in FAILED; non si tratta di un breakpoint o di un normale completamento.
Il debugger conserva il messaggio O23_SYNTHETIC_ERROR: deliberately invalid reference e l’origine effettiva dell’errore: calibration_probe, riga 7. Nel Call Stack resta visibile la traccia dell’eccezione, incluso lo script chiamante. Le variabili sono etichettate come last paused: si riferiscono all’ultima sospensione osservata, non a un contesto di esecuzione ancora attivo.

In questa versione la freccia può rimanere visibile sulla riga di origine dopo il fallimento. Non va interpretata come un Job ancora in PAUSED: lo stato FAILED e i comandi di avanzamento disabilitati prevalgono sulla presenza del simbolo.
7. Consultare Debugger output senza confonderlo con il programma
Aprire la scheda Debugger output. Qui compaiono le comunicazioni del debugger, fra cui il messaggio di eccezione nativo, la transizione di stato e l’avvertenza che le variabili esposte costituiscono l’ultimo snapshot disponibile.
La traccia dell’errore non è una pila di chiamate ancora attiva. Fare clic su un suo frame dopo FAILED non riprende l’interprete e non permette di usare i comandi Step. La consultazione dei messaggi del debugger è distinta dalla lettura dei flussi di output del programma.

8. Aprire i dettagli del Job fallito
Utilizzare Program output / diagnostics… per esaminare il Job gestito. Nei dettagli compaiono il suo stato terminale FAILED e il messaggio prodotto dall’esecuzione GNU Octave; le informazioni permettono di distinguere un errore dello script da una semplice sospensione.
Un Job terminato rimane consultabile come risultato dell’esecuzione. Un esito FAILED non significa che si possa premere Continue per riprendere il medesimo Job: per riprovare dopo avere corretto il codice occorre effettuare una nuova esecuzione, salvando prima le modifiche pertinenti.

9. Interrompere un secondo Job con Stop
Per vedere la differenza fra errore e annullamento, avviare un nuovo Debug su uno script Session salvato e attendere una sospensione reale PAUSED. Nell’esempio successivo il nuovo Job si ferma sulla prima istruzione eseguibile, riga 2, perché non è presente un breakpoint attivo. Se si desidera fermarsi in un punto preciso, verificare prima i marcatori e usare F9.
Durante PAUSED, il pulsante Stop è abilitato. Premerlo significa richiedere la cancellazione del Job gestito corrente, non eseguire una riga Octave e non semplicemente nascondere la finestra del debugger.

La cancellazione è gestita in modo asincrono: osservare lo stato fino alla transizione terminale. Nel caso illustrato il Job passa a CANCELLED, mentre Call Stack, variabili attive e freccia di esecuzione vengono svuotati.

10. Distinguere i risultati e tornare all’editor
Aprire Program output / diagnostics… anche per il Job annullato. La finestra di dettaglio resta disponibile e identifica l’esecuzione come CANCELLED. Confrontando gli esiti si ottengono tre significati diversi: PAUSED è una sospensione reversibile, FAILED è un errore durante il programma e CANCELLED è la conseguenza di una richiesta di arresto.

Dopo lo stato terminale, chiudere la finestra dei dettagli e usare Close / cancel Debug. Per lavorare nuovamente con il codice, lasciare nascosti i pannelli opzionali e usare View → Focus source / restore panes quando necessario. Il sorgente registrato resta salvato; gli esiti dei Job appartengono allo storico delle esecuzioni, non ai Dataset pubblicati.

In sintesi: prima di intervenire, leggere sempre lo stato effettivo del Job. Usare i breakpoint e i comandi Step per un’analisi controllata, Stop per la cancellazione, e i pannelli di output per distinguere messaggi del debugger, errori Octave e diagnostica dell’esecuzione. Non modificare il sorgente presumendo che il Job già avviato ne recepisca automaticamente i cambiamenti.