Episode

Defrag Tools #170 - Debugger - JavaScript-Skripting

Defrag Tools

In dieser Episode von Defrag Tools spricht Andrew Richards mit Andy Luhrs und Bill Messmer aus dem Debugtools für Windows-Team. Wir sprechen über die neuen JavaScript-Erweiterbarkeits- und Skriptfähigkeiten in WinDbg, die im WDK- und SDK-Build 14951 und höher verfügbar sind.

Bill nutzte das Debuggerobjektmodell zuvor in diesen Episoden:

Zeitachse:

[00:00] Willkommen und Einführungen
[00:24] Neuer SDK-Drop
[00:29] Warum JavaScript
[02:07] Neue Befehle
[03:50] Visual Studio Code
[04:00] Beispiel - Hallo Welt
[07:15] Standardnamespaces des Debuggers
[09:07] Beispiel : Alle Threads drucken
[10:26] Beispiel - Bedingter Haltepunkt
[18:13] 'g' vs. 'gc' – Andrew war richtig! "gc" setzt die Ausführung auf die gleiche Weise fort, wie sie gestartet wurde. Wenn Sie also auf 'p' klicken und dann einen bedingten Haltepunkt treffen, der darin "gc" enthält, beendet das "gc" einfach ihre anfängliche "p".
[20:40] Beispiel - Eindeutige Stapel
[34:40] Beispiel - Addition

Fragen/Kommentare? Senden Sie uns eine E-Mail: defragtools@microsoft.com.

JavaScript MSDN-Dokumente:

Unique Stacks (Beispiel) (das rechte Beispiel):

"strikte Verwendung";

class __stackEntry { constructor(frameString) { this.threads = []; this.frameString = frameString; this.children = new Map(); }

display(indent) 
{
    for (var child of this.children.values())
    {
        host.diagnostics.debugLog(indent, child.frameString, " [Threads In Branch: ");
        for (var thread of child.threads)
        {
            host.diagnostics.debugLog(thread.Id, " ");
        }
        host.diagnostics.debugLog("]\n");
        child.display(indent + "    ");
    }
}

}

class __stackMap { constructor(process) { this.__process = process; this.__root = new __stackEntry(""); this.build(); }

build()
{
    for (var thread of this.__process.Threads)
    {
        var current = this.__root;
        var frameNum = 0;

        var frameCount = thread.Stack.Frames.Count();
        for (var frameNum = frameCount - 1; frameNum >= 0; --frameNum) {
            var frame = thread.Stack.Frames[frameNum];
            var frameString = frame.toString();
            if (current.children.has(frameString)) {
                current = current.children.get(frameString);
                current.threads.push(thread);
            }
            else {
                var newEntry = new __stackEntry(frameString);
                current.children.set(frameString, newEntry);
                current = newEntry;
                current.threads.push(thread);
            }
        }
    }
}

findEntry(thread)
{
    var current = this.__root;
    var frameCount = thread.Stack.Frames.Count();
    for (var frameNum = frameCount - 1; frameNum >= 0; --frameNum)
    {
        var frame = thread.Stack.Frames[frameNum];
        var frameString = frame.toString();
        if (!current.children.has(frameString))
        {
            return null;
        }
        current = current.children.get(frameString);
    }
    return current;
}

display()
{
    this.__root.display("");
}

}

class __threadSameStacks { constructor(thread) { this.__thread = thread; }

getDimensionality()
{
    return 1;
}

getValueAt(idx)
{
    for (var idxVal of this)
    {
        var tid = idxVal[Symbol.indicies][0];
        if (idxVal[Symbol.indicies][0] == idx && tid != this.__thread.Id)
        {
            return idxVal.value;
        }
    }
    return undefined;
}

*[Symbol.iterator]()
{
    var context = this.__thread.hostContext;
    var session = host.namespace.Debugger.Sessions.getValueAt(context);
    var process = session.Processes.getValueAt(context);
    var map = new __stackMap(process);
    var entry = map.findEntry(this.__thread);
    if (entry != null)
    {
        for (var sharingThread of entry.threads)
        {
            if (sharingThread.Id != this.__thread.Id)
            {
                yield new host.indexedValue(sharingThread, [sharingThread.Id]);
            }
        }
    }
}

}

class __threadExtension { get IdenticalStacks() { return new __threadSameStacks(this); } }

function invokeScript() { var map = new __stackMap(host.currentProcess); map.display(); }

function initializeScript() { return [new host.namedModelParent(__threadExtension, "Debugger.Models.Thread")]; }