Plankalkl-Compiler V0.0.1 Copyright (c) 2000 Bernd-Gunter Nitzler

				EMail: bernd@nitzler.de
				www:   http://www.nitzler.de

Achtung!!!
Dies ist ein Pre-Pre-Alpha-Release. Es ist bei weitem nicht alles
implementiert was in der Sprache Plankalkl moglich ist. Auch in den Teilen
die bereits implementiert sind gibt es noch Lcken und garantiert auch
Fehler. Die beigefgten Include-Dateien, die fr die bersetzung und den
Ablauf des generierten C++ Programms notwendig sind, sind weder vollstndig
noch komplett getestet. bersetzte Programme, wie die im Unterverzeichnis
"tests" wurden nur auf syntaktische und logische C++ Korrektheit geprft,
sie wurden nie zu einem ausfhrbaren Programm gelinkt und ablaufen gelassen.
Ist im Plankal-Quellprogramm ein Fehler dann gibt es keine ausfhrliche
Fehlermeldung sondern nur einen "parse error" und dies teilweise nicht
einmal mit einer Angabe an welcher Stelle dieser Fehler aufgetreten ist.

Es fehlt in jeder Beziehung an Dokumentation. In dieser Readme gebe ich nur
Hinweise wie man ein Plankalkl-Programm aus der von Konrad Zuse
beschriebenen Mehrzeilen-Syntax fr diesen Plankalkl-Compiler umsetzen kann
und ein paar weitere kurze Erluterungen zur Syntax.


Wie bei meinen Programmen blich sind die Sourcen beigefgt. Ich bitte aber
darum keine vernderten Versionen weiter zu verbreiten weil ich derzeit
intensiv am Compiler arbeite und deshalb in kurzen Abstnden erweiterte
Versionen zur Verfgung stehen werden die sich von dieser Version erheblich
unterscheiden knnen. Ich mchte im Moment auch niemanden zu einer
Erweiterung auf eigene Faust raten denn ich htte kaum Zeit nderungen
die gleichzeitig von verschiedenen Seiten kommen mit meinen Erweiterungen
zusammen unter einen Hut zu bringen. Ich bin aber natrlich gerne bereit
Verbesserungsvorschlge anzunehmen.

Derzeit luft dieser Compiler unter Linux 6.x und ist mit dem GNU
g++ (egcs-2.91.66) und GNU bison 1.28 compilerbar. Da ich keine besonders
groen Betriebssystemabhngigkeiten und derzeit auch noch keine
auergewhnlichen C++-Libraries benutze sollte er auch mit anderen
Compilern oder auf anderen Betriebssystemen lauffhig sein. Die grte
Betriebssystemabhngigkeit ist im Modul plank.cc das Starten des
C++-Compilers nach der erfolgreichen Plankalkl-bersetzung. Ferner
sollte der benutzte C++-Compiler den Typ "long long" kennen. Wenn
jemand Interesse hat den Plankalkl-Compiler auf anderen Systemen
zum Laufen zu bringen bin ich gerne bereit die notwendigen Anpassungen mit
einzubauen.

Auf meiner Homepage (http://www.nitzler.de) gibt es einen Artikel der
"Communications of the ACM", in dem die Sprache Plankalkl kurz umrissen ist.
Eine ausfhrlichere Beschreibung, die auch die Grundlage dieses Compilers
ist, ist in dem GMD-Bericht Nr. 63 "Der Plankalkl", Konrad Zuse von 1972
zu finden. Leider kann man dieses Dokument nicht mehr kaufen, es gibt aber
noch ein paar wenige Uni-Bibliotheken bei denen man es ausleihen kann.

Die beigefgten Compiler Sourcen sind noch nicht ganz auf C++ umgestellt,
sie nutzen also bisher nur einen Teil der Mglichkeiten von C++. Es sollte
auch nicht wundern das ich im Compiler stndig Speicher fr die
verschiedensten Strukturen alloziere aber keinerlei Gedanken an eine Freigabe
derselben verschwende. Bei den heutigen Speichergren ist diese
Verschwendung absolut minimal, der Aufwand fr eine entsprechende Verwaltung
zu diesem frhen Zeitpunkt aber erheblich und fehleranfllig.

Die vom Compiler erzeugten C++ Sourcen benutzen derzeit noch weniger
C++ Techniken. Leider sind die Templates in C++ nicht so weitgehend variabel
wie es fr Plankalkl notwendig ist, deshalb kann der Plankalkl-Compiler
die C++ Templates nur in wenigen Fllen benutzen und mu berwiegend
Funktionen mehrfach generieren.

Die Mehrzeilensyntax des ursprnglichen Plankalkls habe ich, fr eine
einfachere Verarbeitung durch den Compiler, durch eine heutzutage eingngigere
Syntax ersetzt. Im Bericht "Der Plankalkl" wird hufig von einer sogenannten
Impliziten Form und einer Expliziten Form geschrieben. In den meisten
Fllen versteht dieser Compiler auch die implizite Form.

Hier ein paar Beispiele fr die Umsetzung:

Ursprngliche Schreibweise:	wird ersetzt durch:

 |Z   ^ Z			Z4.2.3 ^ Z2
V|4     2
K|2.3				Die Strukturangabe entfllt da bereits bei
S|0     0			der Definition der Variablen Z4 und Z2 gesetzt

 |R(V , V) => (R , R)		R(V0=S1.n,V1=S1.n)=>(R0=S1.n,R1=S0)
V|  0   1      0   1
S|  1.n 1.n    1.n 0

 |(R()) (V,V) => R		(R(Rx))(V0=S0,V1=S0)=>R0=S0
V|        0 1     0		Anstelle der griechischen Symbole knnen
S|        0 0     0		beliebige Bezeichner verwendet werden

 |(R(,))(V,V,V,V)=>R		(R(Rx0,Rx1))(V0=Ax,V1=Ax,V2=Ax,V3=Ax)=>R0=Ax
V|   0 1   0 1 2 3  0		Anstelle der griechischen Symbole knnen
A|         @ @ @ @  @		berall beliebige Bezeichner verwendet werden

 |(V  V)  (V  V) => R	(V0 Rx0 V3) Rx1 (V1 Rx0 V2) =>R0
V| 0 0 3  1  1 0 2     0	Die Strukturangaben entfallen da bereits bei
S| @   @     @   @     @	der Definition der Variablen gesetzt

 |V +- Z			V0[Z1]
V|0 |  1
K|--+
A|1.n  9

 |(x)(x E V -> Rx(x))		x(V0,Rx(x))
V|        0			Dies ist der All-Operator (implizite Form)

 |(Ex)(x E V ^ Rx(x))		E x(V0,Rx(x))
V|        0			Dies ist der Exist-Operator (implizite Form)

 |x(x E V ^ Rx(x))		F x(V0,Rx(x))
V|       0			Dies ist der "Derjenige welcher"-Operator
				(implizite Form)

 |W(x(x E V -> Rx(x))=>Z) | P(Z)  X x(V0,Rx(x)) P(x)
V|         0            0      0   Dies ist der Next-Ausdruck (implizite Form)
S|         m*s          s	   das Zwischenergebnis Z0 ist in dieser Form
				   nicht notwendig

Die gesamte Syntax ist in der Datei "plankal.syn" beschrieben.

In dem Verzeichnis "tests" sind die im GMD-Bericht "Der Plankalkl" ab dem
Kapitel 2 aufgelisteten Rechenplne P1.*, P2.* und P3.* in der hier benutzten
Syntax enthalten. Teilweise fehlen allerdings noch Funktionen.

P148:R(V0=A5)=>R0=S0
	F x=A4(V0,(x.1='--+-'))=>Z0=A4
	E x(V0,R17(Z0.0,x.0)^(x.1=0) v x.1.3^!E y=A4(V0,y.1.3^R128(V0,y.0,x.0)))=>R0

P1:R(V0=m.s) => R0
	Az(V0) => ^ R0 ; V0[0] => Z0 ; 0 => e=S1.n
	W(V0){X x(x e V0 ^ x != V0[0]) => Z1 ; Sq(Z0,Z1) => ^ R0
		Kla(Z1) -> {e + 1 => e} ; Klz(Z1) -> {e - 1 => e}
		e >= 0 => ^ R0 ; Z1 => Z0}
	Sz(Z0) => ^ R0 ; e = 0 => ^ R0

Denkbar sind auch mehrere Parameter und Ergebnisse:
P17:	R(V0=s) => (R0=s,R1=0)

Programmaufruf mit z. B. R17(x).0 ergibt R0 nach dem Programmaufruf.
R17(x) ergibt (R0,R1) als Struktur.

Randauszug: Vereinbarung von Variablen und Programmen.

S0		ist ein Bit (Ja-Nein-Wert)
S1.n		ist ein Bitvektor mit n Bits
A1 = S1.3	3-Bit Wert
A2 = 2*A1	Vektor von A1 Werten
B3 = [0..12]	Beschrnkung auf die Werte 0 bis 12
A3 = S1.4#B3	Art 3 mit Typ S1.4 und Beschrnkung 3
A4 = (A2,A3)	ist eine Struktur
A5 = 64*A3	Vektor von 64 A3-Arten
A9 = (A5,S0,S1.4,A2)	Struktur verschiedener Arten
P148: R(V0=A5) => R0	Programm 148 mit einem Parameter und einem Ergebnis

Bezeichnungen: ein Buchstabe und eine Zahl:
A	fr Arten
B	fr Beschrnkungen
C	fr Konstanten
E	fr Existiert-Anweisung
F	First-Operator "Derjenige welcher"
I()	fr Index von (einem bestimmten Wert)
K	fr Komponenten
L	Lanmbda-Operator (Last)
N()	fr Anzahl der Komponenten
P	fr Planteile (Programme)
R	fr Resultatwert
S	fr Grundstrukturen:	S0 ist ein Bit,
				S1 eine Bitfolge,
				S2 ein Angabenpaar
				S3 eine Liste
				S4 eine Paarliste
V	fr Variable
Wn	fr Wiederholungsanweisung
	W0(n) { P }	  :	     1 BY  1 TO n   DO P
	W1(n) { P[i] }	  :	 i = 0 BY  1 TO n-1 DO P(i)
	W2(n) { P[i] }	  :    i = n-1 BY -1 TO 0   DO P(i)
	W3(n,m) { P[i] }  :	 i = n BY  1 TO m-1 DO P(i)
	W4(n,m) { P[i] }  :	 i = n BY -1 TO m+1 DO P(i)
	W5(n,m) { P[i] }  : IF n <= m
			    THEN i = n BY  1 TO m-1 DO P(i)
			    ELSE i = n BY -1 TO m+1 DO P(i)
	W6(n,m) { P[i] }  : siehe Seite 37, sehr speziell
X	-Operator (Next)
Z	fr Zwischenwert

Die Beschrnkung auf bestimmte Bezeichner ist aufgehoben, es knnen
beliebige Namen auer den Standardbezeichnern wie z. B. W2 oder E
verwendet werden.

Werte:
als Integer oder Bitfolge 'L000L' oder als Ja-Nein-Folge '+---+-+-' wobei hier
die Bitreihenfolge umgekehrt ist: 'L0LL' == '++-+'. Bei Ja-Nein-Folgen ist
auch das Zeichen 'o' oder '0' als unbestimmtes Zeichen zulssig.

Spezial- und Rechenzeichen:
=>	Zuweisung
=> ^	Zuweisung mit Und-Verknpfung, entspricht &= in C
	entsprechend auch mit den anderen Operatoren
->	Bedingte Anweisung
+	Addition
-	Subtraktion
*	Multiplikation oder Bitlngendefinition
/	Division
#	Beschrnkungsdefinition
v	bitweises Oder
^	bitweises Und
!>	Implikation
!~	bitweises ExOder
~	bitweises nicht ExOder
!	nicht
=	gleich und Artdefinition
!=	ungleich
<=	kleiner gleich
>=	grer gleich
<	kleiner
>	grer
.	Strukturelementauswahl
| |	Absolutbetrag
[ ]	Indexklammern
( )	normale Klammern
;	Trennung von Anweisungen

