GX-TXT Python Script Workspace: Pause, Continue e avanzamento nel debugger nativo
Il debugger Python nativo di GX-TXT permette di eseguire uno Script registrato una riga alla volta, entrare nelle funzioni, tornare al chiamante e sospendere un calcolo. I controlli principali sono Start Debug, Continue, Pause, Stop, Step Into, Step Over e Step Out. Questa guida spiega il comportamento reale dei pulsanti, gli stati del Job e le condizioni necessarie per utilizzare il debugging sulla revisione corretta del codice.
1. Debugger e normale Run Job
La modalità Debug esegue il programma tramite il supervisore GX-TXT, ma lo fa con un adapter Python che osserva le istruzioni del sorgente. È diversa da Validate review, che controlla una richiesta senza eseguirla, e da un normale Run Job, che esegue il programma senza fermarsi ai punti di debug. Un Job Debug mantiene identità, revisione e SHA-256 dello Script registrato: non esegue arbitrariamente ciò che appare nell’editor se contiene modifiche non salvate.
2. Preparare un esempio con funzioni distinte
Aprire una Session, creare un nuovo Script Python e inserire un piccolo esempio sintetico. È preferibile utilizzare un programma senza strumenti fisici, accessi remoti o pubblicazioni: l’avanzamento riga per riga deve essere facilmente osservabile. Il nostro codice comprende transform, combine, main e una funzione di attesa controllata, controlled_spin.

3. Salvare prima di eseguire il Debug
Dopo avere compilato Script ID, Name, Version e Scope, premere File → Save. Lo Script viene registrato nella Session, con una revisione e uno SHA-256 del sorgente. Il debugger lavora sulla copia immutabile di quella revisione. Eventuali cambiamenti del testo richiedono un nuovo salvataggio prima della successiva sessione Debug.

4. Scegliere una riga di chiamata
Nell’esempio, combine chiama transform alla riga 12. Questa riga è utile per distinguere Step Into, che entra nella funzione, da Step Over, che mantiene il controllo nel chiamante. Portare il cursore sulla riga di chiamata e premere F9 per creare il breakpoint. Un cerchio rosso compare nel margine; F9 non avvia Python.
def transform(value):
shifted = value + 2
square = shifted * shifted
return square
def combine(samples):
total = 0
for sample in samples:
term = transform(sample)
total += term
return total

5. Aprire il pannello Debugger
Usare Run → Debug Session script…. La barra originale contiene Start Debug, Continue, Pause, Stop, Step Into, Step Over, Step Out, Breakpoint e Clear all. Quando il debugger è ancora IDLE, soltanto Start Debug e le operazioni appropriate sui breakpoint sono attive; i controlli che richiedono un Job sospeso restano disabilitati. Per questa guida è sufficiente la scheda Breakpoints o Debugger output: Call Stack e Variables saranno trattati separatamente.

6. Start Debug e prima sospensione
Premere Start Debug con il sorgente registrato e pulito. L’adapter Python nativo crea un Job gestito dal supervisore; l’esecuzione si ferma inizialmente sulla prima istruzione osservabile del file, nell’esempio import time alla riga 2. Il debugger mostra PAUSED e il margine disegna una freccia gialla. Questa prima pausa può comparire anche prima di raggiungere un breakpoint inserito dall’utente.

7. Continue fino al breakpoint
Da PAUSED, premere Continue. Il debugger lascia avanzare Python fino al successivo breakpoint valido. Nell’esempio, l’esecuzione si ferma alla riga 12 di combine, prima di eseguire transform(sample). La freccia gialla indica la posizione attuale, mentre il cerchio rosso segnala il breakpoint preimpostato. Continue non equivale a eseguire una sola riga.

8. Step Into entra nella funzione chiamata
Con il Job sospeso sulla chiamata term = transform(sample), premere Step Into. Il controllo passa dalla funzione combine a transform e il debugger si ferma sulla sua prima istruzione eseguibile, la riga 5. È il comando da usare per comprendere il funzionamento interno della funzione invocata. La selezione del cursore nel codice non sostituisce il controllo Step Into: conta la riga realmente segnalata da PAUSED.

9. Step Over avanza nella stessa funzione
All’interno di transform, il comando Step Over esegue l’istruzione corrente e si ferma alla successiva riga pertinente dello stesso livello di chiamata. Nell’esempio, il debugger passa dalla riga 5 alla 6, dove calcola square = shifted * shifted. Se la riga corrente contiene una chiamata a un’altra funzione, Step Over permette normalmente di completarla senza entrare nelle sue singole istruzioni.

10. Step Out torna al chiamante
Se non occorre esaminare il resto della funzione attiva, usare Step Out. Il debugger lascia terminare transform e torna nella funzione chiamante combine, fermandosi nell’esempio sulla riga 13, total += term. Step Out è quindi particolarmente utile quando si è entrati in una funzione per errore oppure se ne è già compreso il comportamento e si vuole riprendere il ragionamento nel chiamante.

11. Confrontare Step Into, Step Over e Step Out
La differenza fondamentale è il livello della chiamata. Step Into segue il codice di una funzione chiamata; Step Over lascia completare la riga corrente senza entrare nei dettagli delle eventuali chiamate; Step Out completa la funzione corrente e riprende nel chiamante. I tre controlli richiedono un Job in stato PAUSED e lavorano sulla copia sorgente salvata. Non sono comandi di navigazione testuale dell’editor.
12. Quando i pulsanti sono attivi
Gli stati del debugger determinano quali pulsanti si possono usare. In IDLE è disponibile Start Debug. In PAUSED sono attivi Continue, Step Into, Step Over, Step Out e Stop, mentre Pause non serve perché l’esecuzione è già sospesa. In RUNNING, il comando Pause può essere disponibile per richiedere una sospensione asincrona; gli Step rimangono disabilitati fino a un nuovo arresto. I tooltip ripetono i nomi effettivi dei comandi. Non assumere automaticamente le scorciatoie F5, F10 o F11 di altri ambienti: utilizzare i pulsanti mostrati da GX-TXT.
13. La freccia gialla è diversa dal breakpoint
Il breakpoint rosso è una regola fissata dall’utente su una riga eseguibile. La freccia gialla è invece un’osservazione della posizione raggiunta dall’interprete. Quando il Job è sospeso sul breakpoint, i due simboli possono comparire uno accanto all’altro. Se si procede con Step Into o Step Out, la freccia cambia riga e funzione, mentre il punto resta nella sua posizione originale. È la freccia, insieme allo stato PAUSED, a documentare dove si trova realmente l’esecuzione.
14. Stop termina un Job gestito
Se non si desidera proseguire, premere Stop nel Debugger. Il pulsante chiede al supervisore di interrompere il Job corrente; non è necessario terminare manualmente l’interprete Python. Nell’esempio il Job di stepping è terminato con stato finale CANCELLED e il debugger ha rimosso la freccia gialla. CANCELLED non è la stessa cosa di un calcolo normalmente COMPLETED.

15. Un Job Debug non pubblica automaticamente Dataset
Il fatto che il debugger abbia eseguito istruzioni Python non comporta necessariamente la pubblicazione di un Dataset canonico. I log, gli stati e le copie congelate dello Script fanno parte della tracciabilità del Job, ma i risultati numerici diventano Dataset soltanto attraverso un’operazione di pubblicazione autorizzata. Questo esempio utilizza dati sintetici e non effettua alcuna pubblicazione.
16. Preparare la prova di Pause senza breakpoint
Per distinguere una sospensione asincrona da un arresto programmato, chiudere il Job precedente e rimuovere tutti i breakpoint con F9 o Clear all. In questo modo non resta alcuna riga rossa che possa provocare una pausa automatica. Il programma di prova contiene una funzione controlled_spin con un ciclo di durata limitata che esegue istruzioni ripetute, senza strumenti esterni o Dataset.

17. Start Debug è inizialmente PAUSED anche senza punti
Aprendo un nuovo Job Debug senza breakpoint, il debugger si ferma comunque sulla prima istruzione osservabile, nell’esempio la riga 2. Da qui si può utilizzare Continue per portare il Job nello stato RUNNING. È importante distinguere questa sospensione iniziale da una successiva richiesta di Pause fatta durante il lavoro effettivo del programma.

18. Pause è disponibile quando Python è RUNNING
Con l’adapter Python installato, il pannello dichiara il supporto per Pause asincrono. Durante RUNNING il pulsante Pause diventa attivo e il tooltip originale indica Pause. Il comando richiede la sospensione al Job gestito; il suo clic non costituisce, da solo, prova che l’interprete sia già fermo. Occorre osservare un successivo stato PAUSED e la freccia gialla sul sorgente.

19. Una limitazione della sospensione senza breakpoint
Nella versione qui descritta è emersa una limitazione: se non esiste alcun breakpoint, un programma che entra in funzioni Python annidate può continuare fino a COMPLETED anche dopo che Pause è stato accettato. Il pulsante resta presentato come disponibile, ma la sospensione non è garantita in questa situazione. Non considerare quindi un clic su Pause una conferma di arresto; se occorre interrompere il Job, usare Stop e controllare lo stato finale.
20. Perché il tracciamento delle funzioni conta
L’adapter utilizza il debugger standard Python bdb, che può evitare di tracciare le chiamate in alcune funzioni quando non sono presenti breakpoint. In tale situazione il controllo asincrono potrebbe non essere rilevato durante il ciclo interno. Questo limite riguarda la combinazione fra tracciamento e sospensione, non il calcolo scientifico del programma. Il comportamento può essere verificato con codice sintetico, senza modificare i sorgenti GX-TXT.
21. Verificare Pause con un breakpoint futuro
Per distinguere l’effettivo supporto a Pause dalla limitazione precedente, nel test è stato posizionato un breakpoint su una riga successiva al ciclo, riga 27. Quel punto non viene raggiunto prima della sospensione. La sua presenza mantiene attivo il tracciamento delle funzioni del medesimo file, consentendo di verificare se Pause si comporta come un arresto asincrono. È una condizione diagnostica dell’esempio, non un suggerimento generale di inserire punti arbitrari nei programmi scientifici.

22. Il comando Pause prima del punto futuro
Avviato il nuovo Job, la sequenza rimane Start Debug → PAUSED iniziale → Continue → RUNNING. Con il programma già nel ciclo, Pause è ancora abilitato. L’utente richiede la sospensione mentre il breakpoint futuro non è stato raggiunto. La presenza del punto nella figura non deve essere interpretata come la causa immediata della pausa: la verifica decisiva è la riga effettivamente osservata quando compare PAUSED.

23. Una vera sospensione asincrona nel ciclo
Nella prova controllata, il comando Pause ha interrotto realmente la funzione controlled_spin alla riga 19, cioè sulla condizione del ciclo while. Il Job era RUNNING ed è passato a PAUSED, mostrando la freccia gialla sulla riga 19. Il breakpoint predisposto alla riga 27 non era stato raggiunto. Questo dimostra il funzionamento effettivo di Pause quando il tracciamento delle funzioni è attivo.

24. Cosa si può fare dopo Pause
Quando lo stato è realmente PAUSED, tornano disponibili Continue, Step Into, Step Over, Step Out e Stop. L’esecuzione osservata appartiene sempre allo stesso Job e alla stessa revisione immutabile dello Script. Per proseguire utilizzare Continue oppure uno dei controlli Step appropriati; per terminare, scegliere Stop. Non alterare nel frattempo i breakpoint del Job già attivo.
25. Stop dopo una pausa asincrona
La seconda prova si è conclusa con Stop dal vero stato PAUSED. Il supervisore ha terminato il Job come CANCELLED, senza creare Dataset e rimuovendo la freccia di esecuzione. Dopo la chiusura del pannello Debugger, i breakpoint tornano modificabili. Nel nostro esempio è stato rimosso anche il punto diagnostico futuro, lasciando il codice pulito.

26. Stato, revisione e tracciabilità
Un Debug completo si riconosce dalla combinazione di riferimento dello Script, revisione, SHA-256, Job e stato. PAUSED documenta una riga effettivamente raggiunta e sospesa; RUNNING significa che le istruzioni possono continuare; COMPLETED e CANCELLED sono due esiti terminali differenti. I rapporti del Job conservano una copia del sorgente eseguito. Le preferenze del debugger e il testo visibile nell’editor non modificano retroattivamente quella copia.
27. Controlli pratici e gestione dei problemi
Prima di Start Debug, verificare Session, Script registrato, modifiche non salvate e breakpoint. Dopo Continue, osservare lo stato e non dedurre un arresto dal solo clic su Pause. Se Pause non produce PAUSED, utilizzare Stop per cancellare in modo gestito, oppure preparare un nuovo Job con breakpoint significativi. Se il sorgente viene modificato dopo il salvataggio, registrare la nuova revisione e ripreparare il Debug. Le operazioni di esame dettagliato di Call Stack e Variables saranno trattate nel capitolo successivo.
28. Tornare al Python Script Workspace
Terminati i Job e chiuso il pannello Debugger, riaprire il sorgente nella visualizzazione High Contrast Dark. I controlli Step, Continue e Pause non hanno riscritto il codice registrato. Questa guida ha mostrato la semantica dei pulsanti e la differenza fra interruzione programmata e sospensione asincrona; la guida successiva approfondirà Call Stack, Locals, Globals e selezione dei frame durante PAUSED.
