Drafting UniCC v2

Posted on December 7, 2017 by bierpilot

Ich denke, das ist die beste Lösung.

Sogar UniCC v1.3 nimmt langsam immer mehr Gestalt an, sogar Features kommen hinzu. Alles Features, die zwar für UniCC 1.x nicht mehr tragend sind, aber deren Ergebnis in UniCC v2 mit wenig Anpassung direkt nutzbar sein werden.

Trotzdem, die letzten Tage waren Scheiße. Weil ich das alles mache um ein Projekt von der Arbeit hoffentlich nach vorne zu bringen, oder wenn ich Pech habe wird es komplett eingestampft.

UniCC ist eigentlich ein zu Code gewordenes Stück meines Lebens. Ursprünglich wollte ich nur ein Tool haben, um RapidBATCH 6 zu entwickeln. Dann wuchs es immer mehr aus. UniCC sollte dann den Parser Generator anagram nacheifern. Dann kamen immer mehr Ideen, Features, Pitfalls, krankes Zeug hinzu. Eigentlich alles quatsch, fand ich damals aber geil. UniCC ist meiner Meinung nach sogar besser als anagram geworden, wenn auch ohne IDE, dafür aber mit noch mehr Flexibilität. Diese Flexibilität bricht ihm auch letztendlich das Genick. Zu viele Features, zu viele Bugs. Lieber einfach, schlank und straightforward. Und eine halbe Konkurrenz zu ANTLR, als GLR multi-target language Paradigma? Das wäre toll. Man wird ja wohl noch träumen dürfen…

UniCC v2 sollte auf der Codebasis der pparse-Erweiterung der libphorward basieren und die Code-Generierung vom UniCC v1 beinhalten. Und einen direkten Interpreter für Parser beinhalten, um Grammatiken sofort zu testen. Das wäre ein finaler Parser Generator.

Hier geht’s zum UniCC v2 Wiki-Doodle…

A step Phorward.

Posted on September 6, 2016 by bierpilot

Manchmal ist es so, dass man Dinge mal einige Zeit zur Seite legt, bevor man damit wieder weitermacht. Letzte Woche war es bei mir wieder mal soweit, die etwas angestaubten Spielsachen der alten Zeit wieder rauszukramen… meine private Software ;). Da ist ja wirklich viel passiert die letzten, ja man kann sagen 10 Jahre, und dennoch gab es nicht wirklich was neues.

Und doch, es macht mir immernoch Spaß. Zumindest es in einer gewissen Weise auch zu einem Ende zu bringen oder sich vielleicht auch von manchen Dingen zu trennen, an denen man sehr lange festgehalten hat, wo man aber letztendlich keine weitere Zeit mehr reinstecken möchte oder auch sollte.

Jedenfalls hat meine Website phorward-software.com ein Update erfahren… es gibt jetzt dort einen aktualisierten Projekte-Bereich für die Projekte phorward, pynetree, JS/CC und UniCC.

Vor allem an phorward (libphorward, bzw. das Phorward Toolkit) habe ich immernoch Bock weiterzumachen, da es für mich die einzige Möglichkeit ist, weiterhin was in C zu coden und diese Library wirklich alle Themen abdeckt, die ich persönlich super interessant finde. Die libphorward ist ja quasi mein eigenes Steckenpferd einer libmega (Insider wissen, was gemeint ist!) die richtig geile C-Funktionen bereithält (plist, pstack, pstr), und noch dazu add-ons für reguläre Ausdrücke (pregex), Lexing (plex), Parsing (pparse) und sogar virtuelle Maschinen (pvm) bereitstellt. Ursprünglicher Zweck dahinter war es immernoch, einmal ein RapidBATCH damit neu zu entwickeln. Das steht aber weiterhin noch in den Sternen.
pynetree ist ja das im letzten Jahr gestartete Projekt einer Python-Parser-Bibliothek mit linksrekursiven Grammatiken, die durch einen Top-Down-Packrat-Parser geparst werden, und sich gemeinsam mit phorward eine eigene TBNF-Sprache teilt. Hier wird auf jeden Fall noch weitergemacht!
JS/CC, der JavaScript-Compiler-Compiler, den ich bereits 2007 veröffentlich habe, hat neue Freunde gefunden. Er wird von mir nicht mehr weiterentwickelt oder verfolgt, scheint aber durch die Programmierer Andrew Brobston und Sergiy Shatunov eine gelungende Anbindung an Node.JS gefunden zu haben und wird in einem ganz anderen Rahmen als ursprünglich gedacht weiterentwickelt. Finde ich aber gut, immerhin ein Open Source Projekt welches von Menschen gebraucht, genutzt und sogar Weiterentwickelt wird. JS/CC wird jetzt unter jscc.brobston.com, respektive bei GitHub unter https://github.com/abrobston/jscc weiterentwickelt.
UniCC, das eigentlich als “universeller Parser Generator” gedachte Vorzeigeprojekt von mir vor inzwischen auch schon wieder 4 Jahren wird jetzt mehr oder minder eingestampft. Es erfolgt jetzt noch einmal ein Update des Benutzerhandbuchs sowie eine komplette Neu-Lizenzierung der Software unter der BSD-Lizenz, dann wird sie freigelassen. Immerhin: Der UniCC compiliert nach wie vor mit der aktuellsten libphorward, die als Unterbau fungiert. Einziger mir bekannter Einsatz dieses Tools ist das Projekt impact bei MEGA, dessen gesamte Formelsprache in UniCC entwickelt worden ist, und immerhin sogar auf 8 verschiedenen Architekturen läuft.

Alles in allem Plane ich auch, die Webseite unter phorward.info nochmal neu aufzusetzen, warscheinlich als ViUR Projekt und auch mehr mit dem Open Source Hintergedanken. Sozusagen als “mein Software Blog”, ohne es weiterhin auf dieser kommerziellen Schiene, auf der Phorward Software ja ursprünglich aufbaute, zu fahren. Da ist nämlich nichts mehr.

pynetree

Aside

pyParse musste ich nochmal kurzerhand umbenennen, weil es ein Projekt Namens pyParse schon gibt… ist mir nicht aufgefallen, weil SCHEISS GOOGLE einem ja immer verbessern muss, und deshalb andere Begriffe gefunden hat.

Der neue Name des Projektes lautet jetzt pynetree. Zum einen weil Pinien sehr schöne Bäume sind und einen tollen AST abgeben, zum anderen der Pythonbezug – Passt!

https://bitbucket.org/codepilot/pynetree/overview

pyParse (bzw. jetzt pynetree)

Posted on November 15, 2015 by bierpilot

Es gibt wieder was neues aus der Welt des Compilerbaus von mir:

Nachdem ich mir mal letzte Woche das Paper Packrat Parsers Can Support Left Recursion [Warth, Douglass, Millstein] durchgelesen hatte und den dort gezeigten Algorithmus implementierte, fiel der Groschen: Linksrekursive Grammatiken lassen sich nun DOCH mit einem Nicht-LR-Parser parsen! Also das, wonach ich die ganze Zeit gesucht hatte… oft war ich nah dran, aber es hat dann doch nicht gereicht oder anderweitige Probleme aufgezeigt, die das “proof of concept” nicht werden lassen wollten. Die Lösung ist nun ein modifizierter Packrat-Parser! So ungefährt muss es auch mein lieber Martin Stoilov mit seinem rpatk gelöst haben.

Da ich mir erst nicht so ganz sicher war, ob mein Ansatz jetzt wirklich funktioniert, musste ich zuerst noch ein paar Tests durchführen bzw. es etwas voranbringen… die waren aber diesmal wirklich erfolgreich! Man kann damit arbeiten wie mit einer Grammatik für einen LR-Parser. Einzig und allein die Reihenfolge der Produktionen ist hier zu beachten, was bei einem LR-Parser (wie z.B. libphorward) nicht der Fall ist.

Habe das ganze mal in Python ausprogrammiert und inzwischen schon zu einem kleinen Open Source Projekt gemacht, welches auf den Namen ~~pyParse~~ pynetree hört, und unter der MIT-Lizenz steht.

https://bitbucket.org/codepilot/pynetree/src

#-*- coding: utf-8 -*-
from pyparse import Parser

g = {
	"factor": ["INT", "( expr )"],
	"mul": "term * factor",
	"div": "term / factor",
	"term": ["mul", "div", "factor"],
	"add": "expr + term",
	"sub": "expr - term",
	"expr": ["add", "sub", "term"],
	"calc": "expr"
}

p = Parser(g, "calc")
p.addToken("INT", r"\d+")

p.addAction("INT")
p.addAction("mul")
p.addAction("div")
p.addAction("add")
p.addAction("sub")
p.addAction("calc")

p.dump(p.parse("1 + 2 * ( 3 + 4 ) * 5 - 6 / 7"))

#-*- coding: utf-8 -*-

from pyparse import Parser

g = {

"factor": ["INT", "( expr )"],

"mul": "term * factor",

"div": "term / factor",

"term": ["mul", "div", "factor"],

"add": "expr + term",

"sub": "expr - term",

"expr": ["add", "sub", "term"],

"calc": "expr"

}

p = Parser(g, "calc")

p.addToken("INT", r"\d+")

p.addAction("INT")

p.addAction("mul")

p.addAction("div")

p.addAction("add")

p.addAction("sub")

p.addAction("calc")

p.dump(p.parse("1 + 2 * ( 3 + 4 ) * 5 - 6 / 7"))

und gibt

calc
  sub
    add
      INT (1)
      mul
        mul
          INT (2)
          add
            INT (3)
            INT (4)
        INT (5)
    div
      INT (6)
      INT (7)

calc

sub

add

INT (1)

mul

INT (2)

add

INT (3)

INT (4)

INT (5)

div

INT (6)

INT (7)

aus.

pyparse kann inzwischen sogar eine BNF-Grammatik ähnlich der libphorward interpretieren (selbstverständlich ist der Parser dafür in pyParse entwickelt!)

#-*- coding: utf-8 -*-
from pyparse import Parser

p = Parser("$INT /\\d+/ %emit;"
		   "f: INT | '(' e ')';"
		   "mul %emit: t '*' f;"
		   "div %emit: t '/' f;"
		   "t: mul | div | f;"
		   "add %emit: e '+' t;"
		   "sub %emit: e '-' t;"
		   "e %goal: add | sub | t;")

p.dump(p.parse("123+456*789"))

#-*- coding: utf-8 -*-

from pyparse import Parser

p = Parser("$INT /\\d+/ %emit;"

"f: INT | '(' e ')';"

"mul %emit: t '*' f;"

"div %emit: t '/' f;"

"t: mul | div | f;"

"add %emit: e '+' t;"

"sub %emit: e '-' t;"

"e %goal: add | sub | t;")

p.dump(p.parse("123+456*789"))

pyParse wird wohl dann als erstes mal in ViUR eingebaut… GEIL! 😀

Bierpiloten-Blog

Vom Fliegen, Coden und sonstigem Kram…

Category Archives: pynetree

Drafting UniCC v2

A step Phorward.

pynetree

Aside

pyParse (bzw. jetzt pynetree)