Quelltext mit Formatierungs- und Style-Informationen versehen

[CodeCrack]

Hallo,

ich möchte ein Programm schreiben, das einen C++-Quellcode nimmt und in einer neuen Datei speichert, dabei aber nicht die alte Formatierung übernimmt, sondern den Quelltext anhand von vozugebenden Regeln formatiert. Das Programm macht also im Wesentlichen das, was die Format-Funktion (Ctrl+Shift+F) von eclipse mit dem Code macht, soll dann aber zusätzlich Styleinformationen hinzufügen, sodass ich formatierte Quelltexte erhalte, die z.B. der tex- oder der HTML-Spezifikation entsprechen (um ein benutzerdefiniertes Syntax-Highligting bekommen).

Der erste Schritt wäre sicher, den Ursprungs-Quellcode zu parsen. Dafür habe ich schon verschiedene Ansätze ausprobiert. Ich habe überlegt, was besser wäre, die gesamte Quellcode-Datei zeilenweise einzulesen mit split() zu zerlegen und jedem Ausdruck die Information, um welche Art Ausdruck es sich handelt mitzugeben und abzuspeichern, oder ob es sinnvoll wäre, Zeichen für Zeichen zu untersuchen und nach Ausdrücken zu suchen, die meinen Kriterien entsprechen.

Im zweiten Schritt würde ich dann die gesammelten und gespeicherten Informationen auswerten und entsprechend "formatiert" (also inklusive Style-Informationen) abspeichern.

Wie würdet ihr an diese Aufgabe (vor allem im ersten Schritt) rangehen? Welche Klassen des SDK würdet ihr ggf. nutzen? Ich würde gerne (mit eurer Hilfe) erst eine ungefähre Richtung festlegen, bevor ich weitermache.

Zwei Fragen, die sich für mich ergeben haben, sind:
1. Sollte ich die Datei zeichenweise, zeilenweise oder als Ganzes verarbeiten?
2. Sollte ich, um den Quelltext in seine Bestandteile zu zerlegen, ein mehrstufiges oder ein flaches Verfahren verwenden?

Für die, die noch nicht genau wissen, was ich meine, hier ein Beispiel:
Aus folgendem Code:

//---------------------------------------------------
// Game2.cpp :
// Kollisionskontrolle, Treppen und Gravitation
//---------------------------------------------------

#include "Game2.h"

//---------------------------------------------------

// Spiel initialisieren/"aufbauen"
void TGame::CreateGame (HWND GHandle)
{
  geRect   WorldScreen;    // Anzeigefläche
}

... macht mein Programm das:

<span class="preprocessor">#include "Game2.h"</span>

<span class="comment">// Spiel initialisieren/"aufbauen"</span>
<span class="keyword">void </span><span class="">TGame</span><span class="">::</span><span class="method">CreateGame</span><span class="operator">(</span><span class="">HWND </span><span class="">GHandle</span><span class="operator">) </span><span class="operator">{</span>
<tab indent=4><span class="type">geRect</span> <span class="class">WorldScreen</span><span class="operator">; </span><span class="comment">// Anzeigefläche</span>
<span class="operator">}</span>

Dies in einem Browser angezeigt, bekommt man in etwa:

#include "Game2.h"

// Spiel initialisieren/"aufbauen"
void TGame::CreateGame(HWND GHandle) {
    geRect WorldScreen; // Anzeigefläche
}

Wie man an diesem Beispiel sieht, ist die Formatierung des Codes nach der Bearbeitung durch mein Programm verändert.

Ich freue mich über jeden Gedanken/Vorschlag/Idee.

 

[Flown]

Ich hab mal etwas ähnliches für JavaScript gebastelt. Es war zwar ein spezieller Highlighter für Sondefeatures, aber sollte ziemlich gleich sein.

Ich hatte einen AST mit dem Debugger Interface. Somit konnte ich die Speziellen Nodes herausholen und mit der Debugger API die Stellen raussuchen.
Wahrscheinlich ist es schlau soetwas mit ANTLR zu basteln. Ich hatte damals dafür den GraalVM Compiler zur Verfügung.

 

[CodeCrack]

Danke Flown, für deine Impulse. Allerdings sprichst du von Böhmischen Dörfern. Du hattest einen AST mit einem Debugger Interface? Was ein Debugger ist, weiß ich, aber was hat das in Kombination mit einem Interface zu bedeuten? Was ist ein "AST"? Was meinst du an dieser Stelle mit Knoten/Node? Wo konntest du das "herausholen" und was meinst du an dieser Stelle mit "herausholen"? Was eine API ist, weiß ich ebenfalls, doch auch hier wieder, ist mir die Verknüpfung mit einem Debugger unplausibel. Du schreibst, du hättest einen GraalVM Compiler für ANTLR gehabt. Was hat das eine mit dem anderen zu tun? Das erschließt sich mir - als Außenseiter - nicht von allein! Du meinst, du hattest das Framework ANTLR genutzt, um Code zu schreiben, den du dann mit dem GraalVM Compiler compiliert hast? Deine Antwort lässt mich denken, dass ich nichts weiß, außer, dass ich nichts weiß, aber eine praktische Hilfe ist das nicht.

Kann ich meine Aufgabe durchführen ohne mich zuvor in die Lage zu versetzen, einen Compiler zu programmieren?!

Edit: Wie ich gerade herausfand, ist GraalVM kein Compiler, sondern eine Alternative zur JVM. Dann stellt sich aber die Frage, was das Wort Compiler in diesem Zusammenhang bedeutet. Meinst du vielleicht Interpreter?

 

[Flown]

Entschuldige, dass ich es nicht sehr gut formuliert habe.

Was ich gemacht habe: JavaScript-File -> GraalVM Compiler (genauer nur den Parser) -> AST (Abstract Syntax Tree) -> AST durchlaufen, die richtigen Nodes im AST suchen -> Mittels DebuggerAPI die Stelle im Quelltext suchen -> Ausgeben.

Was du benötigst ist definitiv einen Parser für die Sprache und die Verbindung wo die Knoten des AST im Quelltext sind (das macht normallerweise ein Debugger). AST durchlaufen und die Ausgabe in deinem Format tätigen.

 

[CodeCrack]

Entschuldigen? Hee, ich bin froh, dass du versuchst mir zu helfen!

Ich möchte aber eigentlich die Erfahrung machen, etwas Eigenes zu entwickeln. Allerdings will ich keinen kompletten Compiler schreiben, das wäre zu viel des Guten.

Ich will einfach nur Sprachelemente identifizieren und mit Stilinformationen für die Darstellung z.B. im Browser versehen.

Aber ich scheitere schon an der Frage, ob ein SAX-Parser prinzipiell ausreichen würde, oder ob es ein DOM-Parser sein muss.

Desweiteren wundert es mich, dass man "an jeder Ecke" XML-Parser findet, aber keinen "individuell konfigurierbaren" Parser, also einen Parser, mit dem ich beliebige Dokumente parsen kann.

 

[Flown]

Gibt es der heißt ANTLr oder COCO/r

 

[CodeCrack]

Uff, ganz schön aufwändig, sich da reinzuarbeiten. Aber der Ansatz gefällt mir. Trotzdem folgende Frage: Nehmen wir an, ich würde bei der Formatierung auf die Unterscheidung von Klassen und Methoden verzichten, sondern nur codestrukturierende Sonderzeichen auswerten, könnte ich dann auf eine weniger Komplexe Möglichkeit zurückgreifen, z.B. auf Reguläre Ausdrücke, oder so?

 

[Flown]

könnte ich dann auf eine weniger Komplexe Möglichkeit zurückgreifen, z.B. auf Reguläre Ausdrücke, oder so?

Möglich... Aber kommt ganz drauf an. Die sichere Seite ist auf jedenfall die Parsersache.