void resolve_path_components(unsigned char * path, struct unsigned_char_ptr_list * path_components, struct memory_pool_collection * m){
/* Split up a path like /a/b/abc/d into 'a', 'b', 'abc', 'd' */
unsigned int j = 0;
struct unsigned_char_list tmp;
unsigned_char_list_create(&tmp);
while(path[j]){
if(path[j] == '/'){
if(unsigned_char_list_size(&tmp)){
unsigned int len = unsigned_char_list_size(&tmp);
unsigned char * s = copy_string(unsigned_char_list_data(&tmp), ((unsigned char *)unsigned_char_list_data(&tmp)) + (len -1), m);
unsigned_char_ptr_list_add_end(path_components, s);
}else{
unsigned char * s = heap_memory_pool_malloc(m->heap_pool, 1);
s[0] = 0; /* empty string */
unsigned_char_ptr_list_add_end(path_components, s);
}
unsigned_char_list_destroy(&tmp);
unsigned_char_list_create(&tmp);
}else{
unsigned_char_list_add_end(&tmp, path[j]);
}
j++;
}
if(unsigned_char_list_size(&tmp)){
unsigned int len = unsigned_char_list_size(&tmp);
unsigned char * s = copy_string(unsigned_char_list_data(&tmp), ((unsigned char *)unsigned_char_list_data(&tmp)) + (len-1), m);
unsigned_char_ptr_list_add_end(path_components, s);
}
unsigned_char_list_destroy(&tmp);
}
int output_buffer_to_file(struct unsigned_char_list * buffer, char * out_file){
FILE *f = NULL;
unsigned char * data = unsigned_char_list_data(buffer);
unsigned int size = unsigned_char_list_size(buffer);
if(!(f = fopen(out_file, "w"))){
printf("Failed to open file %s for write.\n", out_file);
return 1;
}
fwrite(data, sizeof(unsigned char), size, f);
fclose(f);
return 0;
}
int main(void){
const char * file_to_open = "test/c89/empty-main-return-zero.c";
struct c_lexer_state c_lexer_state;
struct memory_pool_collection memory_pool_collection;
struct unsigned_char_list input_characters;
int rtn = 0;
struct parser_state parser_state;
struct unsigned_char_list generated_code;
struct unsigned_char_list lexer_output;
struct unsigned_char_list buffered_symbol_table;
struct preprocessor_state * preprocessor_state;
struct unsigned_char_list preprocssed_characters;
struct struct_c_lexer_token_ptr_list output_tokens;
struct code_gen_state code_gen_state;
struct_c_lexer_token_ptr_list_create(&output_tokens);
unsigned_char_list_create(&lexer_output);
unsigned_char_list_create(&input_characters);
unsigned_char_list_create(&buffered_symbol_table);
unsigned_char_list_create(&preprocssed_characters);
memory_pool_collection_create(&memory_pool_collection);
unsigned_char_list_create(&generated_code);
preprocessor_state = create_preprocessor_state(&memory_pool_collection);
if(!(rtn = get_preprocessed_output_from_file(preprocessor_state, (unsigned char *)file_to_open, &output_tokens))){
unsigned int i;
for(i = 0; i < struct_c_lexer_token_ptr_list_size(&output_tokens); i++){
struct c_lexer_token * current_token = struct_c_lexer_token_ptr_list_get(&output_tokens, i);
unsigned char * j;
for(j = current_token->first_byte; j < (current_token->last_byte + 1); j++){
unsigned_char_list_add_end(&preprocssed_characters, *j);
putchar(*j);
}
}
}else{
printf("Nothing to output. Preprocessing failed for %s\n", file_to_open);
}
printf("\nCompleted preprocessing\n");
printf("\n");
create_c_lexer_state(&c_lexer_state, &lexer_output, &memory_pool_collection, (unsigned char *)file_to_open, unsigned_char_list_data(&preprocssed_characters), unsigned_char_list_size(&preprocssed_characters));
rtn = lex_c(&c_lexer_state);
if(!rtn){
unsigned int i;
for(i = 0; i < struct_c_lexer_token_ptr_list_size(&c_lexer_state.tokens); i++){
struct c_lexer_token * tok = struct_c_lexer_token_ptr_list_get(&c_lexer_state.tokens, i);
printf("%s\n", get_c_token_type_names()[tok->type]);
}
printf("Lex was successful.\n");
}
printf("Begin parsing:\n");
create_parser_state(&parser_state, &memory_pool_collection, &c_lexer_state, &generated_code, unsigned_char_list_data(&preprocssed_characters));
if(parse(&parser_state)){
printf("Parsing failed.\n");
}else{
printf("Full parser true:\n");
print_parser_nodes(parser_state.top_node, 0);
}
create_code_gen_state(&code_gen_state, &parser_state, &generated_code, &buffered_symbol_table);
if(generate_code(&code_gen_state)){
printf("Parsing failed.\n");
}else{
unsigned int i;
unsigned int size;
unsigned char * data;
printf("Code generation was successful.\n");
size = unsigned_char_list_size(&generated_code);
data = unsigned_char_list_data(&generated_code);
printf("About to print\n");
printf("%c\n",'a');
printf("print %d size\n", size);
printf("print %c first \n", data[0]);
for(i = 0; i < size; i++){
printf("%c", data[i]);
}
}
struct_c_lexer_token_ptr_list_destroy(&output_tokens);
unsigned_char_list_destroy(&input_characters);
unsigned_char_list_destroy(&generated_code);
unsigned_char_list_destroy(&buffered_symbol_table);
unsigned_char_list_destroy(&lexer_output);
destroy_code_gen_state(&code_gen_state);
destroy_parser_state(&parser_state);
destroy_preprocessor_state(preprocessor_state);
unsigned_char_list_destroy(&preprocssed_characters);
destroy_c_lexer_state(&c_lexer_state);
memory_pool_collection_destroy(&memory_pool_collection);
return 0;
}
