Assegnazione dei responsabili di moduli e funzioni

Le estensioni !analyze e !owner usano un file denominato triage.ini per determinare il proprietario dei simboli riscontrati dal debugger.

Quando si usano queste estensioni, le identità della funzione o del proprietario del modulo vengono visualizzate dopo la parola "Followup".

Il file triage.ini è un file di testo che si trova nella sottodirectory \triage dell'installazione di Strumenti di debug per Windows. Un file di esempio triage.ini è incluso come parte del pacchetto Strumenti di debug per Windows.

Avvertimento Se si installa una versione aggiornata di Strumenti di debug per Windows nella stessa directory della versione corrente, sovrascrive tutti i file in tale directory, incluso triage.ini. Dopo aver modificato o sostituito il file di esempio triage.ini, salvare una copia di tale file in una directory diversa. Dopo aver reinstallato i debugger, è possibile copiare il triage.ini salvato sulla versione predefinita.

Formato del file di triage.ini

Anche se il file triage.ini consente di determinare il "proprietario" di una funzione interrotta nel debugger, le stringhe "proprietario" in questo file possono essere qualsiasi cosa che possa aiutarti con il debug. Le stringhe possono essere nomi di persone che hanno scritto o gestito il codice. In alternativa, le stringhe possono essere brevi istruzioni sulle operazioni che è possibile eseguire quando si verifica un errore in un modulo o in una funzione.

Ogni riga di questo file ha la sintassi seguente.

Module[!Function]=Owner 

È possibile aggiungere un asterisco (*) solo alla fine di un modulo o di un nome di funzione. Se viene visualizzato altrove, viene interpretato come carattere letterale.

Non è possibile aggiungere spazi nella stringa del proprietario. Se nella stringa proprietaria esistono spazi, vengono ignorati.

Per altre informazioni sulle opzioni di sintassi, vedere sintassi triage.ini speciale.

Gli esempi seguenti illustrano un file di triage.ini di esempio.

module1=Person1
module2!functionA=Person2
module2!functionB=Person3
module2!funct*=Person4
module2!*=Person5
module3!singleFunction=Person6
mod*!functionC=Person7

Triage.ini e !owner

Quando si passa un modulo o un nome di funzione all'estensione !owner , il debugger visualizza la parola "Followup" seguita dal nome del proprietario del modulo o della funzione.

Nell'esempio seguente viene usato il file di esempio precedente triage.ini.

0:000> !owner module2!functionB
Followup:  Person3

Secondo il file, "Person3" possiede module2!functionB e "Person4" possiede module2!funct\. Entrambe queste stringhe corrispondono all'argomento passato a !owner, quindi viene usata la corrispondenza più completa.

Triage.ini e !analyze

Quando si usa l'estensione !analyze , il debugger esamina il frame di errore superiore nello stack e tenta di determinare il proprietario del modulo e della funzione in questo frame. Se il debugger può determinare il proprietario, vengono visualizzate le informazioni sul proprietario.

Se il debugger non è in grado di determinare il proprietario, il debugger passa al frame dello stack successivo e così via, fino a quando il debugger non determina il proprietario o lo stack viene esaminato completamente.

Se il debugger può determinare il proprietario, il nome del proprietario viene visualizzato dopo la parola "Followup". Se il debugger cerca l'intero stack senza trovare informazioni, non viene visualizzato alcun nome.

Nell'esempio seguente viene usato il file di esempio triage.ini fornito in precedenza in questo argomento.

Supponiamo che il primo frame nello stack sia MyModule!someFunction. Il debugger non trova MyModule nel file triage.ini. Successivamente, continua con il secondo fotogramma nello stack.

Si supponga che il secondo frame sia module3!anotherFunction. Il debugger visualizza una voce per module3, ma non esiste alcuna corrispondenza per un'altra funzione in questo modulo. Successivamente, il debugger continua con il terzo frame.

Si supponga che il terzo frame sia module2!functionC. Il debugger cerca innanzitutto una corrispondenza esatta, ma tale corrispondenza non esiste. Il debugger elimina quindi il nome della funzione e individua module2!funct\* in triage.ini. Questa corrispondenza conclude la ricerca, perché il debugger determina che il proprietario è "Person4".

Il debugger visualizza quindi l'output simile all'esempio seguente.

0:000> !analyze
*******************************************************************************
*                                                                             *
*                        Exception Analysis                                   *
*                                                                             *
*******************************************************************************

Use !analyze -v to get detailed debugging information.

Probably caused by : module2 ( module2!functionC+15a )

Followup: Person4
---------

Una corrispondenza più completa ha la precedenza su una corrispondenza più breve. Tuttavia, una corrispondenza del nome del modulo è sempre preferibile a una corrispondenza del nome della funzione. Se module2!funct\* non fosse presente in questo file triage.ini, il debugger avrebbe selezionato module2!\* come corrispondenza. E se sia module2!funct\* che module2!\* sono stati rimossi, mod*!functionC sarebbe stato selezionato.

Sintassi speciale triage.ini

Se si omette il punto esclamativo e il nome della funzione o si aggiunge !\* dopo un nome di modulo, vengono indicate tutte le funzioni in tale modulo. Se anche una funzione all'interno di questo modulo viene specificata separatamente, la specifica più precisa ha la precedenza.

Se si usa "default" come nome di modulo o nome di funzione, equivale a un carattere jolly. Ad esempio, nt!\* è uguale a nt!default e il valore predefinito è uguale a *!\*.

Se viene eseguita una corrispondenza, ma la parola ignore viene visualizzata a destra del segno di uguale (=), il debugger continua al frame successivo nello stack.

È possibile aggiungere last_ o maybe_ prima del nome di un proprietario. Questo prefisso assegna al proprietario una priorità minore quando si esegue !analyze. Il debugger sceglie una corrispondenza definita più in basso nello stack rispetto a una maybe_ corrispondenza più in alto nello stack. Il debugger sceglie anche una corrispondenza maybe_ inferiore nello stack rispetto a una corrispondenza last_ superiore nello stack.

triage.ini di esempio

Un modello di esempio triage.ini è incluso nel pacchetto Strumenti di debug per Windows. È possibile aggiungere i proprietari di qualsiasi modulo e funzione che si vuole usare per questo file. Se si desidera non avere un valore predefinito globale, eliminare la riga default=MachineOwner all'inizio di questo file.