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/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 ++++ 4 files changed, 506 insertions(+) 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/targets') 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