/media/sda-magnetic/david/Extern-Magnetic-2022-06-29/Extern01/Dokumente-2020-11-16/disk10-ab-2020-01-10/02-debian-pc2-work/informatik/pascal-compiler/2020-01-22-types-and-tree/pascal96between.c

struct bin_tree {
    struct bin_tree *next;
    struct bin_tree *sub;
    int id;
};

struct bin_tree *root;
    
int create_name(char *str) {
    namespace_id++;
    if(namespace_id < NAME_N_MAX)
        strcpy(name_table[namespace_id], str);
    else {
        printf("I'm sorry too much names in use\n");
        return 0;
    }
return 1;
}


int functionheading(void) {
    char str[256];
    int buf_i_start;
    int retval;    
    int buf_j;
    
    /*
     * <functionsheading> ::= function <functionid> <parameterlist> : <resulttype>;
     */
    
    buf_i_start = buf_i;
    buf_j = lex_get_token_from_stream_ws(str);
    if(is_function(str)) {
        buf_i += buf_j;
        buf_j = lex_get_token_from_stream_ws(str);
        if(is_var_name(str)) {
            
            /* So an dieser Stelle muss die Tabelle fuer die Namen her */
            
            if(create_name(str) != 0) {
                buf_i += buf_j;
                if(parameter_list()) {
                    buf_j = lex_get_token_from_stream_ws(str);
                    if(is_colon(str)) {
                        buf_i += buf_j;
                        if(result_type()) {
                            buf_j = lex_get_token_from_stream_ws(str);
                            if(is_semicolon(str)) {
                                retval = 1;
                                buf_i += buf_j;
                            }
                            else {
                                retval = 0;
                                buf_i = buf_i_start;
                            }
                        }
                        else {
                            retval = 0;
                            buf_i = buf_i_start;
                        }
                    }
                    else {
                        retval = 0;
                        buf_i = buf_i_start;
                    }
                }
                else {
                    retval = 0;
                    buf_i = buf_i_start;
                }
            }
            else {
                retval = 0;
                buf_i = buf_i_start;
            }
        }
        else {
            retval = 0;
            buf_i = buf_i_start;
        }
    }
    else {
        retval = 0;
        buf_i = buf_i_start;
    }
    
return retval;
}
    
int func_type_set(char *str) {
    return 1;
}
    
int procedureheading(void) {
    char str[256];
    int buf_i_start;
    int retval;    
    int buf_j;
    
    /*
     * <procedureheading> ::= procedure <procedureid> <procedureparameterlist>;
     */
    
    buf_i_start = buf_i;
    buf_j = lex_get_token_from_stream_ws(str);
    if(is_procedure(str)) {
        buf_i += buf_j;
        buf_j = lex_get_token_from_stream_ws(str);
        if(is_var_name(str)) {
             if(create_name(str) != 0) {
                buf_i += buf_j;
                if(procedure_parameter_list()) {
                    if(func_type_set("procedure") != 0) {
                        buf_j = lex_get_token_from_stream_ws(str);
                        if(is_semicolon(str)) {
                            retval = 1;
                            buf_i += buf_j;
                        }
                        else {
                            retval = 0;
                            buf_i += buf_j;
                        }
                    }
                    else {
                        retval = 0;
                        buf_i = buf_i_start;
                    }
                }
                else {
                    retval = 0;
                    buf_i = buf_i_start;
                }
            }
            else {
                retval = 0;
                buf_i = buf_i_start;
            }
        }
        else {
            retval = 0;
            buf_i = buf_i_start;
        }
    }
    else {
        retval = 0;
        buf_i = buf_i_start;
    }
    
return retval;
}
  
    

int var_definition_part(void);
int functiondeclarationpart(void);
    
int functiondefinition(void) {
    int buf_i_start;
    int retv;
    
    /*
  *functiondefinition ::= functionheading; block;
  *functionheading ::= 
  *
  *
  **/   
    
    buf_i_start = buf_i;
    retv = functionheading();
    if(retv == 0) {
        buf_i = buf_i_start; 
    }
    else {
        if(type_declaration_part()) {
            retv = 1;
        }
        if(var_definition_part()) {
            retv = 1;
        }
        if(functiondeclarationpart()) {
            retv = 1;
        }
        retv = block();
        if(retv == 0)
            buf_i = buf_i_start;

    }
    
return retv;
}


struct bin_tree *definition_part() {
    struct bin_tree *retval = NULL;
        
    if((retval = type_declaration_part()) != NULL) {
        if((retval->next = var_definition_part()) != NULL) {
            retval->next->next = functiondeclarationpart();
        }
        else {
            retval->next = functiondeclartionpart();
        }
    }
    else if((retval = var_definition_part()) != NULL) {
        retval->next = functiondeclarationpart();
    }
    else if((retval = functiondeclarationpart()) != NULL);

return retval;
}


struct bin_tree *proceduredefinition(void) {
    int buf_i_start;
    int retv;
    struct bin_tree *retval;
    
    /*
  *functiondefinition ::= functionheading; block;
  *functionheading ::= 
  *
  *
  **/   
    
    buf_i_start = buf_i;
    
    retv = procedureheading();
    if(retv == 0) {
        buf_i = buf_i_start; 
    }
    else {
        if((retval = (struct bin_tree *)malloc(sizeof(struct bin_tree))) == NULL) {
            perror("Not enough memory");
            exit(1);
        }
        retval->id = namespace_id;
        retval->next = NULL;
        retval->sub = definition_part();
        
        retv = block();
        if(retv == 0)
            buf_i = buf_i_start;
    }
    
return retval;
}


struct bin_tree *functiondeclarationpart(void) {
    int buf_i_start;
    struct bin_tree *retval;
    struct bin_tree *r1;
    struct bin_tree *r2;
    
    buf_i_start = buf_i;
        
    r1 = functiondefinition();
    r2 = proceduredefinition();
            
    if(r1 != NULL)
        retval = r1;
    if(r2 != NULL)
        retval = r2;
    if(retval != NULL) 
        retval->next = functiondeclarationpart();
    else {
        buf_i = buf_i_start;
        retval = NULL;
    }
return retval;
}


int var_type_set(char *str) {
    return 1;
}

struct bin_tree *vardefinition(void) {
    int buf_i_start;
    int buf_j;
    struct bin_tree *retval;
    char str[256];
    
    buf_i_start = buf_i;
    
    buf_j = lex_get_token_from_stream_ws(str);
    if(is_var_name(str)) {
        if(create_name(str) != 0) {
            buf_i += buf_j;
            buf_j = lex_get_token_from_stream_ws(str);
            if(is_colon(str)) {
                buf_i += buf_j;
                buf_j = lex_get_token_from_stream_ws(str);
                if(is_var_name(str)) {
                    if(var_type_set(str)) {
                        buf_i += buf_j;
                        buf_j = lex_get_token_from_stream_ws(str);
                        if(is_semicolon(str)) {
                            buf_i += buf_j;
                            if((retval = (struct bin_tree *)malloc(sizeof(struct bin_tree))) == NULL) {
                                perror("Not enough memory");
                                exit(1);
                            }
                            retval->next = NULL;
                            retval->sub = NULL;
                            retval->id = namespace_id;
                        }
                        else {
                            buf_i = buf_i_start;
                            retval = NULL;
                        }
                    }
                    else {
                        buf_i = buf_i_start;
                        retval = NULL;
                    }
                }
                else {
                    buf_i = buf_i_start;
                    retval = NULL;
                }
            }
            else {
                buf_i = buf_i_start;
                retval = NULL;
            }
        }
        else {
            buf_i = buf_i_start;
            retval = NULL;
        }
    }
    else {
        buf_i = buf_i_start;
        retval = NULL;
    }
    
return retval;
}

struct bin_tree *vardefinitionpart(void) {
    int buf_i_start;
    struct bin_tree *retval = NULL;
    
    buf_i_start = buf_i;
    if((retval = vardefinition()) != NULL)  
        retval->next = vardefinitionpart();
    else {
        retval = NULL;
        buf_i = buf_i_start;
    }
return retval;
}

int var_definition_part(void) {
    char str[256];
    int buf_j;
    int buf_i_start;
    int retval;
    
    buf_i_start = buf_i;
    
    buf_j = lex_get_token_from_stream_ws(str);
    if(is_var_procedure_attribute(str)) {
        buf_i += buf_j;
        if(vardefinitionpart()) {
            retval = 1;
        }
        else {
            retval = 0;
            buf_i = buf_i_start;
        }
    }
    else {
        buf_i = buf_i_start;
        retval = 0;
    }
return retval;
}


int main(void) {
    
    if((head = (struct lin_list *)malloc(sizeof(struct lin_list))) == NULL) {
        perror("Not enough memory!");
        exit(1);
    }
    
    head->id = 0;
    head->next = NULL;
    
}