From 85b23fbee717f047af5a89eac6f4dba8e7812524 Mon Sep 17 00:00:00 2001 From: Galin Simeonov Date: Tue, 1 Jun 2021 18:21:02 +0300 Subject: restructuring --- src/backend/backend.c | 37 +++++ src/backend/backend.h | 18 +++ src/backend/print.c | 294 ------------------------------------- src/backend/print.h | 27 ---- src/backend/targets/C/ast_to_c.c | 155 ++++++++++++++++++++ src/backend/targets/C/ast_to_c.h | 29 ++++ src/backend/targets/print/print.c | 295 ++++++++++++++++++++++++++++++++++++++ src/backend/targets/print/print.h | 27 ++++ 8 files changed, 561 insertions(+), 321 deletions(-) create mode 100644 src/backend/backend.c create mode 100644 src/backend/backend.h delete mode 100644 src/backend/print.c delete mode 100644 src/backend/print.h create mode 100644 src/backend/targets/C/ast_to_c.c create mode 100644 src/backend/targets/C/ast_to_c.h create mode 100644 src/backend/targets/print/print.c create mode 100644 src/backend/targets/print/print.h (limited to 'src/backend') diff --git a/src/backend/backend.c b/src/backend/backend.c new file mode 100644 index 0000000..122e84c --- /dev/null +++ b/src/backend/backend.c @@ -0,0 +1,37 @@ +#ifndef BACKEND_C +#define BACKEND_C BACKEND_C +#include + +/*returns an array of pointers to state_and_transition structs*/ +struct State_And_Transitions** extract_transition_table(struct AST_States *states,struct AST_Transitions *transitions) +{ + struct State_And_Transitions **ret; + struct Queue *qs; + size_t i; + + ret=malloc(sizeof(struct State_And_Transitions)*states->number_of_states); + + /*calloc also initialises the queues + *i-th queue is for transitions starting from the i-th state + * */ + qs=calloc(sizeof(struct Queue),states->number_of_states); + + /*traverse transitions and push them into the queue of their coresponding state*/ + for(i=0;isize;++i) + Queue_Push(qs+transitions->transitions[i]->from->number,transitions->transitions[i]); + + /*condense the queues into the arrays*/ + for(i=0;inumber_of_states;++i) + { + ret[i]=malloc(sizeof(struct State_And_Transitions)+sizeof(struct AST_Transitions *[qs[i].size])); + ret[i]->state=states->states[i]; + ret[i]->number_of_transitions=qs[i].size; + pointer_array_fill((void**)ret[i]->transitions,qs+i); + } + + free(qs); + + return ret; +} + +#endif diff --git a/src/backend/backend.h b/src/backend/backend.h new file mode 100644 index 0000000..1857cd0 --- /dev/null +++ b/src/backend/backend.h @@ -0,0 +1,18 @@ +#ifndef BACKEND_H +#define BACKEND_H BACKEND_H +#include +#include + +/* + * describes a given state and the transitions coming out of it + * I should probbably have done this in the parsing stage + */ +struct State_And_Transitions +{ + struct AST_State *state; + size_t number_of_transitions; + struct AST_Transition *transitions[]; +}; +/*returns an array of state_and_transition structs*/ +struct State_And_Transitions** extract_transition_table(struct AST_States *states,struct AST_Transitions *transitions); +#endif diff --git a/src/backend/print.c b/src/backend/print.c deleted file mode 100644 index 614a6c9..0000000 --- a/src/backend/print.c +++ /dev/null @@ -1,294 +0,0 @@ -#ifndef PRINT_C -#define PRINT_C PRINT_C -#include - -void print_keyword_enum(enum Keyword code) -{ - switch(code) - { - case KW_MACHINE: - printf("KW_MACHINE"); - break; - case KW_FROM: - printf("KW_FROM"); - break; - case KW_TO: - printf("KW_TO"); - break; - case KW_ON: - printf("KW_ON"); - break; - case KW_ID: - printf("KW_ID"); - break; - case KW_STRING: - printf("KW_STRING"); - break; - case KW_NOP: - printf("KW_NOP"); - break; - case KW_EOF: - printf("KW_EOF"); - break; - case KW_OPEN_SQUARE: - printf("KW_OPEN_SQUARE"); - break; - case KW_CLOSE_SQUARE: - printf("KW_CLOSE_SQUARE"); - break; - case KW_PIPE: - printf("KW_PIPE"); - break; - case KW_SEMI_COLUMN: - printf("KW_SEMI_COLUMN"); - break; - case KW_STARTING: - printf("KW_STARTING"); - break; - case KW_STATES: - printf("KW_STATES"); - break; - case KW_EVENTS: - printf("KW_EVENTS"); - break; - case KW_EVENT: - printf("KW_EVENT"); - break; - case KW_TRANSITIONS: - printf("KW__TRANSITIONS"); - break; - case KW_EXECUTE: - printf("KW_EXECUTE"); - break; - case KW_COMMA: - printf("KW_COMMA"); - break; - default: - printf("LEXERROR"); - } -} -void print_token(struct token *token) -{ - size_t i; - assert(token); - - printf("[ "); - print_keyword_enum(token->type); - printf(" "); - for(i=0;isize;++i) - printf("%c",token->data[i]); - printf(" ] "); - -} -void print_tokens(struct Queue *tokens) -{ - struct Queue_Node *it; - assert(tokens); - - for(it=tokens->first;it!=NULL;it=it->prev) - { - print_token( (struct token*)(it->data)); - printf(" "); - } -} -void print_ast_enum(enum AST_Type type) -{ - switch(type) - { - case AST_TYPE_MACHINE: - printf("AST_TYPE_MACHINE"); - break; - case AST_TYPE_STATE: - printf("AST_TYPE_STATE"); - break; - case AST_TYPE_STATES: - printf("AST_TYPE_STATES"); - break; - case AST_TYPE_EVENT: - printf("AST_TYPE_EVENT"); - break; - case AST_TYPE_EVENTS: - printf("AST_TYPE_EVENTS"); - break; - case AST_TYPE_TRANSITION: - printf("AST_TYPE_TRANSITION"); - break; - case AST_TYPE_TRANSITIONS: - printf("AST_TYPE_TRANSITIONS"); - break; - case AST_TYPE_COMMAND: - printf("AST_TYPE_COMMAND"); - break; - case AST_TYPE_PIPELINE: - printf("AST_TYPE_PIPELINE"); - break; - default: - printf("AST_NOP"); - } - -} -void print_ast(struct AST *tree) -{ - assert(tree); - - switch(tree->type) - { - case AST_TYPE_MACHINE: - print_ast_machine((struct AST_Machine*)tree); - break; - case AST_TYPE_STATE: - print_ast_state((struct AST_State*)tree); - break; - case AST_TYPE_STATES: - print_ast_states((struct AST_States*)tree); - break; - case AST_TYPE_EVENT: - print_ast_event((struct AST_Event*)tree); - break; - case AST_TYPE_EVENTS: - print_ast_events((struct AST_Events*)tree); - break; - case AST_TYPE_TRANSITION: - print_ast_transition((struct AST_Transition*)tree); - break; - case AST_TYPE_TRANSITIONS: - print_ast_transitions((struct AST_Transitions*)tree); - break; - case AST_TYPE_COMMAND: - print_ast_command((struct AST_Command*)tree); - break; - case AST_TYPE_PIPELINE: - print_ast_pipeline((struct AST_Pipeline*)tree); - break; - default: - printf("noast"); - } -} -void print_ast_state(struct AST_State* tree) -{ - assert(tree); - - printf("[ STATE: "); - print_ast_enum(tree->type); - printf("]"); -} -void print_ast_event(struct AST_Event* tree) -{ - assert(tree); - - printf("[ EVENT: "); - print_ast_enum(tree->type); - printf("]"); -} -void print_ast_states(struct AST_States* tree) -{ - size_t i; - assert(tree); - - printf("STATES [\n"); - for(i=0;inumber_of_states;++i) - { - print_ast_state(tree->states[i]); - printf(" "); - } - printf("\n ] END STATES \n"); -} -void print_ast_events(struct AST_Events* tree) -{ - size_t i; - assert(tree); - - printf("EVENTS [\n"); - for(i=0;inumber_of_events;++i) - { - print_ast_event(tree->events[i]); - printf(" "); - } - printf("\n ] END EVENTS \n"); -} -void print_ast_transition(struct AST_Transition* tree) -{ - assert(tree); - - printf("TRANSITION [\nFROM"); - print_ast_state(tree->from); - printf(" TO "); - print_ast_state(tree->to); - printf(" COMMAND {"); - if(tree->pipeline==NULL) - { - printf("NULL"); - }else - { - print_ast_pipeline(tree->pipeline); - } - -} -void print_ast_command(struct AST_Command* tree) -{ - assert(tree); - - printf("( command "); - print_token(tree->function_name); - if(tree->argument==NULL) - { - printf(" NOARGUMENTS "); - }else - { - printf(" \""); - print_token(tree->argument); - printf("\" "); - } - printf(")"); -} -void print_ast_pipeline(struct AST_Pipeline* tree) -{ - size_t i; - assert(tree); - printf("PIPELINE <"); - for(i=0;isize;++i) - { - print_ast_command(tree->pipeline[i]); - printf(" | "); - } - printf("> PIPELINE_END"); -} -void print_ast_machine(struct AST_Machine* tree) -{ - assert(tree); - printf("MACHINE "); - print_token(tree->id); - printf(" [\n"); - print_ast_states(tree->states); - print_ast_events(tree->events); - print_ast_transitions(tree->transitions); - printf("] MACHINE_END\n"); -} -void print_ast_transitions(struct AST_Transitions* tree) -{ - size_t i; - assert(tree); - printf("TRANSITIONS [\n"); - for(i=0;isize;++i) - { - print_ast_transition(tree->transitions[i]); - printf("\n"); - } - printf("] TRANSITIONS_END\n"); -} -void print_error(struct Error *error) -{ - assert(error); - printf("Error: %s, line %ld row %ld\n",error->message,error->row,error->column); -} -void print_errors(struct Translation_Data *translation_data) -{ - struct Queue_Node *it; - assert(translation_data); - - for(it=translation_data->errors->first;it!=NULL;it=it->prev) - { - print_error(it->data); - } -} -#endif diff --git a/src/backend/print.h b/src/backend/print.h deleted file mode 100644 index 54d47ce..0000000 --- a/src/backend/print.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef PRINT_H -#define PRINT_H PRINT_H -#include -#include -#include -#include - - -void print_keyword_enum(enum Keyword code); -void print_token(struct token *token); -void print_tokens(struct Queue *tokens); - -void print_ast_enum(enum AST_Type type); -void print_ast(struct AST *tree); -void print_ast_state(struct AST_State* tree); -void print_ast_event(struct AST_Event* tree); -void print_ast_states(struct AST_States* tree); -void print_ast_events(struct AST_Events* tree); -void print_ast_transition(struct AST_Transition* tree); -void print_ast_command(struct AST_Command* tree); -void print_ast_pipeline(struct AST_Pipeline* tree); -void print_ast_machine(struct AST_Machine* tree); -void print_ast_transitions(struct AST_Transitions* tree); - -void print_error(struct Error *error); -void print_errors(struct Translation_Data *translation_data); -#endif diff --git a/src/backend/targets/C/ast_to_c.c b/src/backend/targets/C/ast_to_c.c new file mode 100644 index 0000000..346801c --- /dev/null +++ b/src/backend/targets/C/ast_to_c.c @@ -0,0 +1,155 @@ +#ifndef AST_TO_C_C +#define AST_TO_C_C AST_TO_C_C +#include +#include + +void ast_to_c(FILE *out,struct AST *tree) +{ + assert(tree->type==AST_TYPE_MACHINE); + ast_machine_to_c(out,(struct AST_Machine*)tree); +} +void ast_machine_to_c(FILE *out,struct AST_Machine *machine) +{ + + assert(out!=NULL && machine!=NULL && machine->type==AST_TYPE_MACHINE); + + + ast_machine_to_c_make_header_part(out,machine); + ast_machine_to_c_make_body_part(out,machine); + + +} +void ast_machine_to_c_make_body_part(FILE *out,struct AST_Machine *machine) +{ + size_t i; + struct State_And_Transitions **table; + + table=extract_transition_table(machine->states,machine->transitions); + + for(i=0;istates->number_of_states;++i) + { + ast_state_to_c_signature(out,machine,machine->states->states[i]); + fprintf(out,"\n{\n"); + ast_transitions_of_state_to_c(out,machine,table[i]); + fprintf(out,"\n}\n"); + } +} +void ast_machine_to_c_make_header_part(FILE *out,struct AST_Machine *machine) +{ + fprintf(out,"typedef struct machine_buffer_t \n{" + "\n\tsize_t size;\n\tunsigned char buffer[];\n} machine_buffer_t;\n\n"); + ast_events_to_c(out,machine); + ast_states_to_c(out,machine); +} +void ast_events_to_c(FILE *out,struct AST_Machine *machine) +{ + size_t i; + + assert(out!=NULL && machine!=NULL && machine->type==AST_TYPE_MACHINE); + + fprintf(out,"enum "); + ast_event_name_to_c(out,machine); + fprintf(out,"\n{\n"); + + for(i=0;ievents->number_of_events;++i) + { + fprintf(out,"\t"); + ast_token_to_c(out,machine->id); + fprintf(out,"_EVENT_"); + ast_token_to_c(out,machine->events->events[i]->name); + fprintf(out,",\n"); + } + fprintf(out,"};\n"); +} +void ast_states_to_c(FILE *out,struct AST_Machine *machine) +{ + size_t i; + assert(out!=NULL && machine!=NULL && machine->type==AST_TYPE_MACHINE); + for(i=0;istates->number_of_states;++i) + { + fprintf(out,"extern "); + ast_state_to_c_signature(out,machine,machine->states->states[i]); + fprintf(out,";\n"); + } +} +void ast_transitions_of_state_to_c(FILE *out,struct AST_Machine *machine,struct State_And_Transitions *vector) +{ + size_t i; + ast_state_to_c_signature(out,machine,vector->state); + fprintf(out,"\n{\n\n\tswitch(event)\n\t{\n"); + for(i=0;inumber_of_transitions;++i) + { + fprintf(out,"\t\tcase "); + ast_token_to_c(out,vector->transitions[i]->event->name); + fprintf(out,":\n"); + ast_pipeline_to_c(out,3,vector->transitions[i]->pipeline); + fprintf(out,"\n\t\t\tbreak;\n"); + } + +} +void ast_event_name_to_c(FILE *out,struct AST_Machine *machine) +{ + fprintf(out,"MACHINE_"); + ast_token_to_c(out,machine->id); + fprintf(out,"_EVENTS_ENUM"); +} +void ast_state_to_c_signature(FILE *out,struct AST_Machine *machine,struct AST_State *state) +{ + fprintf(out,"void machine_"); + ast_token_to_c(out,machine->id); + fprintf(out,"_state_"); + ast_token_to_c(out,state->name); + fprintf(out,"(enum "); + ast_event_name_to_c(out,machine); + fprintf(out," event)\n"); +} +void ast_token_to_c(FILE *out,struct token *token) +{ + size_t i; + + assert(out!=NULL && token!=NULL); + + for(i=0;isize;++i) + fprintf(out,"%c",token->data[i]); +} +void ast_pipeline_to_c(FILE *out,size_t indentation,struct AST_Pipeline *pipeline) +{ + size_t i; + + ast_to_c_print_tabs(out,indentation); + fprintf(out,"machine_buffer_t *hold_buffer;\n"); + + for(i=0;isize;++i) + { + ast_to_c_print_tabs(out,indentation); + fprintf(out,"hold_buffer="); + ast_command_to_c(out,pipeline->pipeline[i],"hold_buffer"); + fprintf(out,";\n"); + } + ast_to_c_print_tabs(out,indentation); + fprintf(out,"delete_machine_buffer(hold_buffer);\n"); +} +void ast_command_to_c(FILE *out,struct AST_Command *command,char *hold_buffer) +{ + ast_token_to_c(out,command->function_name); + fprintf(out,"("); + if(command->argument==NULL) + fprintf(out,"NULL"); + else + ast_token_to_c(out,command->argument); + fprintf(out,",%s)",hold_buffer); +} + +void ast_command_to_c_signature(FILE *out,struct AST_Command *command) +{ + fprintf(out,"machine_buffer_t* "); + ast_token_to_c(out,command->function_name); + fprintf(out,"machine_buffer_t *arguments,machine_buffer_t *input)"); +} +void ast_to_c_print_tabs(FILE *out,size_t number_of_tabs) +{ + size_t i; + for(i=0;i +#include +#include +#include + +struct State_And_Transitions; + +void ast_to_c(FILE *out,struct AST *tree); +void ast_machine_to_c(FILE *out,struct AST_Machine *machine); +void ast_machine_to_c_make_header_part(FILE *out,struct AST_Machine *machine); +void ast_machine_to_c_make_body_part(FILE *out,struct AST_Machine *machine); + +void ast_events_to_c(FILE *out,struct AST_Machine *machine); +void ast_states_to_c(FILE *out,struct AST_Machine *machine); + +void ast_pipeline_to_c(FILE *out,size_t indentation,struct AST_Pipeline *pipeline); +void ast_command_to_c(FILE *out,struct AST_Command *command,char *hold_buffer); +void ast_command_to_c_signature(FILE *out,struct AST_Command *command); + +void ast_transitions_of_state_to_c(FILE *out,struct AST_Machine *machine,struct State_And_Transitions *vector); +void ast_token_to_c(FILE *out,struct token *token); +void ast_event_name_to_c(FILE *out,struct AST_Machine *machine); +void ast_state_to_c_signature(FILE *out,struct AST_Machine *machine,struct AST_State *state); +/* :X */ +void ast_to_c_print_tabs(FILE *out,size_t number_of_tabs); + +#endif diff --git a/src/backend/targets/print/print.c b/src/backend/targets/print/print.c new file mode 100644 index 0000000..8eae3dd --- /dev/null +++ b/src/backend/targets/print/print.c @@ -0,0 +1,295 @@ +#ifndef PRINT_C +#define PRINT_C PRINT_C +#include + +void print_keyword_enum(enum Keyword code) +{ + switch(code) + { + case KW_MACHINE: + printf("KW_MACHINE"); + break; + case KW_FROM: + printf("KW_FROM"); + break; + case KW_TO: + printf("KW_TO"); + break; + case KW_ON: + printf("KW_ON"); + break; + case KW_ID: + printf("KW_ID"); + break; + case KW_STRING: + printf("KW_STRING"); + break; + case KW_NOP: + printf("KW_NOP"); + break; + case KW_EOF: + printf("KW_EOF"); + break; + case KW_OPEN_SQUARE: + printf("KW_OPEN_SQUARE"); + break; + case KW_CLOSE_SQUARE: + printf("KW_CLOSE_SQUARE"); + break; + case KW_PIPE: + printf("KW_PIPE"); + break; + case KW_SEMI_COLUMN: + printf("KW_SEMI_COLUMN"); + break; + case KW_STARTING: + printf("KW_STARTING"); + break; + case KW_STATES: + printf("KW_STATES"); + break; + case KW_EVENTS: + printf("KW_EVENTS"); + break; + case KW_EVENT: + printf("KW_EVENT"); + break; + case KW_TRANSITIONS: + printf("KW__TRANSITIONS"); + break; + case KW_EXECUTE: + printf("KW_EXECUTE"); + break; + case KW_COMMA: + printf("KW_COMMA"); + break; + default: + printf("LEXERROR"); + } +} +void print_token(struct token *token) +{ + size_t i; + assert(token); + + printf("[ "); + print_keyword_enum(token->type); + printf(" "); + for(i=0;isize;++i) + printf("%c",token->data[i]); + printf(" ] "); + +} +void print_tokens(struct Queue *tokens) +{ + struct Queue_Node *it; + assert(tokens); + + for(it=tokens->first;it!=NULL;it=it->prev) + { + print_token( (struct token*)(it->data)); + printf(" "); + } +} +void print_ast_enum(enum AST_Type type) +{ + switch(type) + { + case AST_TYPE_MACHINE: + printf("AST_TYPE_MACHINE"); + break; + case AST_TYPE_STATE: + printf("AST_TYPE_STATE"); + break; + case AST_TYPE_STATES: + printf("AST_TYPE_STATES"); + break; + case AST_TYPE_EVENT: + printf("AST_TYPE_EVENT"); + break; + case AST_TYPE_EVENTS: + printf("AST_TYPE_EVENTS"); + break; + case AST_TYPE_TRANSITION: + printf("AST_TYPE_TRANSITION"); + break; + case AST_TYPE_TRANSITIONS: + printf("AST_TYPE_TRANSITIONS"); + break; + case AST_TYPE_COMMAND: + printf("AST_TYPE_COMMAND"); + break; + case AST_TYPE_PIPELINE: + printf("AST_TYPE_PIPELINE"); + break; + default: + printf("AST_NOP"); + } + +} +void print_ast(struct AST *tree) +{ + assert(tree); + + switch(tree->type) + { + case AST_TYPE_MACHINE: + print_ast_machine((struct AST_Machine*)tree); + break; + case AST_TYPE_STATE: + print_ast_state((struct AST_State*)tree); + break; + case AST_TYPE_STATES: + print_ast_states((struct AST_States*)tree); + break; + case AST_TYPE_EVENT: + print_ast_event((struct AST_Event*)tree); + break; + case AST_TYPE_EVENTS: + print_ast_events((struct AST_Events*)tree); + break; + case AST_TYPE_TRANSITION: + print_ast_transition((struct AST_Transition*)tree); + break; + case AST_TYPE_TRANSITIONS: + print_ast_transitions((struct AST_Transitions*)tree); + break; + case AST_TYPE_COMMAND: + print_ast_command((struct AST_Command*)tree); + break; + case AST_TYPE_PIPELINE: + print_ast_pipeline((struct AST_Pipeline*)tree); + break; + default: + printf("noast"); + } +} +void print_ast_state(struct AST_State* tree) +{ + assert(tree); + + printf("[ STATE: "); + print_token(tree->name); + printf(" %ld",tree->number); + printf("]"); +} +void print_ast_event(struct AST_Event* tree) +{ + assert(tree); + + printf("[ EVENT: "); + print_token(tree->name); + printf("]"); +} +void print_ast_states(struct AST_States* tree) +{ + size_t i; + assert(tree); + + printf("STATES [\n"); + for(i=0;inumber_of_states;++i) + { + print_ast_state(tree->states[i]); + printf(" "); + } + printf("\n ] END STATES \n"); +} +void print_ast_events(struct AST_Events* tree) +{ + size_t i; + assert(tree); + + printf("EVENTS [\n"); + for(i=0;inumber_of_events;++i) + { + print_ast_event(tree->events[i]); + printf(" "); + } + printf("\n ] END EVENTS \n"); +} +void print_ast_transition(struct AST_Transition* tree) +{ + assert(tree); + + printf("TRANSITION [\nFROM"); + print_ast_state(tree->from); + printf(" TO "); + print_ast_state(tree->to); + printf(" COMMAND {"); + if(tree->pipeline==NULL) + { + printf("NULL"); + }else + { + print_ast_pipeline(tree->pipeline); + } + +} +void print_ast_command(struct AST_Command* tree) +{ + assert(tree); + + printf("( command "); + print_token(tree->function_name); + if(tree->argument==NULL) + { + printf(" NOARGUMENTS "); + }else + { + printf(" \""); + print_token(tree->argument); + printf("\" "); + } + printf(")"); +} +void print_ast_pipeline(struct AST_Pipeline* tree) +{ + size_t i; + assert(tree); + printf("PIPELINE <"); + for(i=0;isize;++i) + { + print_ast_command(tree->pipeline[i]); + printf(" | "); + } + printf("> PIPELINE_END"); +} +void print_ast_machine(struct AST_Machine* tree) +{ + assert(tree); + printf("MACHINE "); + print_token(tree->id); + printf(" [\n"); + print_ast_states(tree->states); + print_ast_events(tree->events); + print_ast_transitions(tree->transitions); + printf("] MACHINE_END\n"); +} +void print_ast_transitions(struct AST_Transitions* tree) +{ + size_t i; + assert(tree); + printf("TRANSITIONS [\n"); + for(i=0;isize;++i) + { + print_ast_transition(tree->transitions[i]); + printf("\n"); + } + printf("] TRANSITIONS_END\n"); +} +void print_error(struct Error *error) +{ + assert(error); + printf("Error: %s, line %ld row %ld\n",error->message,error->row,error->column); +} +void print_errors(struct Translation_Data *translation_data) +{ + struct Queue_Node *it; + assert(translation_data); + + for(it=translation_data->errors->first;it!=NULL;it=it->prev) + { + print_error(it->data); + } +} +#endif diff --git a/src/backend/targets/print/print.h b/src/backend/targets/print/print.h new file mode 100644 index 0000000..54d47ce --- /dev/null +++ b/src/backend/targets/print/print.h @@ -0,0 +1,27 @@ +#ifndef PRINT_H +#define PRINT_H PRINT_H +#include +#include +#include +#include + + +void print_keyword_enum(enum Keyword code); +void print_token(struct token *token); +void print_tokens(struct Queue *tokens); + +void print_ast_enum(enum AST_Type type); +void print_ast(struct AST *tree); +void print_ast_state(struct AST_State* tree); +void print_ast_event(struct AST_Event* tree); +void print_ast_states(struct AST_States* tree); +void print_ast_events(struct AST_Events* tree); +void print_ast_transition(struct AST_Transition* tree); +void print_ast_command(struct AST_Command* tree); +void print_ast_pipeline(struct AST_Pipeline* tree); +void print_ast_machine(struct AST_Machine* tree); +void print_ast_transitions(struct AST_Transitions* tree); + +void print_error(struct Error *error); +void print_errors(struct Translation_Data *translation_data); +#endif -- cgit v1.2.3