Dokumentation für Parser aus Delphi VCL?

[DualCoreCpu]

Halloooo,

Ich beschäftigen mich gerade mit den Demos zu TSynCompletionPropsal.

Wenn ich damit Delphi Quelltext vervollständigen will, muss ich ja den Quelltext irgendwie lesen und
passend aufbereiten. Dazu gibt es Parser. Es gibt auch eine Parserklasse in der Delphi VCL, die möglicherweise für die Sprache ObjectPascal erst mal verwendbar wäre. Wo gibt es da Dokus zu dieser Klasse, am besten mit Anwendungsbeispielen?

Ist es überhaupt sinnvoll da eine eigene Lösung zu entwickeln, oder gibt es da vorgefertigte Lösungen.
Schließlich möchte ich ja die Funktionen, Prozeduren und Methoden irgendwie in die ItemList der Komponente TSynCompletionProposal reinkriegen. Der Parser liest die einzelnen Tokens. Aber wie erhalte ich dann die einzelnen Methoden, Funktionen und Prozeduren so, das ich sie in die Itemlist einfügen kann. Im Demo zu Synedit sind in der ItemList einfach paar beispielhafte Funktionen und Prozeduren fertig eingebaut, ebenso in der insertlist, die die Tokens enthält, die in den Quelltext eingefügt werden.

Mein Parser müsste ja nun die Tokens so bereit stellen, das ich sie in die Listen einfügen kann.

Wo erhalte ich dazu Informationen oder Dokus?

[arbu man]

Sprachen sind ein recht komplexes Thema, eben den Parser (oft auch Scanner genannt) musst du noch eine Grammatik aufbauen. Das lässt sich gut durch aufbauen eines Syntaxbaum erreichen.
Als Beispiel nehm ich jetzt Folgende Gramatik:

Code:

funktion : 'funktion' <whitespace> <bezeichner> '(' <parameters> ')'
parameters: ( <bezeichner> ':' <bezeichner> ',' <parameters> )  | <bezeichner> ':' <bezeichner> | 'void'
bezeichner: ('a'...'z')*

Gegeben sei folgende Eingabe:

Code:

funktion     dosomething(a:int,b:float)

Der Scanner liefert dann folgendes

Code:

keyword('funktion')
whitespace('      ')
bezeichner('dosomething')
klammerauf()
...
klammerzu()

Daraus kannst du dann den Syntaxbaum aufbauen. Ich merke gerade das ich noch jede Menge schreiben müsste um das Beispiel zu beenden. Am besten suchst du im Internet nach folgenden Begriffen:

http://de.wikipedia.org/wiki/Syntaxbaum
http://de.wikipedia.org/wiki/Formale_Grammatik

Edit: Um noch mal auf deine Eigentlich Frage zurüchk zukommen, in der VCL ist mit keine solche Klasse bekannt, in Java gibt es jedoch eine Scanner Klasse java.util.Scanner, das xtext Projekt bietet sogar die Möglichkeit aus einer Grammatik einen Interpreter samt IDE! zu erstellen.

Gruß Björn

[generic]

ist nicht auf der extra cd von delphi ein lexer/parser dabei?
schau mal nach pascalscript, dort ist evtl. der parser dabei als src.

Delphi Compiler Generator
http://www.soft-gems.net/index.php?o...d=25&Itemid=33

[DualCoreCpu]

Hallo Björn!

Danke für Deine schnelle Antwort. Du fragst, wo es in der VCL eine Parserklasse gibt.

Das ist in der Unit "Classes" die Klasse "TParser".

Dort gibt es zumindest schon mal eine Funktion "TokenString".

Von Yacc und Lex hab ich schon mal gehört.

Habe soeben gegoogelt und eine deutschsprachige Dokumentation mit dem Titel "yacc-Eine Einführung"
gefunden und werde mir diese erst mal durcharbeiten. Der vorletzte Link auf der ersten Google Seite ->Suchbegriff "Yacc" ohne die Anführungszeichen.

Wer mir aber erst mal die Doku des Delphi Compiler Genrators anschauen, den mir soeben der User @generic empfohlen hat. Villeicht finde ich ja dort schon alles.

Im übrigen hoffe ich, das die Klasse TParser der Unit Classes auch mit dieser standardisierten Grammatikbeschreibung gesteuert wird. Sonst brauch ich nen anderen Parser.

Ich will ne Grammatik für Objektpascal und später für C++ und evtl noch Assembler.

Damit will ich dann eine Codevervollständigung mit TSynCompletionProposal bauen.

Zitat von generic:

ist nicht auf der extra cd von delphi ein lexer/parser dabei?
schau mal nach pascalscript, dort ist evtl. der parser dabei als src.

Den PascalScript Parser werd ich mir interessehalber ansehen. In Delphi gibt es eine TParser Klasse in der Unit Classes.

Zitat von generic:

Delphi Compiler Generator
http://www.soft-gems.net/index.php?option=com_content&task=view&id= 25&Itemid=33

Delphi Compiler Generator?

Noch besser! Danke!



Denn damit müsste sich ja ein geeigneter Parser für meine Zwecke bauen lassen. Wenn der einen Compiler erzeugen kann, sollte der auch einen passenden Parser erzeugen können.

Werde mir das alles jetzt erst mal ansehen.

Wenn Fragen auftauchen, melde ich mich wieder.

[jaenicke]

Ich selbst habe schon mit Castalia gearbeitet, das ist ein sehr einfach aufgebauter Parser, den man daher leicht um Features erweitern kann. Vor allem ist da sehr interessant, dass man alles was man nicht braucht auch einfach ignorieren kann an Elementen.
Die Dateien des Projekts sind hier zu finden:
http://code.google.com/p/castaliadel...wse/#svn/trunk

[Stevie]

Zitat von DualCoreCpu:

Es gibt auch eine Parserklasse in der Delphi VCL, die möglicherweise für die Sprache ObjectPascal erst mal verwendbar wäre. Wo gibt es da Dokus zu dieser Klasse, am besten mit Anwendungsbeispielen?

TParser Delphi

[Uwe Raabe]

Der TParser aus Classes.pas wird intern verwendet um aus der Textdarstellung einer DFM eine Binärdarstellung zu machen. Er ist meines Wissens für keine andere Aufgabe gedacht oder verwendbar.

[DualCoreCpu]

Hallo,

Danke zuerst an alle für Eure zahlreiche Antworten. Hab mir auch Castalia runtergeladen. Guck ich mir später an. Hab mir erst mal die verfügbaren Dokus zu Lex und yacc, die mit dem Delphi Compiler Generator mitgeliefert wurden angesehen und brauchte eigentlich mal ein Beispiel.

Für ne Codevervollständigung kömnnte ich ja folgendes schreiben:

%token class const begin constructor destructor end function out override procedure
%token type uses var virtual

Aber wie geht es jetzt weiter?

Wenn der Token "type" gefunden wird muss ja mindestens zwischen Klasse und record unterschieden werden. Wenn später eine Variable vom angegebenen Typ gefunden wird, brauche ich für die Codevervollständigung die Members dieses Typs, beim Record die Felder und bei der Klasse auch die Methoden und Eigenschaften. Nur wie sage ich das dem Lex Programm?

Ich weiß faktisch nicht, was gehört zum Programm, das letzlich entstehen soll und was gehört zum Eingabecode für Lex bzw. yacc?

Beispiel:

%left '+' '-'
%left '*' '/'
%token NUM
%%
expr : expr '+' expr
| expr '-' expr
| expr '*' expr
| expr '/' expr
| '(' expr ')'
| NUM
;

%{
type YYSType = Real;
%}

x : y { action; } z

Ist "{ action; } z jetzt eine Operation zwischen y und z, aus der sich x ergibt?

Wo finde ich da eine verständliche Einführung. Die mit dem Delphi Compiler Generator mitgeleieferte ist mir zu knapp.

Wenn ich mir selber eine Grammatik unabhängig von Lex und yacc schreiben will, könnte das wahrscheinlich so aussehen:


<token> <typbezeichner> '=' <eingebauter_typ>
<token>:= "TYPE"
<typbezeichner>:=['A'..'Z', 'a'..'z']
<eingebauter_typ>:="CLASS","RECORD"...

Nun müsste ich mir ein Pascalprogramm schreiben, das weiß, was <token>, <typbezeichner> ... usw bedeuten, um damit die Grammatik beschreiben zu können.

Aber noch immer hoffe ich auf eine verstänliche einsteigerfreundliche Dokumentation von lex und yacc, womit ich das gleiche erreiche und das womöglich schneller, als mit einem eigenen Lexer.

Wo als finde ich eine verständliche einsteigerfreundliche Dokumentation von Lex und Yacc?

[HERMES]

Eine sehr gute Einführung in flex und bison (Nachfolger von lex und yacc) ist das Buch "flex und bison" von Levine, O´Reilly Verlag 2009. Es gibt auch Delphivarianten von flex und bison, einfachmal mal nach "dyacc" googlen.

In der Delphi Hilfe, zumindest bei den älteren Versionen, ist eine EBNF Grammatik enthalten. Diese umfasst (Delphi 7) etwa 5 Seiten. Versprich dir aber nicht zuviel davon um daraus eine brauchbare LALR Grammatik (für bison notwendig) zu machen ist noch sehr viel Arbeit nötig. Eine brauchbare Grammatik, auch für so schöne Sprachen wie Delphi, wird mehr als 100 Seiten umfassen.

Der flex Lexer könnte mit etwa 20 Seiten zu machen sein.

Ich habe vor einiger Zeit eine bison Grammatik für eine SPS Sprache geschrieben, die weit weniger komplex ist als Delphi. Diese Grammatik hat mit relativ vielen Kommentaren 140 Seiten. Der flex Lexer 40.

Wenn du eine Codevervollständigung implementieren möchtest würde es aber ausreichen den Interfaceteil der units zu parsen und Typinformationen zu speichern.