Nächste Seite: /media/sda-magnetic/david/Dokumente-15-2023-11-22/informatik/newC2023-10-23/myc/reg738.c Aufwärts: elektrotechnik 02/11/2026 Vorherige Seite: /media/sda-magnetic/david/Dokumente-15-2023-11-22/informatik/newC2023-10-23/myc/reg736.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define X 1024
#define END -1
#define CONTROLSTATE '#'
char v [X];
int state1 [X];
int state2 [X];
int x;
int initstates () {
int l;
for (l = 0; l < X; l++) {
v [l] = ' ';
}
}
int jx = 0;
char expr [] = "[[[[ag,bg],cg],[dg,eg]],[fg,gg]]";
//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 äusseren 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 äusseren zeigt auf das Ende des äusseren
- Es gibt die Einteilung
1.) Anfang
2.) Mitte
3.) Ende
1.) Es gibt die erste Hälfte
2.) Es gibt die zweite Hälfte
1.) Das ende der ersten Hälfte zeigt auf das Ende des Ganzen
2.) Das ende der zweiten Hälfte 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ür
1.) Anfang
2.) Mitte
3.) Ende
einen einzelnen Zustand
Atomare Einheiten bekommen einen Zustand
Die Atomare Einheit stellt die Mitte des äusseren dar
Anfang: a: (Anfang)
Mitte: m (Mitte)
Ende: e (Ende)
Atomare Einheit: d
So jetzt müssen 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ächsten. Zum Beispiel
Die Mitte kombiniert sich mit dem Ende
(d,e) Atomare Einheit -> Ende
Generelle Regel, wir geben immer das Ende zurück
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ück
Atomare Einheit
(d,e)
(a, nächstes 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: %i\n", x); // Der Zustand für den Anfang
x++;
x1 = or_operator (l+1);
print_padding (l);
printf ("m: %i\n", x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator (l+1);
print_padding (l);
printf ("e: %i\n", x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d: %i\n", x++);
tokenback ();
return x;
}
}
int or_operator2 (int l) {
int x1;
int x2;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a: %i\n", x); // Der Zustand für den Anfang
x++;
x1 = or_operator2 (l+1);
print_padding (l);
printf ("m: %i\n", x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator2 (l+1);
print_padding (l);
printf ("e: %i\n", x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d: %i\n", x++);
tokenback ();
return x;
}
}
/* Jetzt stehen wir vor dem Problem, dass es d1 und d2 gibt. Aber wir können die Atomaren einheiten nicht unterscheiden
Das ist das Problem vom Bäumen, 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]: %i\n", l, x); // Der Zustand für den Anfang
x++;
x1 = or_operator3 (LEFT, l+1);
print_padding (l);
printf ("m[%i]: %i\n", l, x);
x++;
if (gettoken () != ',') {
fprintf (stderr, "Komma vergessen");
exit (1);
}
x2 = or_operator3 (RIGHT, l+1);
print_padding (l);
printf ("e[%i]: %i\n", l, x);
x++;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
}
else {
print_padding (l);
printf ("d[%i:%i]: %i\n", 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ür die Mitte gibt es keine Bedeutung.
Ausser, dass Mitte des Äussere, Endes Inneren zusammenhängne
a: -> d [links]
a: -> d [rechts]
e: -> (ende des nächsten)
e: -> die mitte des nächsten
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 Übergeordneten. 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 atom () {
int ch;
ch = gettoken ();
printf ("%c\n", ch);
if ((ch >= 'a') && (ch <= 'z')) {
state1 [x] = x+1;
state2 [x] = x+1;
v [x] = ch;
x++;
return atom ();
}
else {
tokenback ();
return x;
}
}
struct fraktur or_operator4 (int successor, int l) {
struct fraktur x1;
struct fraktur x2;
struct fraktur y;
int ch;
if (gettoken (l+1) == '[') {
print_padding (l);
printf ("a[%i]: %i\n", l, x); // Der Zustand für 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]: %i\n", l, x);
y.mitte1 = x;
y.mitte2 = x;
//x++;
if ((ch = gettoken ()) != ',') {
fprintf (stderr, "Komma vergessen %c", ch);
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]: %i\n", l, x);
y.ende1 = x;
y.ende2 = x;
x++;
state1[x1.ende1] = y.ende1;
state2[x1.ende2] = y.ende2;
state1[x2.ende1] = y.ende1;
state2[x2.ende2] = y.ende2;
/* Ich brauche den Anfang nicht, der Atomaren Einheit
Weil: Der Anfang ist das gleiche wie das Ende - ist er das - dann ist er deselbe Zustand
Ist die atomare Einheit eine Kette, dann zeigt der erste Zustand auf den nächsten, bis zu Ende
aber damit habe ich nichts zu tun
Die Mitte der Atomaren Einheit interessiert nie. Überhaupt interessiert die Mitte so nicht
Das Ende der Atomaren Einheiten ist initialisert. Es gibt zwei inneren Bereiche. Und die haben
Ende und zwar 1 und 2. Das ist intialisiert
*/
state1 [y.anfang1] = x1.anfang1;
state2 [y.anfang2] = x2.anfang1;
if (gettoken () != ']') {
fprintf (stderr, "Klammer vergessen ]");
exit (1);
}
return y;
}
else {
struct fraktur r;
tokenback ();
print_padding (l);
printf ("d[%i:%i]: %i\n", successor, l, x);
r.anfang1 = x;
r.anfang2 = x;
r.mitte1 = x;
r.mitte2 = x;
r.ende1 = atom ();
r.ende2 = r.ende1;
r.dlinksanfang1;
r.dlinksende1;
r.dlinksanfang2;
r.dlinksende2;
r.drechtsanfang1;
r.drechtsende1;
r.drechtsanfang2;
r.drechtsende2;
x++;
return r;
}
}
/*
So, jetzt ist das entscheidende: Die Atomare Einheit, hat an sich keine Mitte
Das wichtige ist: (1.) natürlich unterscheiden zwischen Zuständen und diesen Strukturen. Das ist klar, dass am Ende Zustände kommen. Das schwierige bei den Zuständen 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 übergeben. 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 übergeben. 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ückgabe wert - kein Übergabe wert. die frage ist: Was ist bei der atomaren Einheit die Mitte. Die Antwort ist: Wir können 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änge 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 (v [x] == CONTROLSTATE) {
if (state1 [x] == state2 [x])
flag = automat (state1 [x], xtext);
else
flag = automat (state1 [x], xtext) || automat (state2 [x], xtext);
}
else if ((v [x] >= 'a') && (v [x] <= 'z')) {
if (v [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) {
int k;
x = 0;
i = 0;
or_operator4 (LEFT, 0);
printf ("success\n");
for (k = 0; k <= x; k++) {
if ((v[k] >= 'a') && (v[k] <= 'z'))
printf ("(%i, (%c, %i, %i))\n", k, v[k], state1 [k], state2 [k]);
else
printf ("(%i, (%i, %i))\n", k, state1 [k], state2 [k]);
}
}