Nächste Seite: Re: Pattern Matching Aufwärts: Graphen, Schaltwerke und Zahlen Vorherige Seite: Re: Pattern Matching
So sehe ich das
#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;
};
int or_operator4 (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_operator4 (LEFT, l+1);
print_padding (l);
printf ("m[%i]: %in", l, x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator4 (RIGHT, l+1);
print_padding (l);
printf ("e[%i]: %in", l, x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
int anfang = x;
int ende = x;
print_padding (l);
printf ("d[%i:%i]: %in", successor, l, x);
x++;
tokenback ();
return 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");
}