static int svtParserParseInit(svt_parser_t *parser) { if (yylex_init_extra(&parser->yylval, &parser->scanner) != 0){ perror("Can't initialize scanner"); return -1; } yyset_in(parser->input, parser->scanner); parser->cur_tok = -1; parser->cur_obj = NULL; return 0; }
oconfig_item_t *oconfig_parse_fh (FILE *fh) { int status; oconfig_item_t *ret; char file[10]; yyset_in (fh); if (NULL == c_file) { int status; status = snprintf (file, sizeof (file), "<fd#%d>", fileno (fh)); if ((status < 0) || (status >= sizeof (file))) { c_file = "<unknown>"; } else { file[sizeof (file) - 1] = '\0'; c_file = file; } } status = yyparse (); if (status != 0) { fprintf (stderr, "yyparse returned error #%i\n", status); return (NULL); } c_file = NULL; ret = ci_root; ci_root = NULL; yyset_in ((FILE *) 0); return (ret); } /* oconfig_item_t *oconfig_parse_fh */
int Compiler_compileFile(Context* context, FILE* file) { void* scanner; Node* root = 0; yylex_init(&scanner); yyset_in(file, scanner); int res = yyparse(scanner, &root); yylex_destroy(scanner); if (res) return -1; res = Compiler_compileRootNode(context, root); if (root) Node_delete(root); return res; }
int parser_parse(FILE* in, FILE* out) { int result = 0; yyscan_t scanner; if (yylex_init(&scanner)) { result = 1; } else { yyset_in(in, scanner); yyset_out(out, scanner); result = yyparse(scanner, yyparse_callback); yylex_destroy(scanner); } return (result); }
unsigned char parse_and_report(const char *filename) { yyscan_t scanner; FILE *f; unsigned char err = 0; if(filename == NULL || strcmp(filename, "-") == 0) { f = stdin; filename = "stdin"; } else { f = fopen(filename, "r"); if(!f) { perror(filename); return 1; } } yylex_init(&scanner); yyset_in(f, scanner); yyset_extra((void *) filename, scanner); #ifdef DEBUG yyset_debug(1, scanner); #endif if(xml_output) printf("\t<file name=\"%s\">\n", filename); switch(yyparse(scanner)) { case 0: if(!xml_output) printf("%s: valid JSON\n", filename); break; case 1: if(!xml_output) printf("%s: parsing failed\n", filename); err = 1; break; case 2: fprintf(stderr, "Out of memory\n"); exit(1); break; } if(xml_output) printf("\t</file>\n"); yylex_destroy(scanner); if(f != stdin) fclose(f); return err; }
int main(int argc, char *argv[]) { FILE *fp; yyscan_t yyscanner; M1_compiler comp; if (argc <= 1) { fprintf(stderr, "Usage: m1 <file>\n"); exit(EXIT_FAILURE); } fp = fopen(argv[1], "r"); if (fp == NULL) { fprintf(stderr, "Could not open file\n"); exit(EXIT_FAILURE); } /* set up compiler */ init_compiler(&comp); /* set up lexer and parser */ yylex_init(&yyscanner); yyset_extra(&comp, yyscanner); yyset_in(fp, yyscanner); comp.yyscanner = yyscanner; /* yyscanner has a pointer to comp, and vice versa. */ yyparse(yyscanner, &comp); fprintf(stderr, "parsing done\n"); if (comp.errors == 0) { assert(intstack_isempty(comp.breakstack) != 0); assert(intstack_isempty(comp.continuestack) != 0); check(&comp, comp.ast); /* need to finish */ //if (comp.errors == 0) { fprintf(stderr, "generating code...\n"); gencode(&comp, comp.ast); } } fclose(fp); fprintf(stderr, "compilation done\n"); return 0; }
/* Parse a file */ object_type *parse(interp_core_type *interp, FILE *in) { reset(interp); if(!interp->scanner) { create_parser(interp); } yyset_in(in, peek_scanner); if(parse_internal(interp, peek_scanner)) { return 0; } TRACE("\n") return interp->added; }
void iiInit(FILE* file) { yyset_in(file); gint i; for(i=0; i < NUM_TRAC_STATEMENTS; i++) { statementsSucceed[i] = 0; statementsFail[i] = 0; } fileList = NULL; dirList = NULL; timing_init(); ast_init(); var_init(); //groups_init(); }
std::unique_ptr<AstTranslationUnit> ParserDriver::parse(const std::string& filename, FILE* in, SymbolTable& symbolTable, ErrorReport& errorReport, DebugReport& debugReport) { translationUnit = std::make_unique<AstTranslationUnit>( std::unique_ptr<AstProgram>(new AstProgram()), symbolTable, errorReport, debugReport); yyscan_t scanner; scanner_data data; data.yyfilename = filename.c_str(); yylex_init_extra(&data, &scanner); yyset_in(in, scanner); yy::parser parser(*this, scanner); parser.set_debug_level(trace_parsing); parser.parse(); yylex_destroy(scanner); translationUnit->getProgram()->finishParsing(); return std::move(translationUnit); }
__attribute__ ((constructor)) void colorit_load(void) { int new_out; if (fork_count++) return; if (pipe(color_pipe) != 0) { perror("pipe creation failed"); return; } child_pid = fork(); if (!child_pid) { FILE *fd_in = NULL; colorit_data data = { NULL, NULL}; close(color_pipe[1]); if (yylex_init_extra(&data, &data.scaninfo)) { perror("init alloc failed"); exit(1); } yyset_in(fd_in = fdopen(color_pipe[0], "r"), data.scaninfo); data.out = stdout; if (colorit_init(&data, LIBCOLORIT_TERM) != 0) { fprintf(stderr, "Can't init %s\n", LIBCOLORIT_TERM); exit(1); } yyparse(&data); fclose(fd_in); exit(0); } unsetenv("LD_PRELOAD"); close(color_pipe[0]); dup2(color_pipe[1], 1); dup2(color_pipe[1], 2); }
int main(int argc, char *argv[]) { /* process arguments */ handle_opts(argc, argv); /* open files */ vlog("[plppp] opening files\n"); FILE_INPUT = fopen(S_FILE_INPUT,"r"); if (FILE_INPUT == NULL) { err("[plppp] cannot open input file: %s\n", S_FILE_INPUT); } FILE_OUTPUT = fopen(S_FILE_OUTPUT,"w"); if (FILE_OUTPUT == NULL) { err("[plppp] cannot open output file: %s\n", S_FILE_OUTPUT); } yyset_in(FILE_INPUT); /* create our first define */ defines = install_define(defines,"WIRA","brengsek"); log("[plppp] starting preprocessor\n"); yyparse(); /* print the defines */ if (S_DEFINE_OUTPUT != NULL) { vlog("[plppp] printing defines\n"); FILE_DEFINE = fopen(S_DEFINE_OUTPUT, "w"); print_defines(FILE_DEFINE, defines); } fprintf(FILE_OUTPUT, "%s", program); vlog("[plppp] closing files\n"); fclose(FILE_INPUT); fclose(FILE_OUTPUT); log("[plppp] done\n"); return 0; }
void fsqlf_format_file(struct fsqlf_kw_conf *kwall, FILE *fin, FILE *fout) { struct fsqlf_formatter_state f_state; FSQLF_stack_init(&f_state.lexstate_stack, sizeof(int)); FSQLF_stack_init(&f_state.sub_openings, sizeof(pair)); FSQLF_tokque_init(&f_state.tqueue); f_state.currindent = 0; f_state.left_p = 0; f_state.right_p = 0; f_state.kwall = kwall; f_state.bout = (struct FSQLF_out_buffer){NULL, 0, 0}; yyscan_t scanner; yylex_init(&scanner); yyset_in(fin, scanner); yyset_out(fout, scanner); yyset_extra(&f_state, scanner); yylex(scanner); yylex_destroy(scanner); }
ParserStatus FidlParser::parse(const std::string& file, bool debug) { clear(); //std::cout << "Opening file '" << file << "' for parsing\n"; bool ok = open_and_buffer_file(&open_files_, file); if (!ok) { return first_error_; } assert(open_files_.size() == 1); //std::cout << "Initializing lexer.\n"; yylex_init(&lexer_); if (debug) { yyset_debug(1, lexer_); yydebug = 1; } yyset_extra(this, lexer_); yyset_in(current_file_ptr(), lexer_); //std::cout << "Starting parsing of '" << current_file() << "'.\n"; root_node_ = new ast::Root(); yyparse(this, lexer_); //std::cout << "Done parsing '" << current_file() << "'.\n"; yylex_destroy(lexer_); return first_error_; }
void parse_file(FILE* f) { yyscan_t scanner; lexinfo charpos = {0, 0}; int token_type; const char* token; yylex_init_extra(&charpos, &scanner); yyset_in(f, scanner); do { token_type = yylex(scanner); token = yyget_text(scanner); if(random() < 50000) { if(!new_query) printf(" "); new_query = 0; printf("%s", token); } if(!new_query && (random() < 50000)) { printf("\n"); new_query = 1; } } while(token_type != TOK_DONE); yylex_destroy(scanner); }
static void rev_list_file(rev_file *file, analysis_t *out, cvs_master *cm, rev_master *rm) { struct stat buf; yyscan_t scanner; FILE *in; cvs_file *cvs; in = fopen(file->name, "r"); if (!in) { perror(file->name); ++err; return; } if (stat(file->name, &buf) == -1) { fatal_system_error("%s", file->name); } cvs = xcalloc(1, sizeof(cvs_file), __func__); cvs->gen.master_name = file->name; cvs->gen.expand = EXPANDUNSPEC; cvs->export_name = file->rectified; cvs->mode = buf.st_mode; cvs->verbose = verbose; yylex_init(&scanner); yyset_in(in, scanner); yyparse(scanner, cvs); yylex_destroy(scanner); fclose(in); cvs_master_digest(cvs, cm, rm); out->total_revisions = cvs->nversions; out->skew_vulnerable = cvs->skew_vulnerable; out->generator = cvs->gen; cvs_file_free(cvs); }
int main(int argc, char** argv) { int print_t = 0; int print_v = 0; int print_f = 0; int i; int rc; g_type = (char*) malloc(10); symboltable tracking_table = create_symboltable(); flat_symtab var_table = create_flat_symtab(); func_table function_table = create_functable(); if (argc < 2){ printf("usage: scan filename\n"); return -1; } FILE* in = fopen(argv[1], "r"); if (in == NULL){ printf("file not found\n"); return -1; } for(i = 2; i < argc; i++){ if(strcmp(argv[i], "-t") == 0){ print_t = 1; }else if (strcmp(argv[i], "-v") == 0){ print_v = 1; }else if (strcmp(argv[i], "-f") == 0){ print_f = 1; }else { printf("acceptable options are -t, -v and -f\n"); } } // set input source yyset_in(in); // parse input rc = yyparse(); if (rc == 0){ printf("succeeded parsing input.\n"); } else{ printf("--- error --- failed parsing input: error at line %d, abort.\n", lineNumber); return -1; } // build symbol table build_symtab(tracking_table, var_table, function_table, root); if (sym_error != 0){ printf("--- error --- errors found building symboltable, abort. \n"); return -1; } // type check rc = type_check(var_table, function_table, root); if (rc != 0){ printf("--- error --- errors found in type checking, abort.\n"); // return -1; } // print data structures if(print_t == 1) print_ast(root, 0); if(print_v == 1) print_flat_table(var_table); if(print_f == 1) print_func_table(function_table); return 0; }
static PyObject * _psp_module_parse(PyObject *self, PyObject *argv) { PyObject *code; char *filename; char *dir = NULL; char *path; psp_parser_t *parser; yyscan_t scanner; FILE *f; if (!PyArg_ParseTuple(argv, "s|s", &filename, &dir)) { return NULL; } if (dir) { path = malloc(strlen(filename)+strlen(dir)+1); if (!path) return PyErr_NoMemory(); strcpy(path, dir); strcat(path, filename); } else { path = filename; } Py_BEGIN_ALLOW_THREADS f = fopen(path, "rb"); Py_END_ALLOW_THREADS if (f == NULL) { PyErr_SetFromErrnoWithFilename(PyExc_IOError, path); if (dir) free(path); return NULL; } if (dir) free(path); parser = psp_parser_init(); if (dir) parser->dir = dir; yylex_init(&scanner); yyset_in(f, scanner); yyset_extra(parser, scanner); yylex(scanner); yylex_destroy(scanner); fclose(f); psp_string_0(&parser->pycode); if (PyErr_Occurred()) { psp_parser_cleanup(parser); return NULL; } if (parser->pycode.blob) { code = MpBytesOrUnicode_FromString(parser->pycode.blob); } else { code = MpBytesOrUnicode_FromString(""); } psp_parser_cleanup(parser); return code; }
int main(int argc, char *argv[]) { /* process arguments */ handle_opts(argc, argv); /* open files */ vlog("[plpcc] opening files\n"); FILE_INPUT = fopen(S_FILE_INPUT,"r"); if (FILE_INPUT == NULL) { err("[plpcc] cannot open input file: %s\n", S_FILE_INPUT); } FILE_OUTPUT = fopen(S_FILE_OUTPUT,"w"); if (FILE_OUTPUT == NULL) { err("[plpcc] cannot open output file: %s\n", S_FILE_OUTPUT); } yyset_in(FILE_INPUT); if (S_SYMBOL_OUTPUT != NULL) { SYMBOL_OUTPUT = fopen(S_SYMBOL_OUTPUT, "w"); if (SYMBOL_OUTPUT == NULL) { err("[plpcc] cannot open symbol table output file: %s\n", S_SYMBOL_OUTPUT); } } if (S_PARSE_OUTPUT != NULL) { PARSE_OUTPUT = fopen(S_PARSE_OUTPUT, "w"); if (PARSE_OUTPUT == NULL) { err("[plpcc] cannot open parse tree output file: %s\n", S_PARSE_OUTPUT); } } if (S_GRAPH_OUTPUT != NULL) { GRAPH_OUTPUT = fopen(S_GRAPH_OUTPUT, "w"); if (GRAPH_OUTPUT == NULL) { err("[plpcc] cannot open parse tree graph output file: %s\n", S_GRAPH_OUTPUT); } } /* grab the lines from the source for error handling and annotation */ build_lines(S_FILE_INPUT); /* create an empty symbol table */ sym = new_symbol_table(NULL); log("[plpcc] starting frontend\n"); yyparse(); /* print the parse tree */ if (PARSE_OUTPUT != NULL) { vlog("[plpcc] printing parse tree\n"); print_tree(parse_tree_head, PARSE_OUTPUT, 0); } /* print the parse tree graph formatted for Graphviz*/ if (GRAPH_OUTPUT != NULL) { vlog("[plpcc] printing parse tree graph\n"); print_tree_graph(parse_tree_head, GRAPH_OUTPUT, S_FILE_INPUT); /* close output file*/ fclose(GRAPH_OUTPUT); /* Run Graphviz command to generate PNG of parse tree */ S_GRAPH_COMMAND = malloc(sizeof(char) * (strlen(S_FILE_OUTPUT) * 2 + 22)); sprintf(S_GRAPH_COMMAND, "dot -Tpng %s.dot > %s.png", S_FILE_OUTPUT, S_FILE_OUTPUT); system(S_GRAPH_COMMAND); } /* print the symbol table */ if (SYMBOL_OUTPUT != NULL) { vlog("[plpcc] printing symbol table\n"); print_symbols(sym, SYMBOL_OUTPUT, 0); vlog("[plpcc] printing activation records\n"); print_frames(sym, SYMBOL_OUTPUT); } /* call the backend to compile the parse tree, starting from the head */ if (NO_COMPILE == 0) { handle(parse_tree_head); fprintf(FILE_OUTPUT, "%s", program); } vlog("[plpcc] closing files\n"); fclose(FILE_INPUT); fclose(FILE_OUTPUT); log("[plpcc] done\n"); return 0; }
ParseInfo* click_parse_configuration(FILE* input, ClickAllocator alloc, ClickLinker link, void* obj) { ParseInfo* ret = 0; yylex_destroy(); __click_modules = alloc_resource(sizeof(List)); __click_symbol_table = alloc_resource(sizeof(Map)); __click_edges = alloc_resource(sizeof(List)); init_list(__click_modules); init_map(__click_symbol_table); init_list(__click_edges); yyset_in(input); int parse_result = yyparse(); yylex_destroy(); if(parse_result == 0) { int no_modules = __click_modules->len; ret = malloc(sizeof(ParseInfo)); ret->all_modules = malloc(sizeof(void*)*no_modules); ret->root_modules = malloc(sizeof(void*)*no_modules); ret->leaf_modules = malloc(sizeof(void*)*no_modules); ret->no_modules = no_modules; ret->no_root = 0; ret->no_leaf = 0; int k; for(k=0; k<no_modules; k++) { Node* node = (Node*)__click_modules->list[k]; assert(node->type == Node_MODULE); Module* module = (Module*)node->payload; char* module_name = module->name->payload; assert(module->args->type == Node_ARG_LIST); ArgList* arglist = (ArgList*)module->args->payload; char** argv = alloc_resource(sizeof(char*) * (arglist->len + 1)); argv[arglist->len] = 0; int argc = arglist->len; int j; for(j=0; j<arglist->len; j++) { Node* eacharg = (Node*)arglist->list[j]; char* value_str = 0; if(eacharg == NULL) { } else if(eacharg->type == Node_VALUE_LIST) { ValueList* valuelist = (ValueList*)eacharg->payload; value_str = vlist_to_string(valuelist); } else { assert(0); } argv[j] = value_str; } void* user_module = 0; if(alloc) user_module = alloc(k, module_name, argc, argv, obj); ret->all_modules[k] = user_module; } int* inward = alloc_resource(sizeof(int)*no_modules); int* outward = alloc_resource(sizeof(int)*no_modules); for(k=0; k<no_modules; k++) { inward[k] = 0; outward[k] = 0; } for(k=0; k<__click_edges->len; k++) { Chain* edge = (Chain*)__click_edges->list[k]; assert(edge->head->type == Node_MODULE); assert(edge->tail->type == Node_MODULE); Module* head = (Module*)edge->head->payload; Module* tail = (Module*)edge->tail->payload; if(link) link(ret->all_modules[head->index], edge->head_outport, ret->all_modules[tail->index], edge->tail_inport, obj); inward[tail->index]++; outward[head->index]++; } for(k=0; k<no_modules; k++) { if(inward[k] == 0) { ret->root_modules[ret->no_root++] = ret->all_modules[k]; } if(outward[k] == 0) { ret->leaf_modules[ret->no_leaf++] = ret->all_modules[k]; } } } clear_resource(); __click_modules = 0; __click_symbol_table = 0; __click_edges = 0; return ret; }
/*Thread task function for reentrant scanner*/ void *lex_thread_task(void *arg) { lex_thread_arg *ar = (lex_thread_arg*) arg; FILE * f = fopen(ar->file_name, "r"); if (f == NULL) { DEBUG_STDOUT_PRINT("ERROR> Lexing thread %d could not open input file. Aborting.\n", ar->id); exit(1); } lex_token *flex_token; int8_t end_of_chunk = 0; yyscan_t scanner; //reentrant flex instance data int32_t flex_return_code; token_node *token_builder = NULL; token_node_stack stack; sem_value_stack stack_char; sem_value_stack stack_int; uint32_t alloc_size = 0, realloc_size = 0; uint32_t chunk_length = ar->cut_point_dx - ar->cut_point_sx; par_compute_alloc_realloc_size((ar->cut_point_dx - ar->cut_point_sx), &alloc_size, &realloc_size); DEBUG_STDOUT_PRINT("LEXER %d > alloc_size %d, realloc_size %d\n", ar->id, alloc_size, realloc_size) /*Initialization flex_token*/ flex_token = (lex_token*) malloc(sizeof(lex_token)); if (flex_token == NULL) { DEBUG_STDOUT_PRINT("ERROR> could not complete malloc flex_token. Aborting.\n"); exit(1); } flex_token->chunk_length = chunk_length; flex_token->num_chars = 0; flex_token->chunk_ended = 0; //Initialize stack for semantic values. //Since the possible semantic values are only char or int, we can allocate two different stacks, one for each type, avoiding to waste memory. init_sem_value_stack(&stack_char, alloc_size, 0); init_sem_value_stack(&stack_int, alloc_size, 1); flex_token->stack_char = &stack_char; flex_token->stack_int = &stack_int; flex_token->realloc_size = realloc_size; fseek(f, ar->cut_point_sx, SEEK_SET); if(yylex_init_extra(flex_token, &scanner)) { DEBUG_STDOUT_PRINT("ERROR> yylex_init_extra failed.\n") exit(1); } yyset_in(f, scanner); ar->list_begin = NULL; init_token_node_stack(&(stack), alloc_size); flex_return_code = yylex(scanner); /*The procedure to find cut points cannot cut a single token in two parts.*/ while(!end_of_chunk && flex_return_code != __END_OF_CHUNK && flex_return_code != __END_OF_FILE) { if(flex_return_code == __LEX_CORRECT) { //append a token par_append_token_node(flex_token->token, flex_token->semantic_value, &token_builder, &(ar->list_begin), &stack, realloc_size); ar->lex_token_list_length++; } else { //flex_return_code is __ERROR) DEBUG_STDOUT_PRINT("Lexing thread %d scanned erroneous input. Abort.\n", ar->id) ar->result = 1; /*Signal error by returning result!=0.*/ fclose(yyget_in(scanner)); yylex_destroy(scanner); fclose(f); pthread_exit(NULL); } if (flex_token->chunk_ended) end_of_chunk = 1; else { //Continue to scan the chunk flex_return_code = yylex(scanner); } } ar->list_end = token_builder; fclose(yyget_in(scanner)); yylex_destroy(scanner); fclose(f); pthread_exit(NULL); }
char *compilestyle(const char *source, int len, int *len_out) { #if defined(YYDEBUG) && YYDEBUG extern int yydebug; yydebug = 1; #endif CompilerState _state={0,}, *state = &_state; StrReader reader = {source, 0, len}; YYLTYPE yylloc = {0,}; yyscan_t scanner; if (!errorprint) { set_errorprint((void*) stderr, (errorprint_t)fprintf); } state->ma_r = memarena_new(4096); yylex_init(&scanner); yyset_in((FILE*)&reader, scanner); printf("compiling AST tree. . .\n"); if (yyparse(state, &yylloc, scanner)==0) { astnode_print(state->result, 0, stdout, fprintf); } else { //error errorprint(errorarg, "Parse error!\n"); return NULL; } state->index_globals = memarena_malloc(state->ma_r, sizeof(*state->globals)); state->global_indices = memarena_malloc(state->ma_r, sizeof(*state->globals)); state->globals = memarena_malloc(state->ma_r, sizeof(*state->globals)); state->scope = memarena_malloc(state->ma_r, sizeof(*state->scope)); state->builtin_funcs = memarena_malloc(state->ma_r, sizeof(*state->builtin_funcs)); state->funcs = memarena_malloc(state->ma_r, sizeof(*state->funcs)); strhash_init(state->index_globals); strhash_init(state->global_indices); strhash_init(state->globals); strhash_init(state->scope); strhash_init(state->builtin_funcs); strhash_init(state->funcs); state->error = cerror; //set longjump state->jmpbuf = memarena_malloc(state->ma_r, sizeof(jmp_buf)); setjmp(*state->jmpbuf); char *buf = NULL; int len2 = 0; //see if an exception happened if (state->haderror) { errorprint(errorarg, "compilation failed; aborting\n"); } else { setup_builtins(state); transform_ast(state); buf = emit_bytecode(state, &len2); } strhash_release(state->index_globals); strhash_release(state->global_indices); strhash_release(state->globals); strhash_release(state->scope); strhash_release(state->builtin_funcs); strhash_release(state->funcs); yylex_destroy(scanner); memarena_free(state->ma_r); *len_out = len2; return buf; }