C#: Parser für Funktionsdefinitionen

[Martin (Gast)]

Hallo!

Wie parst man am einfachsten eine Funktionsdefinition?
Bsp.:
Eingabe:

static int Test(/*bla*/int i, double e,char* x)

Ergebnis:

Funktion: Test
Return: int
Parameter: * i vom Type int
           * e vom Type double
           * x vom type char*

Bin um jeden Tipp und weiterführenden Link dankbar.

Grüße
Martin

[Peter (Gast)]

sag doch lieber erstmal etwas genauer was du vor hast. Geht es mit C 
quellen die mit c# geparst werden sollen oder geht es im C# Quellen? 
Wenn es um C# geht kann man es über refection ohne parsen erledigen.

[Martin (Gast)]

Im Moment geht es um C-Funktionen, die unter C# geparst werden sollen. 
Will ein Hilfstool programmieren, das bei der Erstellung von 
Funktionsbeschreibungen assistiert.

[Martin (Gast)]

Hat keiner eine Idee?

[Jack (Gast)]

Quellcodedatei einlesen und mittels regulärer Ausdrücke Zeile für Zeile 
lesen und auswerten. NET bietet eine ziemlich gute REGEX-Engine (an Perl 
angelehnt).

[Martin (Gast)]

Ich hab's befürchtet. Regex hatte ich auch schon im Sinn, nur habe ich 
das noch nie verstanden und meine bisherigen Versuche Regex-Ausdrücke 
selbst zu erstellen ist bisher immer kläglich gescheitert...

[Jack (Gast)]

Ist eigentlich gar nicht so schwer. Ich habe mir damals folgendes Buch 
zugelegt:

Reguläre Ausdrücke, 3. Auflage, Jeffrey E.F. Friedl

http://www.oreilly.de/catalog/regex3ger/

Es behandelt die Grundlagen und die Engines verschiedener Sprachen 
(Perl,Python,NET usw.)

[Peter (Gast)]

naja das ganze per RegEx zu machen halten ich nicht für sinnvoll.

denn es gibt ja auch solche definitionen

static int Test(/*bla*/int i, double e, int (*pFunc)(int, double),char* 
x = 5)

[Jack (Gast)]

Peter schrieb:
> denn es gibt ja auch solche definitionen
>
> static int Test(/*bla*/int i, double e, int (*pFunc)(int, double),char*
> x = 5)

Ja, und?

[Peter (Gast)]

Jack schrieb:
> Ja, und?

für solche sachen finde ich regex nicht schön. Ich glaube auch nicht das 
der compiler regex verwendet und das wird sein grund haben.

[Jack (Gast)]

Welche Alternative schlägst du vor?

[Arc N. (arc)]

Wenn es denn endlich mal einen passenden CodeDomProvider gäbe, wäre es 
einfach.
Ansonsten würde ich mir z.B. mal 
http://www.devincook.com/goldparser/download.htm ansehen

[Yalu X. (yalu) (Moderator)]

Mit regulären Ausdrücken können, wie der Name schon andeutet, nur
reguläre Sprachen geparst werden. C ist aber nicht regulär, sondern
kontextsensitiv. Manche Regex-Bibliotheken haben zwar kontextsensitive
Erweiterungen, aber auch damit dürfte es schwierig bis unmöglich sein,
bspw. beliebig verschachtelte Klammerausdrücke zu parsen, die in C-Typen
und damit in Funktionsköpfen durchaus vorkommen können.

Es gibt mehrere Möglichkeiten, einen Parser für eine kontextfreie
Grammatik zu realisieren:

- Man kann ihn selber schreiben, bspw. mit der Methode des rekursiven
  Abstiegs. Hier ist die Vorgehensweise kurz beschrieben:

    http://en.wikipedia.org/wiki/Recursive_descent_parser

  Solch einen Parser für eine einfache Grammatik (wie diejenige für die
  C-Funktionsköpfe) zu schreiben, ist nicht nicht allzu schwer, man
  lernt viel dabei und kommt hinterher auch besser mit mit den beiden
  folgen- den Alternativen zurecht.

- Man benutzt einen Parsergenerator, der aus einer Grammatikbeschreibung
  den Programmcode für den Parser automatisch erzeugt. Hier ist eine
  Liste solcher Generatoren, teilweise auch mit C# also Ausgabesprache:

    http://en.wikipedia.org/wiki/Comparison_of_parser_generators#Deterministic_Context-free_Languages

- Man benutzt eine Parserbibliothek. Sehr hipp sind gerade so genannte
  Parser-Combinators. Dabei enthält die Bibliothek ein paar einfache
  Elementarparser und stellt Operatoren zur Verfügungen, mit denen diese
  zur komplexeren Parsern kombiniert werden können:

    http://en.wikipedia.org/wiki/Parser_combinator

  Die Parser werden damit direkt in der Zielsprache (in deinem Fall C#)
  geschrieben, sind aber wesentlich kürzer, übersichtlicher und leichter
  erweiterbar als handgeschriebene Recursive-Descendent-Parser (s.o.).
  Am eindruckvollsten ist dieses Prinzip in der Parsec-Bibliothek für
  Haskell implementiert. Einen F#-Klon davon, der ja dank .NET leicht in
  C#-Programmen einsetzbar sein sollte, gibt es hier:

    http://www.quanttec.com/fparsec/

  Aber auch in C# gibt es einige interessante Ansätze:

    http://blogs.msdn.com/b/lukeh/archive/2007/08/19/monadic-parser-combinators-using-c-3-0.aspx
    http://code.google.com/p/sprache/
    http://microparser.codeplex.com/
    http://archive.msdn.microsoft.com/RxParsers

  Google findet noch mehr davon.