Debugger di runtime (Cordbg.exe)
Il Debugger di runtime consente ai fornitori di strumenti e agli sviluppatori di applicazioni di individuare e correggere i bug dei programmi basati sul Common Language Runtime di .NET Framework. Questo strumento utilizza l'API di debug del runtime per offrire servizi di debug. Il codice sorgente di Cordbg.exe viene fornito come applicazione di esempio. Gli sviluppatori possono esaminare il codice per comprendere come utilizzare i servizi di debug. Al momento è possibile utilizzare Cordbg.exe solo per effettuare il debug di codice gestito in quanto non esiste alcun supporto per il debug di codice non gestito.
Utilizzare la prima riga di sintassi riportata di seguito per avviare una sessione di Cordbg.exe. Utilizzare la seconda riga al prompt di (cordbg) all'interno di una sessione di Cordbg.exe.
cordbg [ProgramName[Program arguments]][optional arguments ]
command [command arguments]
Parametri
| Comando | Descrizione | ||||||
|---|---|---|---|---|---|---|---|
ap[pdomainenum] [opzione] |
Enumera tutti i domini applicazione, gli assembly e i moduli del processo corrente. Se non si specifica l'argomento opzione, verranno elencati tutti i domini applicazione, gli assembly e i moduli del processo corrente. Dopo operazioni di connessione e disconnessione, è necessario specificare il comando go per riprendere l'esecuzione. L'argomento opzione può essere uno dei seguenti:
|
||||||
as[sociatesource] {s|b id puntointerruzione} nomefile |
Associa il nome file specificato al puntatore dello stack frame corrente (opzione s) o al punto di interruzione specificato (opzione b). |
||||||
a[ttach] pid |
Connette il debugger a un processo in esecuzione. Cordbg.exe interrompe l'eventuale programma di cui sta effettuando il debug e tenta di connettersi al processo specificato dall'argomento pid. Il numero pid di identificazione del processo può essere in formato decimale o esadecimale. |
||||||
b[reak] [[file:] numero riga] | [[ classe::] funzione [:offset]] |
Imposta o visualizza i punti di interruzione. Se non si specifica alcun argomento, verrà visualizzato l'elenco dei punti di interruzione correnti. Se viene invece specificato un argomento, verrà impostato un punto di interruzione nella posizione specificata. È possibile impostare un punto di interruzione in corrispondenza di un numero di riga nel file di origine corrente, in corrispondenza di un numero di riga in un file di origine con nome completo oppure in un metodo qualificato mediante una classe ed eventualmente un offset. I punti di interruzione persistono anche quando vengono effettuate più esecuzioni di una sessione. È possibile utilizzare il comando stop con le stesse modalità di break. In Cordbg.exe i punti di interruzione vengono visualizzati come "non associati" se la posizione per essi specificata non è associabile a codice. Quando un punto di interruzione è non associato, significa che il codice sottostante relativo alla posizione del punto di interruzione non è stato ancora caricato. Questo si può verificare per vari motivi, ad esempio a causa dell'errata digitazione di un nome di file o di classe (per questi nomi è necessario rispettare l'esatta combinazione di maiuscole e minuscole). I punti di interruzione saranno inoltre non associati se vengono impostati prima di eseguire un'applicazione e divengono associati quando viene caricato il codice effettivo. Quando carica un modulo, il debugger tenta automaticamente di associare ciascun punto di interruzione non associato. |
||||||
ca[tch] [evento] |
Visualizza un elenco di tipi di evento o fa in modo che il tipo di evento specificato interrompa il debugger. Se non si specifica alcun argomento, verrà visualizzato l'elenco dei tipi di evento, nel quale i tipi che interrompono il debugger saranno contrassegnati da "on" e quelli che vengono ignorati saranno contrassegnati da "off". Se si specifica un argomento, il debugger verrà interrotto al verificarsi di eventi del tipo specificato. Per impostazione predefinita, il debugger viene interrotto solo per eventi di eccezioni non gestite, ovvero eccezioni second-chance. I tipi di evento che interrompono il debugger persistono anche quando vengono effettuate più esecuzioni di una sessione. Per far sì che il debugger ignori un particolare tipo di evento, utilizzare il comando ignore. L'argomento event può essere uno dei seguenti:
|
||||||
conn[ect] machine_name port |
Per progetti Smart Device. Viene eseguita la connessione a un dispositivo remoto in cui viene eseguita un'applicazione .NET Compact Framework.
|
||||||
cont [conteggio] |
Continua l'esecuzione del programma. Se non si specifica alcun argomento, il programma continua per una volta. Se si specifica un argomento, il programma continua per il numero di volte specificato. Questo comando è utile per continuare un programma quando il debugger viene interrotto da un evento di caricamento classe, da un'eccezione o da un punto di interruzione. È possibile utilizzare il comando go con le stesse modalità di cont. |
||||||
del[ete] [id puntointerruzione, ...] |
Elimina i punti di interruzione. Se non si specifica alcun argomento, verranno eliminati tutti i punti di interruzione correnti. Se si specificano uno o più argomenti id puntointerruzione, verranno eliminati i punti di interruzione specificati. È possibile ottenere identificatori di interruzione utilizzando il comando break o stop. È possibile utilizzare il comando remove con le stesse modalità di delete. |
||||||
de[tach] |
Disconnette il debugger dal processo corrente. Il processo continua automaticamente e viene eseguito come se il debugger non fosse connesso a esso. |
||||||
dis[assemble] [0xindirizzo][{+|-} delta] [riga conteggio] |
Visualizza istruzioni disassemblate native per il puntatore all'istruzione corrente o per l'argomento indirizzo, se specificato. Il numero predefinito delle istruzioni visualizzate è cinque. Se si specifica un argomento riga conteggio, verrà visualizzato il numero specificato di istruzioni supplementari prima e dopo l'indirizzo o il puntatore all'istruzione corrente. L'ultimo argomento riga conteggio utilizzato diviene l'impostazione predefinita per la sessione corrente. Se si specifica un delta, il numero specificato verrà aggiunto al puntatore all'istruzione corrente o all'indirizzo specificato per l'inizio del disassembly. |
||||||
d[own] [conteggio] |
Sposta in basso il puntatore allo stack frame verso i frame chiamati dal frame corrente a scopo di ispezione. Se non si specifica alcun argomento, il puntatore allo stack frame si sposterà verso il basso di un frame. Se si specifica un argomento, il puntatore allo stack frame si sposterà verso il basso per il numero di frame specificato. Se sono disponibili informazioni sul livello dell'origine, verrà visualizzata la riga del codice sorgente relativa al frame. Questo comando viene utilizzato spesso insieme al comando up. |
||||||
du[mp] indirizzo [conteggio] |
Esegue il dump di un blocco di memoria, con l'output in formato esadecimale o decimale, a seconda della modalità del debugger (vedere mode). L'argomento indirizzo è l'indirizzo del blocco di memoria. L'argomento conteggio è il numero di byte di cui eseguire il dump. |
||||||
ex[it] |
Interrompe il processo corrente e chiude il debugger. È possibile utilizzare il comando quit con le stesse modalità di exit. |
||||||
f[unceval] [classe::] funzione [ arg0 arg1 ...argn] |
Valuta la funzione specificata sul thread corrente. Il nuovo oggetto viene memorizzato nella variabile $result in modo da poter essere utilizzato per valutazioni successive. Gli argomenti validi sono limitati ad altre variabili, a valori integer da 4 byte e alle costanti Null, True e False. Nota Nel caso di una funzione membro, il primo argomento deve essere un oggetto della classe o della classe derivata cui la funzione membro appartiene. |
||||||
g[o] [conteggio] |
Vedere cont. |
||||||
h[elp] [comando ...] |
Visualizza descrizioni per i comandi specificati. Se non si specifica alcun argomento, verrà visualizzato l'elenco dei comandi del debugger. È possibile utilizzare il comando ? con le stesse modalità di help. |
||||||
ig[nore] [evento] |
Visualizza un elenco dei tipi di evento o fa in modo che il tipo di evento specificato venga ignorato dal debugger. Se non si specifica alcun argomento evento, verrà visualizzato l'elenco dei tipi di evento, nel quale i tipi che vengono ignorati dal debugger saranno contrassegnati da "off" e quelli che lo interrompono saranno contrassegnati da "on". Se si specifica un argomento, gli eventi del tipo specificato verranno ignorati. Per impostare un tipo di evento che interrompa il debugger, utilizzare il comando catch. L'argomento evento può essere uno dei seguenti tipi di evento:
|
||||||
i[n] [conteggio] |
Vedere step. |
||||||
k[ill] |
Interrompe il processo corrente. Il debugger rimane attivo per elaborare ulteriori comandi. |
||||||
l[ist] opzione |
Visualizza un elenco di funzioni globali, classi o moduli caricati. L'argomento opzione può essere uno dei seguenti:
|
||||||
m[ode] [[nome modalità {0|1} ] |
Imposta e visualizza particolari modalità del debugger per varie funzionalità dello strumento. Per impostare un valore, specificare il nome modalità e 1 per indicarne l'attivazione oppure 0 per indicarne la disattivazione. Se non si specifica alcun argomento, verrà visualizzato l'elenco delle impostazioni correnti delle modalità. Le modalità persistono nel Registro di sistema di Windows anche quando vengono effettuate più esecuzioni di Cordbg.exe. Per ulteriori informazioni, vedere la tabella degli argomenti di mode del debugger. |
||||||
newo[bj] classe |
Crea un nuovo oggetto utilizzando il thread corrente. Il nuovo oggetto viene memorizzato nella variabile $result in modo da poter essere utilizzato per valutazioni successive. |
||||||
newobjnc classe |
Crea un nuovo oggetto utilizzando il thread corrente senza eseguire un costruttore sull'oggetto. Il nuovo oggetto viene inizializzato su zero Il nuovo oggetto viene memorizzato nella variabile $result in modo da poter essere utilizzato per valutazioni successive. |
||||||
news[tr] stringa |
Crea una nuova stringa utilizzando il thread corrente. Il nuovo oggetto viene memorizzato nella variabile $result in modo da poter essere utilizzato per valutazioni successive. |
||||||
n[ext] [conteggio] |
Fa avanzare il programma alla successiva riga di codice sorgente, ignorando le chiamate di funzioni. Se non si specifica alcun argomento, l'avanzamento sarà di una sola riga di codice sorgente. Se si specifica un argomento, l'avanzamento sarà del numero di righe specificato. È possibile utilizzare il comando so con le stesse modalità di next. |
||||||
ns[ingle] [conteggio] |
Fa avanzare il programma di una o più istruzioni, ignorando le chiamate di funzioni. Se non si specifica alcun argomento, l'avanzamento sarà di una sola istruzione. Se si specifica un argomento count, l'avanzamento sarà del numero di istruzioni specificato. |
||||||
o[ut] [conteggio] |
Fa uscire il programma dalla funzione corrente. Se non si specifica alcun argomento, il programma uscirà solo dalla funzione corrente. Se si specifica un argomento, il programma uscirà da un numero di funzioni pari al valore specificato. |
||||||
pa[th] [nuovo percorso] |
Visualizza o imposta il percorso utilizzato per la ricerca di file di origine e di simboli di debug. Se non si specifica alcun argomento, verrà visualizzato il percorso corrente. Se si specifica un argomento nuovo percorso, questo diventerà il nuovo percorso utilizzato per la ricerca dei file di origine e dei simboli di debug. Questo percorso persiste tra sessioni differenti perché viene mantenuto nel Registro di sistema di Windows. |
||||||
p[rint] [nome variabile] |
Visualizza una o più variabili locali con i corrispondenti valori. Se non si specifica alcun argomento, verranno visualizzate tutte le variabili locali con i corrispondenti valori. Se si specifica un argomento, verrà visualizzato solo il valore della variabile locale specificata. Per informazioni dettagliate, vedere Utilizzo del comando print nella sezione Esempi. |
||||||
pro[cessenum] |
Enumera tutti i processi gestiti e i domini applicazione di ciascun processo. |
||||||
q[uit] |
Vedere exit. |
||||||
ref[reshsource] [file origine] |
Carica nuovamente il codice sorgente relativo a un determinato file di origine. È necessario che il file di origine da caricare nuovamente faccia parte del programma in esecuzione. Dopo aver impostato il percorso del file di origine mediante il comando path, sarà possibile utilizzare il comando refreshsource per recuperare il codice sorgente mancante. |
||||||
regd[efault] [imposizione] |
Imposta Cordbg.exe come debugger JIT predefinito. Non verrà eseguita alcuna operazione se è già stato registrato un altro debugger. Utilizzare l'argomento imposizione per sovrascrivere il debugger JIT registrato. |
||||||
reg[isters] |
Visualizza il contenuto dei registri per il thread corrente. |
||||||
rem[ove] [id puntointerruzione, ...] |
Vedere delete. |
||||||
re[sume] [~] [tid] |
Riprende il thread specificato dall'argomento tid quando continua l'esecuzione del debugger. Se si utilizza la sintassi ~, verranno ripresi tutti i thread a eccezione di quello specificato. Se non si specifica alcun argomento, il comando non avrà alcun effetto. |
||||||
r[un] [eseguibile [argomenti]] |
Interrompe l'eventuale processo corrente e ne avvia uno nuovo. Se non si specifica alcun argomento eseguibile, verrà eseguito l'ultimo programma eseguito con il comando run. Se si specifica un argomento eseguibile, verrà eseguito il programma specificato utilizzando eventuali argomenti forniti. Se Cordbg.exe ignora gli eventi di caricamento classi, caricamento moduli e avvio thread (come avviene per impostazione predefinita), il programma verrà interrotto in corrispondenza della prima istruzione eseguibile del thread principale. |
||||||
set variabile valore |
Imposta il valore della variabile specificata sul valore specificato. Il valore può essere un valore letterale o un'altra variabile. Per informazioni dettagliate, vedere Utilizzo del comando set nella sezione Esempi. |
||||||
setip numero riga |
Imposta sul numero riga specificato la successiva istruzione da eseguire. |
||||||
sh[ow] [conteggio] |
Visualizza righe del codice sorgente. Se non si specifica alcun argomento, verranno visualizzate le cinque righe del codice sorgente che precedono e seguono la riga corrente del codice sorgente. Se si specifica un argomento, verrà visualizzato il numero specificato di righe che precedono e seguono la riga corrente. L'ultimo argomento conteggio specificato diviene l'impostazione predefinita per la sessione corrente. |
||||||
si [<conteggio>] |
Vedere step. |
||||||
so [<conteggio>] |
Vedere next. |
||||||
ss[ingle] [conteggio] |
Fa avanzare il programma di una o più istruzioni, eseguendo le chiamate di funzioni. Se non si specifica alcun argomento, verrà eseguita una sola istruzione. Se si specifica un argomento, verrà eseguito il numero di istruzioni specificato. |
||||||
s[tep] [conteggio] |
Fa avanzare il programma alla successiva riga di codice sorgente, eseguendo le chiamate di funzioni. Se non si specifica alcun argomento, il programma avanzerà alla riga successiva. Se si specifica un argomento, il programma avanzerà del numero di righe specificato. È possibile utilizzare il comando si o in con le stesse modalità di step. |
||||||
stop [[file:] numero riga] | [[classe::] funzione[:offset]] | [=0xindirizzo] |
Vedere break. |
||||||
su[spend] [~] [tid] |
Sospende il thread specificato dall'argomento tid quando continua l'esecuzione del debugger. Se si utilizza la sintassi ~, verranno sospesi tutti i thread a eccezione di quello specificato. Se non si specifica alcun argomento, il comando non avrà alcun effetto. |
||||||
t[hreads] [tid] |
Visualizza un elenco di thread o imposta il thread corrente. Se non si specifica alcun argomento, verrà visualizzato l'elenco di tutti i thread ancora attivi e che hanno eseguito codice gestito. Se si specifica un argomento, il thread corrente verrà impostato sul thread specificato. |
||||||
up [conteggio] |
Sposta in alto il puntatore allo stack frame verso i frame che hanno chiamato il frame corrente a scopo di ispezione. Se non si specifica alcun argomento, il puntatore allo stack frame si sposterà verso l'alto di un frame. Se si specifica un argomento, il puntatore allo stack frame si sposterà verso l'alto per il numero di frame specificato. Se sono disponibili informazioni sul livello dell'origine, verrà visualizzata la riga del codice sorgente relativa al frame. |
||||||
w[here] [conteggio] |
Visualizza un'analisi dello stack per il thread corrente. Se non si specifica alcun argomento, verrà visualizzata un'analisi dello stack completa. Se si specifica un argomento, verrà visualizzato il numero specificato di stack frame. |
||||||
wr[itememory] indirizzo conteggio byte, ... |
Scrive i byte specificati nel processo di destinazione. L'argomento indirizzo specifica la posizione in cui scrivere i byte. L'argomento conteggio specifica il numero di byte da scrivere. Gli argomenti byte specificano gli elementi da scrivere nel processo. Se il numero di byte dell'elenco è minore di quello specificato dall'argomento conteggio, una volta raggiunto il termine dell'elenco si riprenderà dai byte iniziali. Se il numero di byte dell'elenco è maggiore di quello specificato dall'argomento conteggio, i byte in eccesso verranno ignorati. |
||||||
wt |
Fa avanzare l'applicazione per istruzioni native, iniziando dall'istruzione corrente e stampando via via la struttura delle chiamate. Il numero di istruzioni native eseguite in ciascuna funzione viene stampato con l'analisi delle chiamate. L'analisi si interrompe quando lo strumento raggiunge l'istruzione return per la funzione in cui il comando è stato eseguito in origine. Al termine dell'analisi viene stampato il numero totale delle istruzioni eseguite. Questo comando è analogo al comando wt di NT Symbolic Debugger ed è utilizzabile per un'analisi di base delle prestazioni. Attualmente è possibile solo il conteggio del codice gestito. |
||||||
x nomemodulo ! stringa_da_cercare |
Visualizza simboli nel modulo specificato che soddisfano i criteri definiti dall'argomento stringa_da_cercare. È possibile utilizzare il carattere asterisco (*) nell'argomento stringa_da_cercare a indicare che qualsiasi elemento potrà soddisfare i criteri. Eventuali caratteri specificati dopo il carattere * verranno ignorati. |
||||||
? [comando ...] |
Vedere help. |
||||||
> nomefile |
Scrive tutti i comandi eseguiti nel nomefile specificato. Se non si specifica nomefile, verrà interrotta la scrittura di comandi nel file. |
||||||
< nomefile |
Legge ed esegue i comandi presenti nel nomefile specificato. |
Nota
I comandi di Cordbg.exe sono soggetti alla distinzione tra maiuscole e minuscole. Vari comandi, inoltre, dispongono di sinonimi ed è pertanto possibile utilizzare indifferentemente uno di questi comandi per ottenere gli stessi risultati. È ad esempio possibile utilizzare il comando break o stop per impostare punti di interruzione.
Argomenti di mode
È possibile specificare gli argomenti di mode utilizzando il minor numero di caratteri necessari per rendere univoca la modalità. "mode m 1" equivale ad esempio a "mode moduleloads 1".
| Argomento | Descrizione |
|---|---|
AppDomainLoads |
Visualizza eventi di caricamento domini applicazione ed eventi di caricamento assembly. |
ClassLoads |
Visualizza eventi di caricamento classi. |
DumpMemoryInBytes |
Visualizza il contenuto della memoria sotto forma di byte o di valori DWORD. |
EmbededCLR |
Imposta il debugger per le applicazioni .NET Compact Framework eseguite su dispositivi Smart Device. Specificare 1 per attivare l'impostazione o 0 per disattivarla. |
EnhanceDiag |
Visualizza informazioni di diagnostica avanzate. |
HexDisplay |
Visualizza i numeri in formato esadecimale o decimale. |
ILNatPrint |
Visualizza gli offset in linguaggio MSIL (Microsoft Intermediate Language), in linguaggio nativo relativo o in entrambi i linguaggi. |
ISAll |
Esegue uno a uno tutti gli intercettatori. |
ISClinit |
Esegue uno a uno gli inizializzatori di classe. |
ISExceptF |
Esegue uno a uno i filtri delle eccezioni. |
ISInt |
Esegue uno a uno gli intercettatori utente. |
ISPolicy |
Esegue uno a uno i criteri di contesto. |
ISSec |
Esegue uno a uno gli intercettatori di protezione. |
JitOptimizations |
Specifica se la compilazione JIT genera codice di cui è possibile eseguire il debug in modo più semplice. |
LoggingMessages |
Visualizza messaggi di log del codice gestito. |
ModuleLoads |
Visualizza eventi di caricamento moduli. |
SeparateConsole |
Specifica se il processo in fase di debug dispone di una console propria. |
ShowArgs |
Visualizza gli argomenti dei metodi nell'analisi dello stack. |
ShowModules |
Visualizza i nomi dei moduli nell'analisi dello stack. |
ShowStaticsOnPrint |
Visualizza campi statici per oggetti. |
ShowSuperClassOnPrint |
Visualizza il contenuto della classe di base per oggetti. |
USAll |
Esegue una ad una tutte le posizioni di interruzione non mappate. |
USEpi |
Esegue uno a uno gli epiloghi dei metodi. |
USPro |
Esegue uno a uno i prologhi dei metodi. |
USUnmanaged |
Esegue il codice non gestito un'istruzione alla volta. |
Note
È necessario compilare l'applicazione di cui effettuare il debug utilizzando flag specifici del compilatore, che determinano la generazione di simboli di debug. Per ulteriori informazioni su questi flag, fare riferimento alla documentazione fornita con il compilatore. È possibile eseguire il debug delle applicazioni ottimizzate, tuttavia alcune informazioni di debug risulteranno mancanti. Diverse variabili locali, ad esempio, non risulteranno visibili e le righe del codice sorgente non saranno corrette.
Dopo aver compilato l'applicazione, digitare cordbg al prompt dei comandi per avviare una sessione di debug, come illustrato nell'esempio che segue.
D:\Program Files\FrameworkSDK\Bin>cordbg
Microsoft (R) Common Language Runtime Test Debugger Shell. Version 2000.14.2100.0, Copyright (c) Microsoft Corp. 1998-2000
(cordbg)
Il prompt (cordbg) indica che il debugger è in esecuzione.
Sarà quindi possibile utilizzare i comandi e gli argomenti appropriati per richiamare le necessarie funzionalità dello strumento.
Quando si avvia una sessione di debug dalla riga di comando, è inoltre possibile specificare il nome dell'applicazione di cui si desidera effettuare il debug, gli argomenti di programma ed eventuali argomenti facoltativi. Gli argomenti facoltativi di Cordbg.exe consistono nei normali comandi utilizzati in Cordbg.exe, ai quali viene aggiunto come prefisso un punto esclamativo (!). È tuttavia possibile utilizzare il carattere ! come carattere effettivo in una stringa facendolo precedere da un carattere di barra rovesciata (\). Questo è necessario quando si utilizza il comando x.
Se un argomento numerico di un comando inizia con il prefisso 0x, verrà automaticamente considerato in formato esadecimale. In caso contrario, verrà considerato in formato decimale.
Alla maggior parte dei comandi di Cordbg.exe è possibile aggiungere come prefisso un asterisco (*), in modo da eseguire il comando una volta per ogni thread gestito del processo. Il comando verrà eseguito nel contesto di ciascun thread. Il comando più utile a cui aggiungere come prefisso un asterisco è il comando w[here]. Specificando ad esempio *w, verrà stampata l'analisi dello stack di ciascun thread gestito.
Per ulteriori informazioni sui servizi di debug del runtime, vedere la specifica Enabling Profiling and Debugging. È inoltre consigliabile che gli sviluppatori di strumenti facciano riferimento alle specifiche Debug Overview e Debug Reference presenti nella cartella Tools Developers Guide di .NET Framework SDK.
Esempi
Avvio di una sessione di Corgbg.exe
Il comando che segue avvia una sessione di Cordbg.exe per l'applicazione MyApplication.exe con gli argomenti di programma a e 2 e con i seguenti comandi facoltativi: impostazione di un punto di interruzione in MyApplication.cs alla riga 42, continuazione dell'applicazione, visualizzazione di simboli in MyApplication.exe in corrispondenza della stringa 'SomeString'.
cordbg MyApplication.exe a 2 !b MyApplication.cs:42 !g !x MyApplication.exe\!SomeString
Avvio di un eseguibile in una sessione di Cordbg.exe
Il comando che segue, immesso da una sessione di Cordbg.exe al prompt (cordbg), esegue l'eseguibile MyApplication.exe con gli argomenti di programma a e 2.
run MyApplication.exe a 2
Utilizzo del comando print
I comandi che seguono illustrano come sia possibile utilizzare la notazione del punto con il comando print per specificare variabili all'interno di oggetti.
print obj.var1
print obj1.obj2.var1
Se una classe estende un'altra classe, il comando print visualizzerà sia i campi della classe specificata sia quelli della classe di base. Se ad esempio la classe m1 presenta i campi a, b e c e la classe m2 estende la classe m1 e presenta i campi d, e ed f, un'istanza myInstance di m2 verrà stampata come segue.
myInstance = <addr> <m2>
a = 1
b = 2
c = 3
m2::d = 4
m2::e = 5
m2::f = 6
È possibile specificare variabili statiche di classe aggiungendo come prefisso al nome della variabile il nome della classe, come illustrato di seguito.
print MyClass::StaticVar1
print System::Boolean::True
Gli indici di matrice devono essere espressioni semplici. Gli indici di matrice che seguono sono utilizzabili con il comando print.
print arr[1]
print arr[i]
print arr1[arr2[1]]
print md[1][5][myObject.a]
Gli indici di matrice che seguono non sono utilizzabili con il comando print, in quanto l'indice di matrice non è un'espressione semplice.
print arr[i + 1]
print arr[i + 2]
Utilizzo del comando set
Quando si utilizza il comando set, il valore assegnato alla variabile specificata può essere un valore letterale o un'altra variabile. Di seguito sono illustrati alcuni esempi validi di utilizzo del comando set.
set int1 0x2a
set float1 3.1415
set char1 'a'
set bool1 true
set obj1 0x12345678
set obj1 obj2
set obj1.m_length[obj1.m_height] obj3.m_length[2]