int main(int argc, char *argv[]) { if (argc != 2) return -1; FILE *input = NULL; if ((input = fopen(argv[1], "r")) == NULL) { return -1; } // creations tableSymbole = symbole_table_create (); scanner = scanner_create (); // initializations symbole_table_init(tableSymbole); scanner_init(scanner, argv[1], input); compile_init (); // compilation fprintf(stdout, "============== start compilation ==============\n"); yyparse(); fprintf(stdout, "============== end conpilation ==============\n"); // destructions symbole_table_del(tableSymbole); scanner_del(scanner); fclose(input); return 0; }
int main(void) { struct t_scanner scanner; struct t_token *token; int i = 0; if (scanner_init(&scanner, stdin)) { fprintf(stderr, "Failed to initialize scanner\n"); return 1; } do { if ((token = scanner_next(&scanner)) == NULL) { fprintf(stderr, "An error occurred during parsing: errno: %d\n", scanner.error); break; } printf("%s\n", token_format(token)); i++; } while (token->type != TT_EOF && i < 30); scanner_close(&scanner); printf("Done.\n"); return 0; }
void test_eof_bof(void) { const char *b = "test"; scanner_t *s = scanner_init(b); assert(scanner_peek(s) == 't'); assert(scanner_advance(s) == 't'); assert(scanner_advance(s) == 'e'); assert(scanner_peek(s) == 's'); assert(scanner_advance(s) == 's'); assert(scanner_advance(s) == 't'); assert(scanner_peek(s) == 0); assert(scanner_current(s) == 't'); assert(scanner_advance(s) == 0); assert(scanner_advance(s) == 0); assert(scanner_advance(s) == 0); assert(scanner_advance(s) == 0); assert(scanner_current(s) == 0); assert(scanner_backup(s) == 't'); assert(scanner_backup(s) == 's'); assert(scanner_peek(s) == 't'); assert(scanner_backup(s) == 'e'); assert(scanner_backup(s) == 't'); assert(scanner_backup(s) == 0); assert(scanner_current(s) == 0); assert(scanner_peek(s) == 't'); scanner_destroy(s); }
json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap) { scanner_t s; va_list ap_copy; json_t *value; if(!fmt || !*fmt) { jsonp_error_init(error, "<format>"); jsonp_error_set(error, -1, -1, 0, "NULL or empty format string"); return NULL; } jsonp_error_init(error, NULL); scanner_init(&s, error, flags, fmt); next_token(&s); va_copy(ap_copy, ap); value = pack(&s, &ap_copy); va_end(ap_copy); if(!value) return NULL; next_token(&s); if(s.token) { json_decref(value); set_error(&s, "<format>", "Garbage after format string"); return NULL; } return value; }
void test_eof_bof_after_accept(void) { const char *b = "test this"; scanner_t *s = scanner_init(b); assert(scanner_advance(s) == 't'); assert(scanner_advance(s) == 'e'); assert(scanner_advance(s) == 's'); assert(scanner_advance(s) == 't'); assert(scanner_advance(s) == ' '); scanner_ignore(s); assert(scanner_current(s) == 0); assert(scanner_advance(s) == 't'); assert(scanner_advance(s) == 'h'); assert(scanner_advance(s) == 'i'); assert(scanner_advance(s) == 's'); assert(scanner_advance(s) == 0); assert(scanner_advance(s) == 0); assert(scanner_current(s) == 0); assert(scanner_backup(s) == 's'); assert(scanner_backup(s) == 'i'); assert(scanner_backup(s) == 'h'); assert(scanner_backup(s) == 't'); assert(scanner_backup(s) == 0); scanner_destroy(s); }
/* * read_ckb: read a CKB file, parse it and install it. * */ BOOL read_ckb(void) { BOOL retval=FALSE; scanner_init(); /* prepare scanner */ if (raw_read_file(save_vars.loadfile)) { interprete_file(); if (error_counter==0) { /* file is correct, use data */ Ckeytbl(ckb.available.unshift, ckb.available.shift, ckb.available.caps, ckb.available.compose, ckb.tabname ); Cbioskeys(ckb.switches.tablevalid); Compose(ckb.switches.compose); Deadkey(ckb.switches.deadkey, NULL); Deadkey(SET, ckb.deadkeys); Extkey(ckb.switches.extkey); Alt_nnn(ckb.switches.alt_nnn); save_vars.filetype=2; retval=TRUE; } } raw_close_file(); scanner_exit(); /* leave scanner */ return retval; }
/**@brief Function for application main entry. */ int main(void) { uint32_t err_code; bool erase_bonds; // Initialize. timers_init(); buttons_leds_init(&erase_bonds); ble_stack_init(); device_manager_init(erase_bonds); gap_params_init(); advertising_init(); services_init(); sensor_simulator_init(); conn_params_init(); scanner_init(); // Start execution. scanner_start(); application_timers_start(); err_code = ble_advertising_start(BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); // Enter main loop. for (;;) { power_manage(); } }
int main(void) { yy_extra_type yyextra; int res; int fd2; for (int i = 0; i < NTIMES; ++i) { yyscan_t scanner = scanner_init(stdin, &yyextra, ScanKeywords, NumScanKeywords); parser_init(); yyparse(scanner); res = scanner_finish(scanner); if (res < 0) { return(res); } if (fseek(stdin, 0, SEEK_SET) < 0) { return(0); } if (i == 0) { if ((fd2 = open("/dev/null", O_WRONLY)) < 0) { perror("open"); return(-1); } if (dup2(fd2,1) < 0) { perror("dup2"); return(-1); } close(fd2); } } return(0); }
yyscan_t lexer_init(const char* sql) { per_scanner_data *extra; yyscan_t scanner; extra = (per_scanner_data*) calloc(sizeof(per_scanner_data), 1); if (extra == NULL) return NULL; extra->_xcdepth = 0; extra->_dolqstart = NULL; extra->_backslash_quote = BACKSLASH_QUOTE_SAFE_ENCODING; extra->_escape_string_warning = false; extra->_standard_conforming_strings = false; extra->_warn_on_first_escape = false; extra->_saw_high_bit = false; extra->_seen_error = false; extra->_literalbuf = NULL; extra->_literallen = 0; extra->_literalalloc = 0; extra->_scanbufhandle = NULL; extra->_scanbuf = NULL; if (base_yylex_init_extra(extra, &scanner) != 0) { free(extra); return NULL; } scanner_init(sql, scanner); return scanner; }
sdb_llist_t * sdb_parser_parse(const char *query, int len, sdb_strbuf_t *errbuf) { sdb_parser_yyscan_t scanner; sdb_parser_yyextra_t yyextra; sdb_llist_iter_t *iter; int yyres; if (scanner_init(query, len, &scanner, &yyextra, errbuf)) return NULL; yyres = sdb_parser_yyparse(scanner); sdb_parser_scanner_destroy(scanner); if (yyres) { sdb_llist_destroy(yyextra.parsetree); return NULL; } iter = sdb_llist_get_iter(yyextra.parsetree); while (sdb_llist_iter_has_next(iter)) { sdb_ast_node_t *node; node = SDB_AST_NODE(sdb_llist_iter_get_next(iter)); if (sdb_parser_analyze(node, errbuf) < 0) { sdb_llist_iter_destroy(iter); sdb_llist_destroy(yyextra.parsetree); return NULL; } } sdb_llist_iter_destroy(iter); return yyextra.parsetree; } /* sdb_parser_parse */
/* * raw_parser * Given a query in string form, do lexical and grammatical analysis. * * Returns a list of raw (un-analyzed) parse trees. The immediate elements * of the list are always RawStmt nodes. */ List * raw_parser(const char *str) { core_yyscan_t yyscanner; base_yy_extra_type yyextra; int yyresult; /* initialize the flex scanner */ yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords); /* base_yylex() only needs this much initialization */ yyextra.have_lookahead = false; /* initialize the bison parser */ parser_init(&yyextra); /* Parse! */ yyresult = base_yyparse(yyscanner); /* Clean up (release memory) */ scanner_finish(yyscanner); if (yyresult) /* error */ return NIL; return yyextra.parsetree; }
void test_buffer_walk(void) { const char *b = "this is a small test buffer"; scanner_t *s = scanner_init(b); assert(scanner_peek(s) == 't'); assert(scanner_advance(s) == 't'); assert(scanner_advance(s) == 'h'); assert(scanner_advance(s) == 'i'); assert(scanner_advance(s) == 's'); assert(scanner_peek(s) == ' '); assert(scanner_current(s) == 's'); assert(scanner_advance(s) == ' '); assert(scanner_backup(s) == 's'); char *xthis = (char*)scanner_accept(s, (acceptfn)test_accept_fn); assert(strcmp(xthis, "this") == 0); free(xthis); size_t i = 4; char c; while ((c = scanner_advance(s))) assert(c == b[i++]); assert(strlen(b) == i); scanner_destroy(s); }
int cli_init(struct parser_state *_state) { const char *home; rl_readline_name = "nft"; rl_instream = stdin; rl_outstream = stdout; rl_callback_handler_install("nft> ", cli_complete); rl_attempted_completion_function = cli_completion; home = getenv("HOME"); if (home == NULL) home = ""; snprintf(histfile, sizeof(histfile), "%s/%s", home, CMDLINE_HISTFILE); read_history(histfile); history_set_pos(history_length); state = _state; scanner = scanner_init(state); while (!eof) rl_callback_read_char(); return 0; }
XkbFile * XkbParseString(struct xkb_context *ctx, const char *string, size_t len, const char *file_name, const char *map) { struct scanner scanner; scanner_init(&scanner, ctx, string, len, file_name); return parse(ctx, &scanner, map); }
mvc * mvc_create(int clientid, backend_stack stk, int debug, bstream *rs, stream *ws) { int i; mvc *m; m = ZNEW(mvc); if (mvc_debug) fprintf(stderr, "#mvc_create\n"); m->errstr[0] = '\0'; /* if an error exceeds the buffer we don't want garbage at the end */ m->errstr[ERRSIZE-1] = '\0'; m->qc = qc_create(clientid, 0); m->sa = NULL; m->params = NULL; m->sizevars = MAXPARAMS; m->vars = NEW_ARRAY(sql_var, m->sizevars); m->topvars = 0; m->frame = 1; m->use_views = 0; m->argmax = MAXPARAMS; m->args = NEW_ARRAY(atom*,m->argmax); m->argc = 0; m->sym = NULL; m->rowcnt = m->last_id = m->role_id = m->user_id = -1; m->timezone = 0; m->clientid = clientid; m->emode = m_normal; m->emod = mod_none; m->reply_size = 100; m->debug = debug; m->cache = DEFAULT_CACHESIZE; m->caching = m->cache; m->history = 0; m->label = 0; m->cascade_action = NULL; for(i=0;i<MAXSTATS;i++) m->opt_stats[i] = 0; store_lock(); m->session = sql_session_create(stk, 1 /*autocommit on*/); store_unlock(); m->type = Q_PARSE; m->pushdown = 1; m->result_id = 0; m->results = NULL; scanner_init(&m->scanner, rs, ws); return m; }
int ztokenexec(i_ctx_t *i_ctx_p) { os_ptr op = osp; stream *s; scanner_state state; check_read_file(s, op); check_estack(1); scanner_init(&state, op); return tokenexec_continue(i_ctx_p, &state, true); }
void parse_init(void) { expr_init(); scanner_init(); chunkpool_init(s->atom_pool, sizeof(struct atom)); chunkpool_init(s->vec_pool, sizeof(struct vec)); map_init(s->sym_table); named_buffer_init(s->named_buffer); map_init(s->initial_symbols); named_buffer_init(s->initial_named_buffer); }
LUALIB_API int luaopen_yaml (lua_State *L) { parser_init (L); scanner_init (L); luaL_register(L, "yaml", R); lua_pushliteral(L, MYVERSION); lua_setfield(L, -2, "version"); return 1; }
int ztoken(i_ctx_t *i_ctx_p) { os_ptr op = osp; switch (r_type(op)) { default: return_op_typecheck(op); case t_file: { stream *s; scanner_state state; check_read_file(s, op); check_ostack(1); scanner_init(&state, op); return token_continue(i_ctx_p, &state, true); } case t_string: { ref token; /* -1 is to remove the string operand in case of error. */ int orig_ostack_depth = ref_stack_count(&o_stack) - 1; int code; /* Don't pop the operand in case of invalidaccess. */ if (!r_has_attr(op, a_read)) return_error(e_invalidaccess); code = scan_string_token(i_ctx_p, op, &token); switch (code) { case scan_EOF: /* no tokens */ make_false(op); return 0; default: if (code < 0) { /* * Clear anything that may have been left on the ostack, * including the string operand. */ if (orig_ostack_depth < ref_stack_count(&o_stack)) pop(ref_stack_count(&o_stack)- orig_ostack_depth); return code; } } push(2); op[-1] = token; make_true(op); return 0; } } }
/* * pg_parse_string_token - get the value represented by a string literal * * Given the textual form of a SQL string literal, produce the represented * value as a palloc'd string. It is caller's responsibility that the * passed string does represent one single string literal. * * We export this function to avoid having plpgsql depend on internal details * of the core grammar (such as the token code assigned to SCONST). Note * that since the scanner isn't presently re-entrant, this cannot be used * during use of the main parser/scanner. */ char * pg_parse_string_token(const char *token) { int ctoken; scanner_init(token); ctoken = base_yylex(); if (ctoken != SCONST) /* caller error */ elog(ERROR, "expected string constant, got token code %d", ctoken); scanner_finish(); return base_yylval.str; }
/** * * Testovaci modul pre scanner.c */ int main( int argc, char *argv[] ) { if( argc != 2 ) { fprintf( stderr, "Error: No input file specified !\n" ); return E_OTHER; } E_ERROR_TYPE ret_val; char *handle_subor; /**< abstrakcia zdrojoveho handle_suboru */ unsigned file_size; /**< velkost suboru */ ret_val = mmap_file( argv[1], &handle_subor, &file_size ); if ( ret_val != E_OK ) return E_INTERPRET_ERROR; char *subor = handle_subor; if ( check_file_header( &subor ) != E_OK ) // kontrola '<?php ' na zaciatku handle_suboru { fprintf( stderr, "Error: Invalid source file.\n" ); free(handle_subor); return E_SYNTAX; } T_token token; token.ttype = E_INVLD; scanner_init( subor, file_size - 5); // scanner dostava subor o 6 znakov mensi koli '<?php ' printf("---------------------------"); while(token.ttype != E_EOF) { scanner_get_token(&token); print_token(&token); getchar(); } printf("---------------------------\n"); free( handle_subor ); return EXIT_SUCCESS; }
ASTNode *parser_run(Parser *p, FILE *f) { ASTNode *root = NULL; /* create scanner on f */ p->scn = (Scanner*)malloc(sizeof(Scanner)); scanner_init(p->scn, f); /* parse a file */ root = parse_file(p); /* cleanup scanner */ scanner_done(p->scn); free(p->scn); p->scn = NULL; /* done */ return root; }
// ----------------------------------------------------------------------------- hron__parser_state hron__initialize (hron__visitor* visitor ) { secret__parser_state ps; secret__scanner_state * ss; if (!visitor) { return 0; } memset(&ps, 0, sizeof (struct tag__secret__parser_state)); ps.payload = visitor->payload; HRON_COALESCE_EMPTY_METHOD(document__begin); HRON_COALESCE_EMPTY_METHOD(document__end); HRON_COALESCE_STRING_METHOD(preprocessor); HRON_COALESCE_STRING_METHOD(comment); HRON_COALESCE_STRING_METHOD(empty); HRON_COALESCE_STRING_METHOD(object__begin); HRON_COALESCE_EMPTY_METHOD(object__end); HRON_COALESCE_STRING_METHOD(value__begin); HRON_COALESCE_EMPTY_METHOD(value__end); HRON_COALESCE_STRING_METHOD(value__line); HRON_COALESCE_ERROR_METHOD(error); ss = malloc (sizeof(secret__scanner_state)); if (!ss) { return 0; } scanner_init (ss, SS_PreProcessorTag, &ps); ss->parser_state.document__begin (ss->parser_state.payload); return ss; }
/* * raw_parser * Given a query in string form, do lexical and grammatical analysis. * * Returns a list of raw (un-analyzed) parse trees. */ List * raw_parser(const char *str) { int yyresult; parsetree = NIL; /* in case grammar forgets to set it */ have_lookahead = false; scanner_init(str); parser_init(); yyresult = base_yyparse(); scanner_finish(); if (yyresult) /* error */ return NIL; return parsetree; }
int CSP_EXTERNAL csp_parse(uint8_t *prog_buffer, int prog_size) { char lex_buf[CSP_LEX_BUFSIZE]; struct csp_names global, functions, local; struct ragel_lexer_t lex; int res; _csp_clear_error(); gen_init(prog_buffer, prog_size); scanner_init(&lex, lex_buf, CSP_LEX_BUFSIZE); global.idx = 0; global.tail = 0; global.size = CSP_NS_GLOBAL_NAMES_SIZE; global.buf = alloca(global.size); global.buf[0] = 0; functions.idx = env_functions->idx + MACRO_OP_BUILTIN_COUNT; functions.tail = env_functions->tail; functions.size = functions.tail + CSP_NS_FUNCTIONS_NAMES_SIZE; functions.buf = alloca(functions.size); memcpy(functions.buf, env_functions->buf, functions.tail+1); /* copy '\0' char too */ local.idx = 0; local.tail = 0; local.size = CSP_NS_LOCAL_NAMES_SIZE; local.buf = alloca(local.size); local.buf[0] = 0; gen_set_namespaces(&global, &functions, &local); res = yyparse(&lex); if (res == 0) program_finish(); return res; }
sdb_ast_node_t * sdb_parser_parse_conditional(const char *cond, int len, sdb_strbuf_t *errbuf) { sdb_parser_yyscan_t scanner; sdb_parser_yyextra_t yyextra; sdb_ast_node_t *node; int yyres; if (scanner_init(cond, len, &scanner, &yyextra, errbuf)) return NULL; yyextra.mode = SDB_PARSE_COND; yyres = sdb_parser_yyparse(scanner); sdb_parser_scanner_destroy(scanner); if (yyres) { sdb_llist_destroy(yyextra.parsetree); return NULL; } node = SDB_AST_NODE(sdb_llist_get(yyextra.parsetree, 0)); if (! node) { sdb_strbuf_sprintf(errbuf, "Empty conditional expression '%s'", cond); sdb_llist_destroy(yyextra.parsetree); return NULL; } assert(SDB_AST_IS_LOGICAL(node)); sdb_llist_destroy(yyextra.parsetree); if (sdb_parser_analyze_conditional(node, errbuf)) { sdb_object_deref(SDB_OBJ(node)); return NULL; } return node; } /* sdb_parser_parse_conditional */
sdb_ast_node_t * sdb_parser_parse_arith(const char *expr, int len, sdb_strbuf_t *errbuf) { sdb_parser_yyscan_t scanner; sdb_parser_yyextra_t yyextra; sdb_ast_node_t *node; int yyres; if (scanner_init(expr, len, &scanner, &yyextra, errbuf)) return NULL; yyextra.mode = SDB_PARSE_ARITH; yyres = sdb_parser_yyparse(scanner); sdb_parser_scanner_destroy(scanner); if (yyres) { sdb_llist_destroy(yyextra.parsetree); return NULL; } node = SDB_AST_NODE(sdb_llist_get(yyextra.parsetree, 0)); if (! node) { sdb_strbuf_sprintf(errbuf, "Empty expression '%s'", expr); sdb_llist_destroy(yyextra.parsetree); return NULL; } assert(SDB_AST_IS_ARITHMETIC(node)); sdb_llist_destroy(yyextra.parsetree); if (sdb_parser_analyze_arith(node, errbuf)) { sdb_object_deref(SDB_OBJ(node)); return NULL; } return node; } /* sdb_parser_parse_arith */
/* * Called before any actual parsing is done * * Note: the passed "str" must remain valid until plpgsql_scanner_finish(). * Although it is not fed directly to flex, we need the original string * to cite in error messages. */ void plpgsql_scanner_init(const char *str) { /* Start up the core scanner */ yyscanner = scanner_init(str, &core_yy, reserved_keywords, num_reserved_keywords); /* * scanorig points to the original string, which unlike the scanner's * scanbuf won't be modified on-the-fly by flex. Notice that although * yytext points into scanbuf, we rely on being able to apply locations * (offsets from string start) to scanorig as well. */ scanorig = str; /* Other setup */ plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_NORMAL; num_pushbacks = 0; location_lineno_init(); }
/* * raw_parser * Given a query in string form, do lexical and grammatical analysis. * * Returns a list of raw (un-analyzed) parse trees. */ List * raw_parser(const char *str) { char *sqlString; core_yyscan_t yyscanner; base_yy_extra_type yyextra; int yyresult; /* initialize the flex scanner */ yyscanner = scanner_init(str, &yyextra.core_yy_extra, ScanKeywords, NumScanKeywords); /* base_yylex() only needs this much initialization */ yyextra.have_lookahead = false; /* initialize the bison parser */ parser_init(&yyextra); /* Parse! */ yyresult = base_yyparse(yyscanner); /* Clean up (release memory) */ scanner_finish(yyscanner); if (yyresult) /* error */ return NIL; /* elog(WARNING, "Expression Tree: %s", nodeToString((const void *)yyextra.parsetree)); sqlString = toSQL((const void *)yyextra.parsetree); elog(WARNING, "SQL Conversion: %s", sqlString); */ return yyextra.parsetree; }
int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap) { scanner_t s; va_list ap_copy; if(!root) { jsonp_error_init(error, "<root>"); jsonp_error_set(error, -1, -1, 0, "NULL root value"); return -1; } if(!fmt || !*fmt) { jsonp_error_init(error, "<format>"); jsonp_error_set(error, -1, -1, 0, "NULL or empty format string"); return -1; } jsonp_error_init(error, NULL); scanner_init(&s, error, flags, fmt); next_token(&s); va_copy(ap_copy, ap); if(unpack(&s, root, &ap_copy)) { va_end(ap_copy); return -1; } va_end(ap_copy); next_token(&s); if(s.token) { set_error(&s, "<format>", "Garbage after format string"); return -1; } return 0; }