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;
}
