Der Stack eines Programms wird, wie in jeder modernen Sprache, so auch in C, in Frames unterteilt. Damit die calc-Routine aus C heraus ohne Komplikationen aufrufbar ist, sollte man sich an diese Konvention halten.

Für jede aufgerufene Funktion muss zu Beginn im sogenannten Funktionsepilog ein Stackframe erzeugt werden. Der Stackframe beinhaltet, neben allgemeinen Steuerdaten wie der Rücksprungadresse und dem gesicherten Inhalt von EBP auch die lokalen Variablen der Funktion. Nachdem das EBP-Register auf dem Stack abgelegt wurde, wird in ihm der aktuelle Stackpointer zwischengespeichert. EBP dient im Rumpf der Funktion der Adressierung der übergebenen Parameter sowie der lokalen Variablen. Die calc-Funktion benötigt zwei Fließkommazahlen zu je 4 Byte und somit insgesamt 8 Byte an lokalen Variablen. Dieser Platz wird mit der Anweisung sub esp,8 auf dem Stack alloziert. Darüberhinaus werden die beiden Register ESI und EDI auf dem Stack gesichert.

Nach der Ausführung des Funktionsepilogs ergibt sich folgende Stackstruktur:

Bevor die Funktion die Kontrolle wieder an das C-Programm zurückgibt, muss der erstellte Stackframe wieder freigegeben werden. Dies geschieht im Funktionsepilog. Zu diesem Zweck werden als erstes die Register ESI und EDI wieder vom Stack geladen. Anschließend wird der Stackpointer auf den zu Beginn in EBP gespeicherten Wert zurückgesetzt und es wird das EBP-Register der aufrufenden Funktion wiederhergestellt. Nachdem alle für die aufrufende Funktion wichtigen Register wieder in ihren Ausgangszustand gebracht wurden, wird mittels ret die Kontrolle wieder an diese übertragen.

Im nächsten Codeblock werden die übergebenen Pointer in Register geladen. Die Anzahl der Tripel wird in einem späteren Codeblock geladen. Hierbei ergibt sich folgende Belegung:

Zwischen dem Laden der Pointer und dem Laden von ECX findet sich im Code noch ein kleiner Einschub. In ihm werden die eben geladenen Pointer allesamt um 4 verringert, um ihre Verwendung im weiteren Programmablauf zu vereinfachen.

Bei der Berechnung der Ergebnisse gemäß der Kapazitäts-Formel wird auf die Eingabewerte jeweils nach dem Schema [EBX+4*ECX] zugegriffen. Hierbei wird ECX mit jedem Schleifendurchlauf dekrementiert. ECX beginnt im ersten Schleifendurchlauf mit der Anzahl der zu berechnenden Wertetripel als Wert und zählt von dort runter bis zur 1 (inklusive). ECX ist somit eigentlich um eins zu groß, um als Arrayindex zu dienen. Man könnte den Zugriff [EBX+4*ECX]natürlich in [EBX+4*ECX-4] abändern, hierdurch würde die Adressberechnung jedoch komplexer werden. Stattdessen wird dieser konstante Offset gleich zu Beginn in die Pointer mit einberechnet.

Die eigentliche Auswertung der Formel wird aus Performancegründen in zwei getrennten Schritten ausgeführt. Im ersten Schritt wird der Teil der Formel, welcher nicht von der Länge des Kondensators oder den Radien abhängt außerhalb der eigentlichen Hauptschleife berechnet. Hierzu werden der Wert von ε_r1 bzw. ε_r1 jeweils mit ε₀ multipliziert. Die Ergebnisse werden in die beim Erstellen des Stackframes resevierten lokalen Variablen zwischengespeichert.

Innerhalb der Hauptschleife wird dann der zweite, von Länge und Radien abhängige, Teil errechnet. Hierbei werden die oben vorberechneten Faktoren verwendet um das Zwischenergebniss auf die beiden Endergebnisse zu skalieren. Die Ergebnisse werden bereits in der Schleife an die richtigen Stellen in den Ausgabe-Arrays geschrieben.

Am Ende des Codes finden sich die Deklarationen von 3 globalen Variablen. Aufgrund der Tatsache, dass die beiden ersten Variablen ε_r1 und ε_r2, mit denen die calc-Methode ihre Ergebnisse berechnet global verfügbar sind, können deren Werte ohne weiteres überschrieben werden. Es wird dann einfach mit anderen Werten für ε_r1 bzw. ε_r2 gerechnet. Diesen Weg verwendet auch das C-Programm um die vom Nutzer gewünschten Dielektrizitätskonstaten an die Assemlerroutine weiterzureichen.

Auch wenn die beiden Variablen überschrieben werden können, so haben sie dennoch bereits zu Beginn sinnvolle Startwerte, nämlich die Dielektrizitätskonstaten von Paraffin und Ölpapier. Sollten also keine speziellen Werte für ε_r2 gewünscht sein, so kann man die globalen Variablen getrost ignorieren.

Die letzte der drei globalen Variablen sollte auf keinen Fall überschrieben werden. Sie ist nur als global deklariert, um aus den Testcases heraus bequem auf ihren Wert zugreifen zu können.

Um die übergebenen Parameter zu interpretieren, wird zu Beginn der main-Funktion eine Instanz der Struktur Parameters erzeugt. In ihr werden sogleich die Standardwerte gespeichert, welche verwendet werden sollen, wenn der Benutzer zu einem Parameter keine Angaben macht. Die Adresse dieser Struktur sowie die Anzahl der Parameter (argc) und der Inhalt der Parameter (argv) wird dann an die Funktion parse_params übergeben. Diese Funktion iteriert über sämtliche Parameter und versucht die übergebenen Parameter zu parsen und zu validieren. Die Ergebnisse werden in die übergebene Parameters-Struktur gespeichert.

Sollte die Validierung fehlschlagen, so wird die Funktion usage aufgerufen und die Ausführung des Programms anschließend abgebrochen. usage schreibt eine Übersicht der verfügbaren Parameter und Hinweise zur korrekten Nutzung des Programms nach stderr.

Diese beiden Funktionen spielen nur dann eine Rolle, wenn der Parameter -v mit einem Wert größer oder gleich 2 angegeben wurde. Ist dies der Fall, dann gibt die Funktion debug_print_input nocheinmal sämtliche eingelesene Wertetripel auf stderr aus. debug_print_results funktioniert analog und gibt sämtliche errechneten Wertepaare aus.

Die Funktion parse_csv übernimmt das Parsen der Eingabedaten. Diese Eingabedaten haben im CSV-Format vorzuliegen, wobei die einzelnen Werte einer Zeile jeweils durch einen Tabstop getrennt sind. Eine while-Schleife iteriert über alle verfügbaren Zeilen. Bei Bedarf werden in dieser Schleife die Zielarrays vergrößert und neu allokiert. Die Array-Größe wird hierbei immer verdoppelt, wodurch sich eine logarithmische anstatt einer quadratischen Laufzeitkomplexität erreichen lässt. Überflüssiger Speicher wird vor Verlassen der Funktion wieder freigegeben. Mithilfe der Funktion fscanf werden die Daten der jeweiligen Zeile geparst und im jeweiligen Zielarray gespeichert. Fehleingaben führen zum vorzeitigen Abbruch der while-Schleife, die Ausführung des Programms wird aber dennoch fortgesetzt.

Die Funktion write_csv stellt das Gegenstück zur Funktion parse_csv dar: Sie iteriert über die Ergebnis-Wertepaare, formatiert diese mithilfe von fprintf und gibt sie dabei an die als Funktionsargument übergebene Ausgabe weiter.

Aufgabe der main-Funktion ist im Grunde nur noch Variablen anzulegen und die beschriebenen Funktionen in der richtigen Reihenfolge aufzurufen. Nachdem die Parameter geparst wurden, werden Pointer auf die Arrays für die Eingabedaten deklariert. Pointer auf diese werden gemeinsam (Pointer auf Pointer auf Werte) mit einem Pointer auf einen Integer, welcher die Anzahl der gelesenen Wertetripel speichern wird, an die Funktion parse_csv übergeben. Ist die Funktion fertig, werden die zwei Arrays, die später die Ergebnisse der Berechnungen enthalten sollen, deklariert und allooziert und die Werte der externen Variablen epsilon_r1 und epsilon r2 durch die als Parameter übergebenen ersetzt. Dann wird die Ausführung der calc-Funktion, die in Assembler implementiert wurde, angestoßen. Abschließend werden die Ergebnisse mit write_csv ausgegeben, der von den Arrays belegte Speicher wieder freigegeben. Während all dem sorgen eingeschobene if-Blöcke dafür, dass dem Verbosity-Level entsprechend Meldungen über den internen Zustand gemacht werden.