/media/sda-magnetic/david/Dok-15-2023-11-27/informatik/pascal/postregs/reg23.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FLAGS_REPEATET 0

struct parsing_begin_end_state {
    int current;
    int begin;
    int end;
    int flags [16];
};

struct parsing_begin_end_state parsing_begin_end_state_init () {
    struct parsing_begin_end_state x;
    int k;
    x.current = -1;
    x.begin = -1;
    x.end = -1;
    for (k = 0;  k < 16;  k++)
        x.flags [k] = 0;
return x;
}

//char expr [] = "(a(((+bc(d))l+ll)de(faaa)))zzz";
#define MAX_STATES  1024
#define END           -1
char expr [] = "abc*de[fasd,asddsr]qdsda*ghijk";
int i = 0;
int j;
int state1 [MAX_STATES];
int state2 [MAX_STATES];
char statechar [MAX_STATES];

char gettoken () {
    return expr [i++];
}
void tokenback () {
    i--;
}

/*
aaaa
aaaaaa
aaaaaaa
aaaaaaaa()
*/

struct parsing_begin_end_state stream (struct parsing_begin_end_state);
struct parsing_begin_end_state followed (struct parsing_begin_end_state);
struct parsing_begin_end_state compound (struct parsing_begin_end_state);
struct parsing_begin_end_state or_operator (struct parsing_begin_end_state);
struct parsing_begin_end_state repeat_operator (struct parsing_begin_end_state);

struct parsing_begin_end_state or_operator (struct parsing_begin_end_state be_arg) {
    struct parsing_begin_end_state j1, j2, j3, j4;
    int t;
    struct parsing_begin_end_state be;
    be = parsing_begin_end_state_init ();
    j1 = parsing_begin_end_state_init ();
    j2 = parsing_begin_end_state_init ();
    j3 = parsing_begin_end_state_init ();
    j4 = parsing_begin_end_state_init ();

    struct parsing_begin_end_state TO_SUBS;
    struct parsing_begin_end_state empty;
    empty.begin = -1;
    empty.end = -1;
    empty.current = -1;

    if (gettoken () == '[') {
        j3.begin = j;
        j3.current = j;
        j3.end = j;
        j++;
        j1 = repeat_operator (j3);              //ACHTUNG!!!
        if (gettoken () != ',') {
            fprintf (stderr, "Komma vergessen");
            exit (1);
        }
        j2 = repeat_operator (j3);              //ACHTUNG!!!
        if (gettoken () != ']') {
            fprintf (stderr, "Klammer vergessen ]");
            exit (1);
        }
        state1 [j3.current] = j1.begin;
        state2 [j3.current] = j2.end;
        statechar [j3.current] = '#';
        j4 = repeat_operator (empty);         //ACHTUNG!!!

        state1 [j1.begin] = j4.begin;
        state1 [j2.begin] = j4.begin;
        state2 [j1.end] = j4.begin;
        state2 [j2.end] = j4.begin;

        /*if (j1.begin == END)
            state1 [j1.current] = j1.begin; //ACHTUNG j3 j1 eggal
        state2 [j1.end] = j4.begin;
         if (j2.begin == END)
            state1 [j2.current] = j2.begin;  //ACHTUNG j3 j2 egal
        state2 [j2.end] = j4.begin;*/
    }
    else { 
        tokenback ();
        j3.current = j;
        j3.begin = j;
        j3.end = j;
        j3 = repeat_operator (j3);         //ACHTUNG!!!
    }
return j3;
}

struct parsing_begin_end_state repeat_operator (struct parsing_begin_end_state be_arg) {
    struct parsing_begin_end_state j1;
    struct parsing_begin_end_state be;
    be = parsing_begin_end_state_init ();
    j1 = parsing_begin_end_state_init ();

    if (gettoken ()  == '*') {
        be_arg.begin = j;
        be_arg.flags [FLAGS_REPEATET] = 1;
        j1 = stream (be_arg);
    }
    else { 
        be_arg.flags [FLAGS_REPEATET] = 0;
        tokenback ();
        j1 = stream (be_arg);
    }
return j1;
}

struct parsing_begin_end_state stream (struct parsing_begin_end_state be_arg) {
    struct parsing_begin_end_state be = parsing_begin_end_state_init ();

    compound (be_arg);
    return followed (be_arg);
}

struct parsing_begin_end_state followed (struct parsing_begin_end_state be_arg) {    
    struct parsing_begin_end_state j1, j2;
    struct parsing_begin_end_state t;
    struct parsing_begin_end_state be;
    be = parsing_begin_end_state_init ();
    j1 = parsing_begin_end_state_init ();
    j2 = parsing_begin_end_state_init ();
    int x;

    struct parsing_begin_end_state TO_SUBS;

    
    int ch = gettoken ();

    if ((ch >= 'a') && (ch <= 'z')) {
        t.begin = be_arg.begin;
        t.current = j;
        t.end = j;
        j++;

        if (be_arg.flags [FLAGS_REPEATET] == 0) {
            j2 = j1 = or_operator (be_arg);
            x = t.begin;
        }
        else {
            j2 = j1 = or_operator (be_arg);
            x = t.begin;
        }
        state1 [t.end] = x;
        state2 [t.end] = j2.end;
        statechar [t.end] = ch;

    }
    else {
        t.begin = be_arg.begin;
        t.current = j;
        t.end = j;
        tokenback ();
    }
return t;
}

struct parsing_begin_end_state compound (struct parsing_begin_end_state be_arg) {
    struct parsing_begin_end_state be;
    be = parsing_begin_end_state_init ();
    struct parsing_begin_end_state TO_SUBS;

    if (gettoken () == '(') {
        or_operator (TO_SUBS);
        if (gettoken () != ')') {
            fprintf (stderr, "fehler klammer vergessen %c %i\n", expr [i], i);
            exit (1);
        }
    }
    else
        tokenback ();
}


void init_end () {
    int k;
    for (k = 0;  k < MAX_STATES;  k++) {
        state1 [k] = END;
        state2 [k] = END;
    }
        
}

int main (void) {
    int k;
        struct parsing_begin_end_state TO_SUBS;
init_end ();
    or_operator (TO_SUBS);
    
    
    
    for (k = 0;  k < 24;  k++) {
        printf ("statechar [%i] = %c\n", k, statechar [k]);
        printf ("state1 [%i] = %i\n", k, state1 [k]);
        printf ("state2 [%i] = %i\n", k, state2 [k]);
    }
    
}