Uso degli alias

Gli alias sono stringhe di caratteri che vengono sostituite automaticamente con altre stringhe di caratteri. È possibile usarli nei comandi del debugger ed evitare di digitare alcune frasi comuni.

Un alias è costituito da un nome alias e da un alias equivalente. Quando si usa un nome alias come parte di un comando del debugger, il nome viene sostituito automaticamente dall'alias equivalente. Questa sostituzione si verifica immediatamente, prima che il comando venga analizzato o eseguito.

Il debugger supporta tre tipi di alias:

• È possibile impostare e denominare alias denominati dall'utente.

• È possibile impostare alias a nome fisso, ma sono denominati $u 0, $u 1, ..., $u 9.

• Il debugger imposta e assegna nomi agli alias automatici.

Definizione di un alias User-Named

Quando si definisce un alias denominato dall'utente, è possibile scegliere il nome dell'alias e l'alias equivalente:

• Il nome alias può essere qualsiasi stringa che non contiene spazi vuoti.

• L'alias equivalente può essere qualsiasi stringa. Se lo si digita sulla tastiera, l'alias equivalente non può contenere spazi iniziali o ritorni a capo. In alternativa, è possibile impostarlo uguale a una stringa in memoria, il valore di un'espressione numerica, il contenuto di un file, il valore di una variabile di ambiente o l'output di uno o più comandi del debugger.

Sia il nome dell'alias che l'alias equivalente sono sensibili alle maiuscole e minuscole.

Per definire o ridefinire un alias denominato dall'utente, usare il comando as (Set Alias) o aS (Set Alias).

Per rimuovere un alias, usa il comando ad (Elimina alias).

Per elencare tutti gli alias denominati dall'utente corrente, usare il comando al (List Aliases).

Definizione di un alias Fixed-Name

Sono disponibili 10 alias a nome fisso. I nomi degli alias sono $u 0, $u 1, ..., $u 9. Gli equivalenti alias possono essere qualsiasi stringa che non contiene la sequenza di tasti INVIO.

Usare il comando r (Registers) per definire gli equivalenti alias per gli alias a nome fisso. Quando si definisce un alias a nome fisso, è necessario inserire un punto (.) prima della lettera "u". Il testo dopo il segno di uguale (=) è l'alias equivalente. L'alias equivalente può includere spazi o punti e virgola, ma gli spazi iniziali e finali vengono ignorati. Non racchiudere l'alias equivalente tra virgolette (a meno che non si vogliano virgolette nei risultati).

Nota Non confondersi usando il comando r (Registers) per gli alias a nome fisso. Questi alias non sono registri o pseudoregistri, anche se si usa il comando r per impostare gli equivalenti alias. Non è necessario aggiungere un segno at (@) prima di questi alias e non è possibile usare il comando r per visualizzare il valore di uno di questi alias.

Per impostazione predefinita, se non si definisce un alias a nome fisso, si tratta di una stringa vuota.

Alias automatici

Il debugger imposta gli alias automatici seguenti.

Il nome alias	Alias equivalente
$ntnsym	Modulo più appropriato per i simboli NT nell'architettura nativa del computer. Questo alias può essere uguale a ntdll o nt.
$ntwsym	Modulo più appropriato per i simboli NT durante il debug a 32 bit che usa WOW64. Questo alias può essere ntdll32 o un'altra versione a 32 bit di Ntdll.dll.
$ntsym	Modulo più appropriato per i simboli NT che corrispondono alla modalità computer corrente. Quando si esegue il debug in modalità nativa, questo alias è uguale a $ntnsym. Quando si esegue il debug in una modalità non nativa, il debugger tenta di trovare un modulo corrispondente a questa modalità. Ad esempio, durante il debug a 32 bit che usa WOW64, questo alias è uguale a $ntwsym.
$CurrentDumpFile	Nome dell'ultimo file di dump caricato dal debugger.
$CurrentDumpPath	Percorso della directory dell'ultimo file dump caricato dal debugger.
$CurrentDumpArchiveFile	Nome dell'ultimo file di archivio dump (file CAB) caricato dal debugger.
$CurrentDumpArchivePath	Percorso della directory dell'ultimo file di archivio dump (file CAB) caricato dal debugger.

Gli alias automatici sono simili ai pseudoregistri automatici, ad eccezione del fatto che è possibile usare alias automatici con token correlati agli alias (ad esempio ${ }), mentre non è possibile usare pseudoregistri con questi token.

Uso di un alias nella finestra di comando del debugger

Dopo aver definito un alias, è possibile usarlo in qualsiasi voce di comando. Il nome dell'alias viene sostituito automaticamente con l'alias equivalente. Pertanto, è possibile usare l'alias come espressione o come macro.

Un nome alias si espande correttamente anche se è racchiuso tra virgolette. Poiché l'alias equivalente può includere un numero qualsiasi di virgolette o punti e virgola, l'alias equivalente può rappresentare più comandi.

Un alias definito dall'utente viene riconosciuto solo se il nome è separato da altri caratteri con uno spazio. Il primo carattere del nome alias deve iniziare la riga o seguire uno spazio, un punto e virgola o una virgoletta. L'ultimo carattere del nome alias deve terminare la riga o essere seguito da uno spazio, da un punto e virgola o da una virgoletta.

Nota Qualsiasi testo immesso nella finestra di comando del debugger che inizia con "as", "aS", "ad" o "al" non riceve la sostituzione dell'alias. Questa restrizione impedisce ai comandi alias di diventare inutilizzabili. Tuttavia, questa restrizione significa anche che i comandi che seguono annunci o al su una riga non hanno gli alias sostituiti. Se si desidera sostituire gli alias in una riga che inizia con una di queste stringhe, aggiungere un punto e virgola prima dell'alias.

Tuttavia, è possibile usare il token ${ } per espandere un alias denominato dall'utente anche quando si trova accanto ad altro testo. È anche possibile usare questo token insieme a determinate opzioni per impedire che un alias venga espanso o per visualizzare determinati valori correlati agli alias. Per altre informazioni su queste situazioni, vedere ${ } (interprete alias).

Un alias a nome fisso si espande correttamente da qualsiasi punto all'interno di una riga, indipendentemente dalla modalità di incorporamento all'interno del testo della riga.

Non è possibile usare comandi disponibili solo in WinDbg (.open, .write_cmd_hist (Write Command History), .lsrcpath e .lsrcfix) e alcuni comandi aggiuntivi (.hh, .cls, .wtitle, .remote, kernel-mode.restart e user-mode .restart) con alias.

Uso di un alias in un file di script

Quando si usa un alias in un file di script, è necessario prestare particolare attenzione per assicurarsi che l'alias sia espanso al momento corretto. Si consideri lo script seguente:

.foreach (value {dd 610000 L4})
{
   as /x ${/v:myAlias} value + 1
   .echo value myAlias
}

ad myAlias

La prima volta che si esegue il ciclo, il comando as, aS (Set Alias) assegna un valore a myAlias. Il valore assegnato a myAlias è 1 più 610000 (il primo output del comando dd). Tuttavia, quando viene eseguito il comando echo (Echo Comment), myAlias non è ancora stato espanso, quindi invece di visualizzare 610001, viene visualizzato il testo "myAlias".

0:001> $$>< c:\Script02.txt
00610000 myAlias
00905a4d 0x610001
00000003 0x905a4e
00000004 0x4
0000ffff 0x5

Il problema è che myAlias non viene espanso fino a quando non viene immesso un nuovo blocco di codice. La voce successiva del ciclo costituisce un nuovo blocco, quindi myAlias viene espanso in 610001. Ma è troppo tardi: avremmo dovuto vedere 610001 la prima volta nel ciclo, non la seconda volta. È possibile risolvere questo problema racchiudendo il comando echo (Echo Comment) in un nuovo blocco, come illustrato nello script seguente.

.foreach (value {dd 610000 L4}) 
{
   as /x ${/v:myAlias} value + 1
   .block{.echo value myAlias}
}

ad myAlias

Con lo script modificato, si ottiene l'output corretto seguente.

0:001> $$>< c:\Script01.txt
00610000 0x610001
00905a4d 0x905a4e
00000003 0x4
00000004 0x5
0000ffff 0x10000

Per altre informazioni, vedere .block e ${ } (interprete alias).

Uso di un token .foreach in un alias

Quando si usa un token foreach nella definizione di un alias, è necessario prestare particolare attenzione per assicurarsi che il token venga espanso. Si consideri la sequenza di comandi seguente.

r $t0 = 5
ad myAlias
.foreach /pS 2 /ps 2 (Token {?@$t0}) {as myAlias Token}
al

Il primo comando imposta il valore dello pseudoregistro $t 0 su 5. Il secondo comando elimina qualsiasi valore che potrebbe essere stato precedentemente assegnato a myAlias. Il terzo comando accetta il terzo token del comando ?@$t 0 e tenta di assegnare il valore di tale token a myAlias. Il quarto comando elenca tutti gli alias e i relativi valori. Si prevede che il valore di myAlias sia 5, ma il valore è la parola "Token".

   Alias            Value  
 -------          ------- 
 myAlias          Token 

Il problema è che il comando as si trova all'inizio della riga nel corpo del ciclo foreach . Quando una riga inizia con un comando as, gli alias e i token in tale riga non vengono espansi. Se si inserisce un punto e virgola o uno spazio vuoto prima di come comando, qualsiasi alias o token che ha già un valore viene espanso. In questo esempio myAlias non viene espanso perché non ha già un valore. Il token viene espanso perché ha un valore pari a 5. Ecco la stessa sequenza di comandi con l'aggiunta di un punto e virgola prima di come comando.

r $t0 = 5
ad myAlias
.foreach /pS 2 /ps 2 (Token {?@$t0}) {;as myAlias Token}
al

Ora si ottiene l'output previsto.

  Alias            Value  
 -------          ------- 
 myAlias          5 

Alias ricorsivi

È possibile usare un alias a nome fisso nella definizione di qualsiasi alias. È anche possibile usare un alias denominato dall'utente nella definizione di un alias a nome fisso. Tuttavia, per usare un alias denominato dall'utente nella definizione di un altro alias denominato dall'utente, è necessario aggiungere un punto e virgola prima del comando as o aS oppure la sostituzione dell'alias non si verifica in tale riga.

Quando si usano definizioni ricorsive di questo tipo, ogni alias viene convertito non appena viene usato. Ad esempio, nell'esempio seguente viene visualizzato 3, non 7.

0:000> r $.u2=2 
0:000> r $.u1=1+$u2 
0:000> r $.u2=6 
0:000> ? $u1 
Evaluate expression: 3 = 00000003

Analogamente, nell'esempio seguente viene visualizzato 3, non 7.

0:000> as fred 2 
0:000> r $.u1= 1 + fred 
0:000> as fred 6 
0:000> ? $u1 
Evaluate expression: 3 = 00000003

L'esempio seguente è consentito e visualizza 9.

0:000> r $.u0=2 
0:000> r $.u0=7+$u0 
0:000> ? $u0
Evaluate expression: 9 = 00000009

Esempi di alias

È possibile usare alias in modo che non sia necessario digitare nomi di simboli lunghi o complessi, come nell'esempio seguente.

0:000> as Short usersrv!NameTooLongToWantToType
0:000> dw Short +8

L'esempio seguente è simile all'esempio precedente, ma usa un alias con nome fisso.

0:000> r $.u0=usersrv!NameTooLongToWantToType
0:000> dw $u0+8

È possibile usare alias come macro per i comandi usati di frequente. Nell'esempio seguente vengono incrementati due volte i registri eax ed ebx .

0:000> as GoUp r eax=eax+1; r ebx=ebx+1
0:000> GoUp
0:000> GoUp

Nell'esempio seguente viene usato un alias per semplificare la digitazione dei comandi.

0:000> as Cmd "dd esp 14; g"
0:000> bp MyApi Cmd 

L'esempio seguente è simile all'esempio precedente, ma usa un alias con nome fisso.

0:000> r $.u5="dd esp 14; g"
0:000> bp MyApi $u5 

Entrambi gli esempi precedenti sono equivalenti al comando seguente.

0:000> bp MyApi "dd esp 14; g"

Tools.ini File

In CDB (e NTSD) è possibile predefinire gli alias a nome fisso nel file tools.ini. Per definire un alias a nome fisso, aggiungere i campi $u da inserire nella voce [NTSD], come nell'esempio seguente.

[NTSD]
$u1:_ntdll!_RtlRaiseException
$u2:"dd esp 14;g"
$u9:$u1 + 42

Non è possibile impostare alias denominati dall'utente nel file Tools.ini.

alias Fixed-Name contro alias User-Named

Gli alias di nome utente sono più facili da usare rispetto agli alias con nome fisso. La sintassi della definizione è più semplice ed è possibile elencarle usando il comando al (List Aliases).

Gli alias con nome fisso vengono sostituiti se vengono usati accanto ad altro testo. Per fare in modo che un alias denominato dall'utente venga sostituito quando è accanto ad altro testo, racchiuderlo nel token ${ } (Alias Interpreter).

La sostituzione dell'alias con nome fisso viene eseguita prima della sostituzione degli alias denominati dall'utente.