Delphi-PRAXiS - GenPar - Ein [ziemlich] generischer Parser

Seite 1 von 2

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Software-Projekte der Mitglieder (https://www.delphipraxis.net/26-software-projekte-der-mitglieder/)

- - GenPar - Ein [ziemlich] generischer Parser (https://www.delphipraxis.net/66351-genpar-ein-%5Bziemlich%5D-generischer-parser.html)

GenPar - Ein [ziemlich] generischer Parser

(Für alle ohne Framework (und natürlich auch alle anderen) gibt es

hier eine Testseite)
GenPar

Assembly: GenPar.dll
Root-Namespace: Kha.GenPar
.NET-Version: 2.0.50727
Größe: 40,0 KB
Signed

Code:

cos(e * 12) / (2 * (e * 6,28 + 1))

Ein mathematischer Ausdruck, wie wir ihn lieben (oder auch nicht) und wie er von tausenden Parsern auf der ganzen Welt zerlegt werden kann. Ergo: Langweilig :zwinker:

Code:

			(!Hugo xor pi > e ? cos(e * 12) / (2 * (e * 6,28 + 1)) : log(a; 3)) ^ 3 * 21 / 32
		

(Default-Expression der Testseite)
Hui, langsam wird es schon etwas außer- und ungewöhnlicher. Aber generisch ist daran noch nichts, das wird es erst beispielsweise mit so etwas:

Code:

			using System;

using System.Collections.Generic;

using System.Text;

using Kha.GenPar; // enthält allgemeine Typen wie Variablen oder Basisklassen

using Kha.GenPar.Infix; // enthält den Infixparser und Zugehöriges

using System.Reflection; 

namespace ConsoleApplication1

{

   class Program

   {

      interface IGreatForum { } // Ein Forum ist einfach toll, das braucht keine Methoden ;)

      class DP : Object, IGreatForum { } // s.o ^^

      // Fangen wir gleich mal mit dem Ergebnis an, sonst wird es langweilig ;)

      static void Main(string[] args)

      {

         InfixParser parser = new InfixParser();

         // sucht in der angegebenen Klasse nach Parsertypen

         // (= Methoden mit Ableitungen von ParserAttribute)

         parser.RegisteredTypes.IncludeTypes(typeof(Program));

         // und noch eine Variable

         parser.RegisteredTypes.Variables.Add(new Variable(typeof(IGreatForum), "great"));

         parser.Parse("DP is great");

         Console.WriteLine(parser.Root.Evaluate());

         Console.ReadLine();

      }

      // Das Ergebnis versteht sich wohl von selbst :P

      // Und nun die Interna:

      // enthält alle in der Assembly definierten Typen

      static List<Type> classList = new List<Type>(Assembly.GetCallingAssembly().GetTypes());

      // Definieren wir mal schnell ein Literal...

      // God bless attributes

      //

      // Parst einen Typenbezeichner im String und gibt ein Type-Objekt zurück

      [SimpleLiteral()]

      public static Type ToType(string s, out int length, out bool succeeded)

      {

         foreach (Type t in classList)

            if (s.StartsWith(t.Name)) {

               length = t.Name.Length;

               succeeded = true;

               return t;

            }

         length = 42; // total egal, da succeeded eh false ist

         succeeded = false;

         return null;

      }

      // Und noch einen Operator

      // Meine Einstellung zu Attributen habe ich ja schon kundgegeben

      // 110 = Operatorvorrang (bei einem einzigen Operator ziemlich egal

      // \a = Argument

      [InfixOperator(110, @"\a is \a")]

      public static bool Is(Type t1, Type t2)

      {

         return t2.IsAssignableFrom(t1);

      }

   }

}

Hmm. Wir haben sozusagen einen komplett neuen Parser geschrieben, und das mit genau 64 Zeilen, von denen die meisten aus Kommentaren bestehen. Nicht schlecht, würde ich mit wenigstens einem kleinem Bisschen Eigenlob sagen :angel2: .

Zum Sourcecode: Da ich eigentlich nur OS-Projekte schreibe und die Assembly sowieso unter der GPL steht, ich gleichzeitig aber die erste verwendbare Version sofort ins Netz stellen wollte, ist der Sourcecode an manchen Stellen noch etwas - nun ja - "inoptimal" ;) . Zur Lektüre würde ich also lieber auf eine der nächsten Versionen warten, morgen werde ich mal FxCop drüberlaufen lassen. Wie gesagt, er läuft, aber in den nächsten Versionen wird das Ganze noch einmal um Einiges generischer werden (-> Plugins). Es sei mir verziehen, wenn man Stellen durch C# oder das Framework eigentlich viel eleganter hätte schreiben können, ich sharpe (^^) (leider) erst seit einem halben Jahr. Achja, irgendwelche Form von Doku lässt auch noch bis zur nächsten Version auf sich warten ;) .

TODO (nicht vollständig, einfach alles, was mir im Moment einfällt):

- Vektoren
- Komplexe Zahlen
- Ein UPN-Parser
- Ein Operator-Browser
- generische Variablen/Konstanten
- Ein Precompiler (konstante Teile des Ausdrucks)
- Optimierungen
- IL-Compiler (Reflection = schnarch)

(Wahrscheinlich wieder die Hälfte vergessen -.-)

GenPar.zip