Nächste Seite: Re: Pattern Matching Aufwärts: Graphen, Schaltwerke und Zahlen Vorherige Seite: Re: Pattern Matching
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define X 1024
#define END -1
#define CONTROLSTATE '#'
char statechar [X];
int state1 [X];
int state2 [X];
int x;
int initstates () {
int l;
for (l = 0; l < X; l++) {
statechar [l] = ' ';
}
}
int jx = 0;
char expr [] = "[[[[,],],[,]],[,]]";
//char expr [] = "abcd";
int i = 0;
char gettoken () {
return expr [i++];
}
void tokenback () {
i--;
}
int stream ();
int followed ();
int compound ();
int or_operator (int);
int repeat_operator ();
void print_padding (int);
int x = 0;
/*
Wenn es keine atomare Einheit ist
hat es
1.) einen Anfang
2.) eine Mitte
3.) ein Ende
Eine atomare Einheit hat
1.) einen Anfang = eine Mitte = ein Ende
- Die Mitte des "ausseren ist das ende des ersten inneren
und der Anfang des zweiten inneren
- die Mitte des inneren zeigt auf das Ende des inneren
- die Mitte des "ausseren zeigt auf das Ende des "ausseren
- Es gibt die Einteilung
1.) Anfang
2.) Mitte
3.) Ende
1.) Es gibt die erste H"alfte
2.) Es gibt die zweite H"alfte
1.) Das ende der ersten H"alfte zeigt auf das Ende des Ganzen
2.) Das ende der zweiten H"alfte zeigt auf das Ende des Ganzen
- Die Frage ist - was ist unsere Einheit ...
... wir sagen Atomare Einheit
- Die Einheit ist der Zustand
- Regel: Wir bilden
- F"ur
1.) Anfang
2.) Mitte
3.) Ende
einen einzelnen Zustand
Atomare Einheiten bekommen einen Zustand
Die Atomare Einheit stellt die Mitte des "ausseren dar
Anfang: a: (Anfang)
Mitte: m (Mitte)
Ende: e (Ende)
Atomare Einheit: d
So jetzt m"ussen wir anfangen ein Tupel zu bilden
Es ist nicht einfach Anfang und Ende. Sondern jedes Tupel hat bestimmte Daten.
Der Anfang kombiniert sich mit dem n"achsten. Zum Beispiel
Die Mitte kombiniert sich mit dem Ende
(d,e) Atomare Einheit -> Ende
Generelle Regel, wir geben immer das Ende zur"uck
Eine Atomare Einheit, kann ein Zeichen sein. Dann ist das der Zustand
Eine Atomare Einheit kann eine Zeichenkette sein, dann ist das Ende der Atomaren Einheit, das Ende der Zeichenkette.
Dieses Ende - Regel, geben wir immer zur"uck
Atomare Einheit
(d,e)
(a, n"achstes Zeichen) Der Anfang liesse sich in mehrere Anfange zusammensetzen
Hier beginnt der Fehler im Denken, wir sehen einen Anfang, an einer Stelle, wo in kurzen Intervall viele Dinge anfangen, die jeweils einen Anfang haben
(e,e)
Es gibt
(e,e)
(e,m)
a1, a2, a3, a4
(a1, a2) (an, an+1), (an, d)
(d1, d2)
*/
void print_padding (int l) {
while (l > 0) {printf (" "); l--;}
}
int or_operator (int l) {
int x1;
int x2;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a: %in", x); // Der Zustand f"ur den Anfang
x++;
x1 = or_operator (l+1);
print_padding (l);
printf ("m: %in", x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator (l+1);
print_padding (l);
printf ("e: %in", x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d: %in", x++);
tokenback ();
return x;
}
}
int or_operator2 (int l) {
int x1;
int x2;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a: %in", x); // Der Zustand f"ur den Anfang
x++;
x1 = or_operator2 (l+1);
print_padding (l);
printf ("m: %in", x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator2 (l+1);
print_padding (l);
printf ("e: %in", x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d: %in", x++);
tokenback ();
return x;
}
}
/* Jetzt stehen wir vor dem Problem, dass es d1 und d2 gibt. Aber wir k"onnen die Atomaren einheiten nicht unterscheiden
Das ist das Problem vom B"aumen, wir haben links und rechts, indem Falle, True und False
*/
#define TRUE 1
#define FALSE 0
#define LEFT FALSE
#define RIGHT TRUE
int or_operator3 (int successor, int l) {
int x1;
int x2;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a[%i]: %in", l, x); // Der Zustand f"ur den Anfang
x++;
x1 = or_operator3 (LEFT, l+1);
print_padding (l);
printf ("m[%i]: %in", l, x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator3 (RIGHT, l+1);
print_padding (l);
printf ("e[%i]: %in", l, x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d[%i:%i]: %in", successor, l, x++);
tokenback ();
return x;
}
}
/*
d[links:l+1] -> e [l]
d[rechts:l+1]-> e [l]
Es gibt quasi nur ein Tupel, von der ganz groben Ansicht
(d,e)
Die mitte ist irgendetwas - f"ur die Mitte gibt es keine Bedeutung.
Ausser, dass Mitte des "Aussere, Endes Inneren zusammenh"angne
a: -> d [links]
a: -> d [rechts]
e: -> (ende des n"achsten)
e: -> die mitte des n"achsten
Wenn a bis e innen in a bis e aussen, d1 liegt, dann zeigt e auf m
Wenn a bis a innen in a bis e aussen, d2 liegt, dann zeigt e auf e
Jetzt hat zu guter letzt die Atomare Einheit, einen Anfang und ein Ende
Wenn die Atomare Einheit verschmilzt, dann gewinnt das Ende. Weil das Ende der Atomaren Einheit
zeigt auf des "Ubergeordneten. Der Anfang wird zum Ende
*/
struct fraktur {
int anfang1;
int anfang2;
int mitte1;
int mitte2;
int ende1;
int ende2;
int dlinksanfang1;
int dlinksende1;
int dlinksanfang2;
int dlinksende2;
int drechtsanfang1;
int drechtsende1;
int drechtsanfang2;
int drechtsende2;
};
struct fraktur or_operator4 (int successor, int l) {
struct fraktur x1;
struct fraktur x2;
struct fraktur y;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a[%i]: %in", l, x); // Der Zustand f"ur den Anfang
//y.anfang1 und y.anfang2
y.anfang1 = x;
y.anfang2 = x;
x++;
x1 = or_operator4 (LEFT, l+1);
y.dlinksanfang1 = x1.anfang1;
y.dlinksanfang2 = x1.anfang2;
y.dlinksende1 = x1.ende1;
y.dlinksende2 = x1.ende2;
print_padding (l);
printf ("m[%i]: %in", l, x);
y.mitte1 = x;
y.mitte2 = x;
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator4 (RIGHT, l+1);
y.drechtsanfang1 = x2.anfang1;
y.drechtsanfang2 = x2.anfang2;
y.drechtsende1 = x2.ende1;
y.drechtsende2 = x2.ende2;
print_padding (l);
printf ("e[%i]: %in", l, x);
y.ende1 = x;
y.ende2 = x;
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
return y;
}
else {
struct fraktur r;
print_padding (l);
printf ("d[%i:%i]: %in", successor, l, x);
r.anfang1 = x;
r.anfang2 = x;
r.mitte1 = x;
r.mitte2 = x;
r.ende1 = x;
r.ende2 = x;
r.dlinksanfang1;
r.dlinksende1;
r.dlinksanfang2;
r.dlinksende2;
r.drechtsanfang1;
r.drechtsende1;
r.drechtsanfang2;
r.drechtsende2;
x++;
tokenback ();
return r;
}
}
/*
So, jetzt ist das entscheidende: Die Atomare Einheit, hat an sich keine Mitte
Das wichtige ist: (1.) nat"urlich unterscheiden zwischen Zust"anden und diesen Strukturen. Das ist klar, dass am Ende Zust"ande kommen. Das schwierige bei den Zust"anden bei Entscheidungen, aber auch bei anderen, zu entscheiden, welcher Zustand, wo auch welchen zeigt. Das geht nicht ohne Strukturen und es geht nicht ohne Anfang, Ende, Mitte.
Die Frage, was tun wir mit dieser Struktur. diese struktur wird nicht "ubergeben. Das ist der falsche Zusammenhang. Das erste, dem wir nie beachtung geschenkt, ist die Atomare Einheit. Dabei ist sie am Ende extremst entscheidend. Das wichtige ist, schon von dieser Sicht her, wird die Struktur nicht "ubergeben. Denn die Atomare Einheit selber, liefert nach aussen, gewisse Daten, aber sie selber behandelt nicht mehr. Es mehr entscheidend, wie man mit der Atomaren Einheit umgeht. Doch die Atomare Einheit, liefert die Atomare Einheit. Anhand dessen wir entscheidend. Diese Struktur ist ein R"uckgabe wert - kein "Ubergabe wert. die frage ist: Was ist bei der atomaren Einheit die Mitte. Die Antwort ist: Wir k"onnen gar nicht entscheiden, ist das darunter eine Atomare Einheit oder etwas anderes
Die Antwort ist die: Bei der atomaren Einheit, gibt es ein Anfang und ein Ende. Aber das Ende gewinnt. Wenn eine Atomare Einheit nur aus einem Einzigen Punkt von der L"ange besteht, dann muss das Ende auf etwas zeigen, was besonders ist. Die Frage ist: Wo ist die Mitte, da das Ende gewinnt, zeigt die Mitte der Atomaren Einheit auf das Ende.
*/
/*
int automat (int x, int xtext) {
int flag = 0;
if (strlen (text) <= xtext)
return 1;
if (statechar [x] == CONTROLSTATE) {
if (state1 [x] == state2 [x])
flag = automat (state1 [x], xtext);
else
flag = automat (state1 [x], xtext) || automat (state2 [x], xtext);
}
else if ((statechar [x] >= 'a') \&\& (statechar [x] <= 'z')) {
if (statechar [x] == text [xtext])
flag = 1;
if (state1 [x] == state2 [x])
flag \&= automat (state1 [x], xtext+1);
else
flag \&= (automat (state1 [x], xtext+1) || automat (state2 [x], xtext+1));
}
return flag;
}*/
int main (void) {
or_operator (0);
printf ("successn");
x = 0;
i = 0;
or_operator2 (0);
printf ("successn");
x = 0;
i = 0;
or_operator3 (LEFT, 0);
printf ("successn");
}