static void test_lex(const char *input) { struct ds output; ds_init(&output); struct lexer lexer; lexer_init(&lexer, input); ds_clear(&output); while (lexer_get(&lexer) != LEX_T_END) { size_t len = output.length; lex_token_format(&lexer.token, &output); /* Check that the formatted version can really be parsed back * losslessly. */ if (lexer.token.type != LEX_T_ERROR) { const char *s = ds_cstr(&output) + len; struct lexer l2; lexer_init(&l2, s); lexer_get(&l2); compare_token(&lexer.token, &l2.token); lexer_destroy(&l2); } ds_put_char(&output, ' '); } lexer_destroy(&lexer); ds_chomp(&output, ' '); puts(ds_cstr(&output)); ds_destroy(&output); }
int cmd_lex(FILE *file, const char *filename) { struct token token; buffer_t token_value; token_value = buffer_create(1024); lexer_init(file); log_set_unit(basename(filename)); printf("Line\tText\tValue\tType\n"); fflush(stdout); while (lexer_next_token(&token)) { lexer_token_value(&token, token_value); printf("%d:%d\t%s\t%s\t%s\n", token.line, token.column, token.text, buffer_data(token_value), lexer_token_type_name(token.type)); fflush(stdout); lexer_token_free_data(&token); } buffer_free(token_value); lexer_destroy(); log_close(); return EXIT_SUCCESS; }
int run_repl(context* ctx) { parser_state* ps = calloc(sizeof(parser_state), 1); ps->die_on_error = 0; ps->error.max = 20; for(unsigned line = 1; ; ++line) { char* input = readline(">> "); if(input == NULL) break; add_history(input); char* ret = malloc(strlen(input) + 2); strcpy(ret, input); strcat(ret, "\n"); free(input); reader r; string_reader_create(&r, ret); lexer_state* ls = calloc(sizeof(lexer_state), 1); lexer_create(ls, &r); ps->ls = ls; ps->ls->linenum = line; ps->t = lexer_next_token(ps->ls); expression_node* program = parse_program(ps); if(program && program->node.block) { for(struct expression_list* expr = program->node.block->list; expr; expr = expr->next) { expression_node* eval = expression_node_evaluate(expr->expression, ctx); char* str = expression_node_inspect(eval); printf("==> %s\n", str); free(str); expression_node_destroy(eval); } expression_node_destroy(program); free(r.fn_data); lexer_destroy(ls); free(ls); free(ret); } } free(ps); return 0; }
int interpret_program(tvm_program_t* p, char* filename, tvm_memory_t* pMemory) { int i; FILE* pFile = NULL; int source_length = 0; char* source = NULL; tvm_lexer_t* lexer = NULL; /* Attempt to open the file. If the file cannot be opened, try once more. */ if(filename) for(i = 0; i < 2; i++) if(!pFile) pFile = tvm_fopen(filename, ".vm", "r"); if(!pFile) { printf("File was not found, or does not exist. Unable to interpret.\n"); return 1; } source_length = tvm_flength(pFile); source = malloc(source_length); tvm_fcopy(source, source_length, pFile); lexer = lexer_create(); lex(lexer, source); free(source); fclose(pFile); if(parse_labels(p, (const char***)lexer->tokens) != 0) return 1; for(i = 0; lexer->tokens[i]; i++) { p->instr = (int*)realloc(p->instr, sizeof(int) * (i + 2)); p->instr[i] = 0; p->args = (int***)realloc(p->args, sizeof(int**) * (i + 2)); p->args[i] = (int**)calloc(MAX_ARGS, sizeof(int*)); parse_instruction(p, (const char**)lexer->tokens[i], pMemory); } lexer_destroy(lexer); p->args[i] = NULL; p->instr[i] = -0x1; return 0; }
/* Like actions_parse(), but the actions are taken from 's'. */ char * OVS_WARN_UNUSED_RESULT actions_parse_string(const char *s, const struct action_params *ap, struct ofpbuf *ofpacts, struct expr **prereqsp) { struct lexer lexer; char *error; lexer_init(&lexer, s); lexer_get(&lexer); error = actions_parse(&lexer, ap, ofpacts, prereqsp); lexer_destroy(&lexer); return error; }
int cmd_parse_expr(FILE *file, const char *filename, const char *cmd) { log_set_unit(basename(filename)); lexer_init(file); parser_init(); generator_init(); struct node* node = NULL; symtable_t symtable = NULL; code_t code = NULL; if (strcmp(cmd, "parse_expr") == 0) { parser_flags_set(0); node = parser_parse_expr(); print_node(node, 0, 0); } else if (strcmp(cmd, "parse_stmt") == 0) { parser_flags_set(0); node = parser_parse_statement(); print_node(node, 0, 0); } else if (strcmp(cmd, "parse") == 0) { parser_flags_set(PF_RESOLVE_NAMES); symtable = parser_parse(); print_symtable(symtable, 0); } else if (strcmp(cmd, "compile") == 0) { symtable = parser_parse(); if (symtable != NULL) { code = generator_process(symtable); optimizer_optimize(code); generator_print_code(code); } else { print_symtable(symtable, 0); } } parser_free_node(node); symtable_destroy(symtable, 1); generator_free_code(code); generator_destroy(); parser_destroy(); lexer_destroy(); log_close(); return EXIT_SUCCESS; }
/* Like actions_parse(), but the actions are taken from 's'. */ char * OVS_WARN_UNUSED_RESULT actions_parse_string(const char *s, const struct shash *symtab, const struct simap *ports, const struct simap *ct_zones, uint8_t first_table, uint8_t n_tables, uint8_t cur_table, uint8_t output_table, struct ofpbuf *ofpacts, struct expr **prereqsp) { struct lexer lexer; char *error; lexer_init(&lexer, s); lexer_get(&lexer); error = actions_parse(&lexer, symtab, ports, ct_zones, first_table, n_tables, cur_table, output_table, ofpacts, prereqsp); lexer_destroy(&lexer); return error; }
int run_file(const char* filename, context* ctx) { reader r; lexer_state* ls = calloc(sizeof(lexer_state), 1); parser_state* ps = calloc(sizeof(parser_state), 1); FILE* fp = fopen(filename, "r"); if(!fp) { printf("Error: can't open file '%s'\n", filename); return 1; } file_reader_create(&r, fp); lexer_create(ls, &r); ps->ls = ls; ps->die_on_error = 0; ps->error.max = 20; ps->t = lexer_next_token(ps->ls); expression_node* program = parse_program(ps); expression_node* eval = expression_node_evaluate(program, ctx); expression_node_destroy(eval); expression_node_destroy(program); lexer_destroy(ls); free(ls); free(ps); free(r.fn_data); fclose(fp); return 0; }
int main(int argc, char const *argv[]) { for (--argc, ++argv; 0 < argc; --argc, ++argv) { lexer_t *lexer = NULL; char *buffer = NULL; FILE *fp = NULL; long length = -1; long readlen = 0; if (!(*argv)) { fprintf(stderr, "NULL argument to bmxlex\n"); return 1; } fp = fopen(*argv, "rb"); if (fp == NULL) { fprintf(stderr, "Failed to open file %s\n", *argv); return 1; } if (fseek(fp, 0, SEEK_END)) { fprintf(stderr, "Failed to seek to the end of %s\n", *argv); goto ERROR_CLOSE_FILE; } length = ftell(fp); if (length == -1) { fprintf(stderr, "Failed to get the length of %s\n", *argv); goto ERROR_CLOSE_FILE; } if (fseek(fp, 0, SEEK_SET)) { fprintf(stderr, "Failed to seek to the start of %s\n", *argv); goto ERROR_CLOSE_FILE; } buffer = (char *)malloc(length); if (buffer == NULL) { fprintf(stderr, "Failed to allocate memory for source buffer for %s\n", *argv); goto ERROR_CLOSE_FILE; } if ((readlen = fread(buffer, 1, length, fp)) != length) { fprintf(stderr, "Failed to read file %s to source buffer (read %ld)\n", *argv, readlen); goto ERROR_CLOSE_FREE; } fclose(fp); lexer = lexer_new(buffer, buffer + length); int err = lexer_run(lexer); if (err) { fprintf(stderr, "Failed to lex %s\nError: %s\n", *argv, lexer_get_error(lexer)); // free(buffer); // return 1; } { size_t num_tokens = lexer_get_num_tokens(lexer); size_t index = 0; for (; index < num_tokens; ++index) { token_t token; char *str = NULL; char *trapped = NULL; size_t len = 0; size_t trapped_len = 0; size_t idx = 0; size_t trapped_idx = 0; lexer_get_token(lexer, index, &token); if (token.kind == TOK_INVALID) { free(buffer); fprintf(stderr, "Invalid token encountered at %d:%d in %s\n", token.line, token.column, *argv); return 1; } str = token_to_string(&token); len = strlen(str); for (; idx < len; ++idx) trapped_len += ((str[idx] == '\n') ? 2 : 1); trapped = calloc(trapped_len + 1, 1); for (idx = 0; idx < len; ++idx, ++trapped_idx) { if (str[idx] == '\n') { trapped[trapped_idx++] = '\\'; trapped[trapped_idx] = 'n'; } else { trapped[trapped_idx] = str[idx]; } } fprintf(stdout, "\"%s\"[%d:%d]:[%d:%s]:%s\n", *argv, token.line, token.column, token.kind, g_token_names[token.kind], trapped); free(str); free(trapped); } } lexer_destroy(lexer); free(buffer); continue; // error gotos ERROR_CLOSE_FREE: free(buffer); ERROR_CLOSE_FILE: fclose(fp); return 1; } return 0; }
/* * Command-line front end for compiler. */ int main(int argc, char **argv) { int action; int arg; buffer_t *in_buffer; buffer_t *out_buffer; int is_done; parser_t *parser; lexer_t *lexer; token_t *token; /* Set default settings. */ action = ACT_TRANS; in_buffer = buffer_create(stdin); out_buffer = buffer_create(stdout); /* Parse command-line arguments. */ for (arg = 1; arg < argc; arg++) { if ((strcmp(argv[arg], "--help") == 0) || (strcmp(argv[arg], "-h") == 0)) { action = ACT_USAGE; } else if ((strcmp(argv[arg], "--lex") == 0) && (action <= ACT_LEX)) { action = ACT_LEX; } else if ((strcmp(argv[arg], "--parse") == 0) && (action <= ACT_PARSE)) { action = ACT_PARSE; } else if ((strcmp(argv[arg], "--translate") == 0) && (action <= ACT_TRANS)) { action = ACT_TRANS; } else { fprintf(stderr, "Invalid argument: %s\n", argv[arg]); /* Stop parsing command-line. */ arg = argc; action = ACT_USAGE; } } /* Take action. */ if (action == ACT_USAGE) { printf( "Usage: compiler [option...]\n" "\n" " Options:\n" "\n" " -h, --help Display this help text.\n" " --lex Run the lexer.\n" " --parse Run the parser. (Calls the lexer.)\n" " --translate Run the translator. (Calls the parser.)\n" ); } else if (action == ACT_LEX) { is_done = 0; lexer = lexer_create(in_buffer); token = token_create(); while (!is_done) { lexer_lex(lexer, token); token_print(token, stdout); printf("\n"); if (token_get_class(token) == T_EOF) is_done = 1; } token_destroy(token); lexer_destroy(lexer); return EXIT_SUCCESS; } else if (action == ACT_PARSE) { parser = parser_create(in_buffer); parser_parse(parser); parser_destroy(parser); return EXIT_SUCCESS; } else if (action == ACT_TRANS) { parser = parser_create(in_buffer); parser_parse(parser); translator_translate(parser_get_tree(parser)); parser_destroy(parser); return EXIT_SUCCESS; } return EXIT_SUCCESS; }
int parse_string (const string_t client_string, list_s lista) { string_t almost_done = NULL; string_t done = NULL; FILE * strf = NULL; int result = CODE_OK; assert (client_string != NULL && lista != NULL); strf = fmemopen (client_string, strlen(client_string) + 1, "r"); if (strf != NULL) { Lexer * l = lexer_new (strf); lexer_next_to (l, "\n"); almost_done = lexer_item (l); if (strncmp (client_string, almost_done, strlen (client_string) - 2) != 0) return BAD_EOL; lexer_destroy (l); fclose (strf); if (strlen (almost_done) > 1 && almost_done != NULL) { strf = fmemopen (almost_done, strlen(almost_done), "r"); if (strf != NULL) { Lexer * j = lexer_new (strf); lexer_next_to (j, "\r"); done = lexer_item (j); lexer_destroy (j); fclose (strf); if (strlen (done) > 1 && done != NULL) { strf = fmemopen (done, strlen(done), "r"); if (strf){ string_t valid_elem = NULL; Lexer * p = lexer_new (strf); while (!lexer_is_off (p)) { lexer_next (p, SUPERALPHANUMERIC); valid_elem = lexer_item (p); list_adjoin_back (lista, valid_elem); lexer_skip (p, BLANK); } lexer_destroy (p); p = NULL; fclose (strf); } else { fprintf (stderr, "fmemopen"); result = INTERNAL_ERROR; } } else { if (done != NULL) result = STRING_VOID; else result = INTERNAL_ERROR; } } else { fprintf (stderr, "fmemopen"); result = INTERNAL_ERROR; } } else { if (almost_done != NULL) result = STRING_VOID; else result = INTERNAL_ERROR; } if(almost_done != NULL) { free (almost_done); almost_done = NULL; } if(done != NULL) { free (done); done = NULL; } } else { fprintf (stderr, "fmemopen"); result = INTERNAL_ERROR; } return result; }