Uso di alias

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

Un alias è costituito da un nome alias e un alias equivalente. Quando si usa un nome alias come parte di un comando 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 di nome fisso, ma sono denominati $u 0, $u 1, ..., $u 9.

• Il debugger imposta e nomi alias automatici.

Definizione di un alias di User-Named

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

• Il nome alias può essere qualsiasi stringa che non contiene spazio vuoto.

• L'alias equivalente può essere qualsiasi stringa. Se lo si immette nella tastiera, l'alias equivalente non può contenere spazi iniziali o restituisce 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 distinzione tra maiuscole e minuscole.

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

Per rimuovere un alias, usare il comando Ad (Elimina alias).

Per elencare tutti gli alias denominati dall'utente correnti, usare il comando al (Alias elenco).

Definizione di un alias di Fixed-Name

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

Usare il comando r (Registri) per definire gli equivalenti alias per gli alias fissi. Quando si definisce un alias di 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 è consigliabile racchiudere l'alias equivalente tra virgolette (a meno che non si vogliano virgolette nei risultati).

Nota Non confondere usando il comando r (Registri) per gli alias di 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 di nome fisso, è una stringa vuota.

Alias automatici

Il debugger imposta gli alias automatici seguenti.

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 potrebbe essere ntdll32 o altre versioni 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 è lo stesso di $ntnsym. Quando si esegue il debug in 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 di 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 all'alias (ad esempio ${ }), mentre non è possibile usare pseudoregistri con questi token.

Uso di un alias nella finestra dei comandi debugger

Dopo aver definito un alias, è possibile usarlo in qualsiasi voce di comando. Il nome 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 qualsiasi numero di virgolette o punti e virgola, l'alias equivalente può rappresentare più comandi.

Un alias denominato dall'utente viene riconosciuto solo se il nome è separato da altri caratteri in base agli spazi vuoti. 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 un virgolette.

Nota Qualsiasi testo immesso nella finestra comando debugger che inizia con "as", "aS", "ad" o "al" non riceve la sostituzione dell'alias. Questa restrizione impedisce il rendering dei comandi alias. Tuttavia, questa restrizione significa anche che i comandi che seguono annunci pubblicitari o al in una riga non hanno gli alias sostituiti. Se si desidera che gli alias vengano sostituiti 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 l'espansione di un alias o per visualizzare determinati valori correlati all'alias. Per altre informazioni su queste situazioni, vedere ${ } (interprete alias).

Un alias 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 i comandi disponibili solo in WinDbg (.open, .write_cmd_hist (Scrittura cronologia comandi), .lsrcpath e .lsrcfix) e alcuni comandi aggiuntivi (.hh, .cls, .wtitle, .remote, .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. Prendere in considerazione lo script seguente:

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

ad myAlias

La prima volta che passa 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 finché non viene immesso un nuovo blocco di codice. La voce successiva al ciclo è un nuovo blocco, quindi myAlias viene espansa in 610001. Ma è troppo tardi: dovremmo aver visto 610001 la prima volta attraverso il 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 and ${ } (Alias Interpreter).

Uso di un token con estensione foreach in un alias

Quando si usa un token con estensione foreach nella definizione di un alias, è necessario prestare particolare attenzione per assicurarsi che il token sia espanso. Prendere in considerazione la sequenza seguente di comandi.

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

Il primo comando imposta il valore del registro pseudo $t 0 su 5. Il secondo comando elimina qualsiasi valore che potrebbe essere stato assegnato in precedenza 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 come è all'inizio della riga nel corpo del ciclo foreach . Quando una riga inizia con come comando , 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. L'esempio seguente, ad esempio, visualizza 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 è inoltre 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 a nome fisso.

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

È possibile usare alias come macro per i comandi usati di frequente. L'esempio seguente incrementa 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 a 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"

file Tools.ini

In CDB (e NTSD) è possibile predefinito gli alias con nome fisso nel file tools.ini . Per specificare un alias a nome fisso, aggiungere i campi $u che si desidera 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 e alias User-Named

Gli alias di nome utente sono più facili da usare rispetto agli alias con nome fisso. La sintassi di 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 sostituire un alias denominato dall'utente quando è accanto ad altro testo, racchiuderlo nel token ${ } (Interprete alias).

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