static void parser_test1()
{
parser_t* p = (parser_t*)malloc(sizeof(parser_t));
init_parser(p, "1 2 3 4 5");
assert_int_equal(TT_NUMBER, get_token(p->t));
assert_int_equal(TT_NUMBER, get_token(p->t));
assert_int_equal(TT_NUMBER, get_token(p->t));
assert_int_equal(TT_NUMBER, get_token(p->t));
assert_int_equal(TT_NUMBER, get_token(p->t));
assert_int_equal(TT_EOF, get_token(p->t));
release_parser(p);
free(p);
}
static inline void
close_conn(client_t *cli, picoev_loop* loop)
{
client_t *new_client;
if(!cli->response_closed){
close_response(cli);
}
picoev_del(loop, cli->fd);
clean_cli(cli);
#ifdef DEBUG
printf("start close client:%p fd:%d status_code %d \n", cli, cli->fd, cli->status_code);
printf("picoev_del client:%p fd:%d \n", cli, cli->fd);
printf("remain http pipeline size :%d \n", cli->request_queue->size);
#endif
if(cli->request_queue->size > 0){
if(check_status_code(cli) > 0){
//process pipeline
prepare_call_wsgi(cli);
call_wsgi_app(cli, loop);
}
return ;
}
if(cli->http != NULL){
PyMem_Free(cli->http);
}
free_request_queue(cli->request_queue);
if(!cli->keep_alive){
close(cli->fd);
#ifdef DEBUG
printf("close client:%p fd:%d status_code %d \n", cli, cli->fd, cli->status_code);
#endif
}else{
disable_cork(cli);
new_client = new_client_t(cli->fd, cli->remote_addr, cli->remote_port);
new_client->keep_alive = 1;
init_parser(new_client, server_name, server_port);
picoev_add(main_loop, new_client->fd, PICOEV_READ, keep_alive_timeout, r_callback, (void *)new_client);
}
//PyMem_Free(cli);
dealloc_client(cli);
#ifdef DEBUG
printf("********************\n\n");
#endif
}
struct xmpp_parser* xmpp_parser_new(bool is_stream_start) {
struct xmpp_parser *parser = calloc(1, sizeof(*parser));
check_mem(parser);
parser->parser = XML_ParserCreateNS(NULL, XMPP_PARSER_SEPARATOR);
check(parser->parser != NULL, "Error creating XML parser");
init_parser(parser, is_stream_start);
return parser;
error:
free(parser);
return NULL;
}
static void parser_test2()
{
parser_t* p = (parser_t*)malloc(sizeof(parser_t));
init_parser(p, "def asd() 100+200-600-20 end 100+321-121");
parse(p);
assert_int_equal(1, list_get_item_count(p->ast->statement_list));
statement_t* s = list_get_item(p->ast->statement_list, 0);
expression_t* e = (expression_t*)s->value;
assert_int_equal(300, tester_expr_eval(e));
release_parser(p);
free(p);
}
t_parser *noneof_parser(const char *ign)
{
t_noneof_parser *ret;
char *e;
ret = init_parser(malloc(sizeof(*ret)), match_noneof, delete_noneof);
ret->ign = ft_strdup(ign);
ret->base.size = sizeof(*ret);
e = ft_memalloc(ft_strlen("Expected nothing in `") + ft_strlen(ign) + 2);
ft_strcpy(e, "Expected nothing in `");
ft_strcat(e, ign);
ft_strcat(e, "`");
ret = (void*)exp_p(&ret->base, e);
free(e);
return (&ret->base);
}
F()
{
loop.this_ptr = NULL;
loop.init = NULL;
loop.destroy = NULL;
loop.run = NULL;
loop.add = fake_add;
loop.remove = fake_remove;
init_parser();
state_hashtable_create();
init_peer(&owner_peer, false, &loop);
owner_peer.send_message = send_message;
init_peer(&call_peer, false, &loop);
call_peer.send_message = send_message;
}
int main(int argn, char *argv[]){
int i;
token_t token;
char *cur;
ioparser_state_t pstate = init_parser();
for(i=1; i< argn; i++){
cur = argv[i];
do {
token = scan(cur);
printf("%s %d\n", TOKEN_ASSTRING(token), token.size);
cur += token.size;
parse_token(pstate, &token);
} while (token.type != ERROR && token.type != END);
}
show_ast(stdout, pstate);
return 0;
}
static ERL_NIF_TERM new_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
XML_Parser parser;
expat_parser *parser_data = (expat_parser *)enif_alloc(sizeof(expat_parser));
ERL_NIF_TERM parser_resource;
parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");
parser_data->env = env;
parser_data->xmlns = enif_make_list(env, 0);
init_parser(parser, parser_data);
XML_Parser *xml_parser = (XML_Parser *)enif_alloc_resource(PARSER_POINTER, sizeof(XML_Parser));
*xml_parser = parser;
parser_resource = enif_make_resource(env, (void *)xml_parser);
enif_release_resource(xml_parser);
return enif_make_tuple(env, 2, OK, parser_resource);
};
cell_t *sexp_parse(secd_t *secd, cell_t *port) {
cell_t *prevport = SECD_NIL;
if (not_nil(port)) {
assert(cell_type(port) == CELL_PORT, "sexp_parse: not a port");
prevport = secd->input_port; // share_cell, drop_cell
secd->input_port = share_cell(secd, port);
}
secd_parser_t p;
init_parser(secd, &p);
cell_t *res = sexp_read(secd, &p);
if (not_nil(prevport)) {
secd->input_port = prevport; //share_cell back
drop_cell(secd, port);
}
return res;
}
Tokenstream * parse_file(const char *path_xml, const char *path_tokens, int n_threads)
{
char ** chunks;
chunker_init(path_xml);
chunker_load_file_content();
chunks = chunker_compute_chunks(&n_threads);
Tokenstream * t_streams = malloc(n_threads * sizeof(Tokenstream));
for(int i = 0; i < n_threads; ++i)
{
create_tokenstream(t_streams + i, (1024) / sizeof(Token)); //1KB per tokenstream
if(i != n_threads -1)
{
t_streams[i].next = &t_streams[i+1];
}
}
Map * map = alloc_map(path_tokens);
// print_map(map);
int tid;
Parser * parser;
#pragma omp parallel num_threads(n_threads) firstprivate(map,chunks) private(tid, parser)
{
tid = omp_get_thread_num() % n_threads;
// tid = 0;
char * chunk_begin, * chunk_end;
chunk_begin = chunks[tid];
chunk_end = chunks[tid + 1];
parser = alloc_parser(chunk_begin, chunk_end);
init_parser(parser, map);
Tokenstream * ts = t_streams + tid;
Token * current = get_new_token_pointer(&ts);
while(get_next_token(parser, current) == 1)
{
current = get_new_token_pointer(&ts);
}
free(parser);
}
free(chunks);
destroy_map(map);
return t_streams;
}
static ERL_NIF_TERM reset_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
XML_Parser **parser;
assert(argc == 1);
if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
return enif_make_badarg(env);
expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
parser_data->result = enif_make_list(env, 0);
parser_data->xmlns = (ERL_NIF_TERM)NULL;
parser_data->env = env;
assert(XML_TRUE == XML_ParserReset((XML_Parser)(*parser), "UTF-8"));
init_parser((XML_Parser)(*parser), parser_data);
return OK;
};
cell_t *sexp_lexeme(secd_t *secd, int line, int pos, int prevchar) {
cell_t *result;
secd_parser_t p;
init_parser(secd, &p);
p.line = line;
p.pos = pos;
p.lc = prevchar;
lexnext(&p);
switch (p.token) {
case TOK_EOF:
return new_symbol(secd, EOF_OBJ);
case TOK_SYM:
result = new_lexeme(secd, "sym", new_symbol(secd, p.symtok));
break;
case TOK_NUM:
result = new_lexeme(secd, "int", new_number(secd, p.numtok));
break;
case TOK_STR:
result = new_lexeme(secd, "str", new_string(secd, strmem(p.strtok)));
drop_cell(secd, p.strtok);
break;
case TOK_CHAR:
result = new_lexeme(secd, "char", new_char(secd, p.numtok));
break;
case TOK_QUOTE: case TOK_QQ:
case TOK_UQ: case TOK_UQSPL:
result = new_lexeme(secd, special_form_for(p.token), SECD_NIL);
break;
case TOK_ERR:
result = new_lexeme(secd, "syntax error", SECD_NIL);
break;
default:
result = new_lexeme(secd, "token", new_char(secd, p.token));
}
cell_t *pcharc = new_cons(secd, new_char(secd, p.lc), result);
cell_t *posc = new_cons(secd, new_number(secd, p.pos), pcharc);
cell_t *linec = new_cons(secd, new_number(secd, p.line), posc);
return linec;
}
static void
accept_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
{
int client_fd;
client_t *client;
struct sockaddr_in client_addr;
if ((events & PICOEV_TIMEOUT) != 0) {
// time out
// next turn or other process
return;
}else if ((events & PICOEV_READ) != 0) {
socklen_t client_len = sizeof(client_addr);
#ifdef linux
client_fd = accept4(fd, (struct sockaddr *)&client_addr, &client_len, SOCK_NONBLOCK | SOCK_CLOEXEC);
#else
client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
#endif
if (client_fd != -1) {
#ifdef DEBUG
printf("accept fd %d \n", client_fd);
#endif
setup_sock(client_fd);
client = new_client_t(client_fd, client_addr);
client->environ = Qnil;
rb_gc_register_address(&client->environ);
init_parser(client, server_name, server_port);
picoev_add(loop, client_fd, PICOEV_READ, READ_LONG_TIMEOUT_SECS, r_callback, (void *)client);
}else{
if (errno != EAGAIN && errno != EWOULDBLOCK) {
// TODO:
// raise exception from errno
/* rb_raise(); */
/* write_error_log(__FILE__, __LINE__); */
// die
loop_done = 0;
}
}
}
}
t_obj_data *obj_parse(const char *file_path)
{
FILE *fp;
char line[BUFF_SIZE];
t_obj_data *data;
if (!(fp = fopen(file_path, "r"))
|| !(data = malloc(sizeof(t_obj_data)))
|| !init_parser(data))
return (NULL);
while (fgets(line, BUFF_SIZE, fp) != NULL && ++g_current_line)
{
if (line[0] == '\n')
continue ;
if (!parse_line(line))
return (NULL);
}
fclose(fp);
return (data);
}
int main(int argc, char** argv) {
init_parser();
/* initialize environment */
lenv* e = lenv_new();
lenv_add_builtins(e);
/* load standard library functions */
lval* x = builtin_load(e, lval_add(lval_sexpr(), lval_str("prelude.lsp")));
if (x->type == LVAL_ERR) { lval_println(x); }
lval_del(x);
if (argc >= 2) {
/* read from command line */
parse_args(e, argc, argv);
} else {
/* interactive prompt */
say_hello();
while (1) {
char* input = prompt();
lval* x = parse(input);
if (x != NULL) {
x = lval_eval(e, x);
lval_println(x);
lval_del(x);
}
free(input);
}
}
/* cleanup */
lenv_del(e);
free_parser();
return 0;
}
int main(int argc, char **argv)
{
uint8_t input[102400];
size_t inputsize;
const HParseResult *result;
init_parser();
inputsize = fread(input, 1, sizeof(input), stdin);
fprintf(stderr, "inputsize=%lu\ninput=", inputsize);
fwrite(input, 1, inputsize, stderr);
result = h_parse(document, input, inputsize);
if(result) {
fprintf(stderr, "parsed=%lld bytes\n", result->bit_length/8);
h_pprint(stdout, result->ast, 0, 0);
return 0;
} else {
return 1;
}
}
void accept_char(char ch)
{
if (parser_initialized==0) {
/* Looks like we forgot to initialize the parser.
Do it now.
*/
if (init_parser()!=0) return; //Failed!
}
#ifdef ECHO_GPS
putchar(ch); // For debugging...
#endif
if (ch == IGNORE_CHAR) {
// fprintf(stderr, "Skipping\n");
return; // Ignore it!
}
if (ch == ACCEPT_CHAR) { // Insert a '\r' first
nmeap_parse(&nmea, '\r');
}
nmeap_parse(&nmea, ch);
}
/*
** Get all tetriminos from dir tetriminos
*/
int initialize_files(t_list *list, t_tetris *game)
{
int count;
t_files file;
t_parser parser;
count = 0;
init_parser(&parser);
if ((file.dir = opendir("./tetriminos/")) == NULL)
exit_tetris("Error with opendir", -1);
while ((file.dirent = readdir(file.dir)))
{
if (file.dirent->d_type == DT_REG)
{
if (initialize_parser(&file, &parser, list, game))
count++;
free(file.link);
close(file.fd);
}
}
closedir(file.dir);
return ((count != 0) ? (1) : (0));
}
/**
* parse_buf - Parse a text buffer for cheats.
* @list: list to add cheats to
* @buf: buffer holding text (must be NUL-terminated!)
* @return: 0: success, -1: error
*/
int parse_buf(gamelist_t *list, const char *buf)
{
parser_ctx_t ctx;
char line[LINE_MAX + 1];
int nl = 1;
if (list == NULL || buf == NULL)
return -1;
init_parser(&ctx);
while (*buf) {
/* Scanner */
int len = chr_idx(buf, LF);
if (len < 0)
len = strlen(line);
else if (len > LINE_MAX)
len = LINE_MAX;
if (!is_empty_substr(buf, len)) {
strncpy(line, buf, len);
line[len] = NUL;
/* Screener */
term_str(line, is_cmt_str);
trim_str(line);
/* Parser */
if (strlen(line) > 0 && parse_line(line, nl, &ctx, list) < 0)
return -1;
}
nl++;
buf += len + 1;
}
return 0;
}
static int
exmpp_xml_control(ErlDrvData drv_data, unsigned int command,
char *buf, int len, char **rbuf, int rlen)
{
struct exmpp_xml_data *edd;
ei_x_buff *to_return;
ErlDrvBinary *bin;
int size, ret;
edd = (struct exmpp_xml_data *)drv_data;
size = 0;
bin = NULL;
to_return = NULL;
switch (command) {
/*
* Parsing.
*/
case COMMAND_PARSE:
case COMMAND_PARSE_FINAL:
if (edd->parser == NULL) {
/* Start a parser. */
if (create_parser(edd) != 0) {
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_atom(to_return,
"parser_setup_failed");
break;
}
}
/* Control the total size of data to parse. */
if (!is_data_size_under_limit(&edd->ctx, len)) {
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_atom(to_return, "stanza_too_big");
break;
}
/* Run XML document parsing. */
ret = XML_Parse(edd->parser, buf, len,
command == COMMAND_PARSE_FINAL);
if (!ret) {
enum XML_Error errcode;
const char *errmsg;
/* An error occured during parsing; most probably,
* XML wasn't well-formed. */
errcode = XML_GetErrorCode(edd->parser);
errmsg = XML_ErrorString(errcode);
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_ERROR;
ei_x_encode_tuple_header(to_return, 2);
ei_x_encode_atom(to_return, "parsing_failed");
ei_x_encode_tuple_header(to_return, 2);
ei_x_encode_long(to_return, errcode);
ei_x_encode_string(to_return, errmsg);
break;
}
/* Return the complete tree(s). */
ret = RET_OK;
if (edd->ctx.complete_trees_ready) {
/* Terminate the complete trees list. */
ei_x_encode_empty_list(edd->ctx.complete_trees);
to_return = edd->ctx.complete_trees;
size = 1 + to_return->index;
bin = driver_alloc_binary(size);
if (bin == NULL)
return (-1);
bin->orig_bytes[0] = (char)ret;
memcpy(bin->orig_bytes + 1,
to_return->buff, to_return->index);
} else {
/* We need more data to produce a tree. */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ei_x_encode_atom(to_return,
command == COMMAND_PARSE ? "continue" : "done");
}
if (command == COMMAND_PARSE) {
/* Update the size of processed data. */
add_data_size(&edd->ctx, len);
/* Reset the complete trees list. */
reset_complete_trees(&edd->ctx);
} else {
/* We're done with the parser. */
destroy_parser(edd);
}
break;
case COMMAND_RESET_PARSER:
if (edd->parser != NULL) {
reset_context(&edd->ctx);
XML_ParserReset(edd->parser, "UTF-8");
init_parser(edd);
}
ret = RET_OK;
break;
/*
* Misc.
*/
case COMMAND_PORT_REVISION:
/* Store the revision in the buffer. */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = RET_OK;
ei_x_encode_string(to_return, "$Revision$");
break;
default:
/* Other commands are handled in 'exmpp_xml.c' */
to_return = exmpp_new_xbuf();
if (to_return == NULL)
return (-1);
ret = control(&edd->ctx, command, buf, to_return);
if (ret < 0)
return (-1);
}
if (bin == NULL) {
if (to_return != NULL) {
size = 1 + to_return->index;
bin = driver_alloc_binary(size);
if (bin == NULL)
return (-1);
bin->orig_bytes[0] = (char)ret;
if (to_return->index > 0)
memcpy(bin->orig_bytes + 1,
to_return->buff, to_return->index);
exmpp_free_xbuf(to_return);
} else {
/* The command called doesn't return anything. */
size = 1;
bin = driver_alloc_binary(size);
bin->orig_bytes[0] = RET_OK;
}
}
/* Set the returned buffer. */
*rbuf = (char *)bin;
/* Return the size of this buffer. */
return (size);
}
int main(int argc, char *argv[]) {
char *filename;
int32_t code;
double time, mem_used;
if (argc > 2) {
fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
exit(YICES_EXIT_USAGE);
}
if (argc == 2) {
// read from file
interactive = false;
filename = argv[1];
if (init_smt2_file_lexer(&lexer, filename) < 0) {
perror(filename);
exit(YICES_EXIT_FILE_NOT_FOUND);
}
} else {
// read from stdin
interactive = true;
init_smt2_stdin_lexer(&lexer);
}
yices_init();
init_smt2(true, 0, interactive);
init_smt2_tstack(&stack);
init_parser(&parser, &lexer, &stack);
// disable SMT2_CHECK_SAT/PUSH/POP/GET_VALUE
tstack_add_op(&stack, SMT2_CHECK_SAT, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_PUSH, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_POP, false, eval_smt2_skip, check_smt2_skip);
tstack_add_op(&stack, SMT2_GET_VALUE, false, eval_smt2_skip, check_smt2_skip);
// smt2_set_verbosity(100);
while (smt2_active()) {
if (interactive) {
fputs("smt2> ", stdout);
fflush(stdout);
}
code = parse_smt2_command(&parser);
if (code < 0) {
// syntax error
if (interactive) {
flush_lexer(&lexer);
} else {
break; // exit
}
}
fflush(stdout);
}
// statistics
time = get_cpu_time();
mem_used = mem_size() / (1024 * 1024);
printf("\nRun time: %.4f s\n", time);
printf("Memory used: %.2f MB\n\n", mem_used);
fflush(stdout);
delete_parser(&parser);
close_lexer(&lexer);
delete_tstack(&stack);
delete_smt2();
yices_exit();
return YICES_EXIT_SUCCESS;
}
void realmain(int argc, char **argv)
{
char b[256];
struct stat statbuf;
/* vars from oldmain */
buffer *buf = NULL;
char path[1024];
int i;
setlocale(LC_NUMERIC, "C");
common_init("Egon Animator %s. No Warranty");
sprintf(b, "%s/%ld", siag_basedir, (long)getpid());
mkdir(b, 0700);
sprintf(b, "%s/egon.scm", siag_basedir);
egonrc = MwStrdup(b);
init_interpreters();
siod_interpreter = init_parser(argc, argv);
init_python_parser();
init_guile_parser();
init_ruby_parser();
waitforchild(0);
init_position();
init_cmds();
buf = new_buffer("noname.egon", "noname.egon");
sprintf(path, "%s/egon/egon.scm", datadir);
if (stat(path, &statbuf)) {
fprintf(stderr, "Can't find the runtime library (egon.scm).\n");
fprintf(stderr, "Expected it in %s\n", path);
fprintf(stderr, "SIAGHOME (if set) is '%s'\n", datadir);
fprintf(stderr, "Please read installation instructions.\n");
exit(EXIT_FAILURE);
}
setvar(cintern("libdir"), strcons(-1, libdir), NIL);
setvar(cintern("datadir"), strcons(-1, datadir), NIL);
setvar(cintern("docdir"), strcons(-1, docdir), NIL);
/* load runtime library */
sprintf(b, "(load \"%s/egon/egon.scm\")", datadir);
execute(b);
init_windows(buf, &argc, argv);
setlocale(LC_NUMERIC, "C"); /* possibly hosed by X */
/* load user customizations, if any */
if (!stat(egonrc, &statbuf)) {
sprintf(b, "(load \"%s\")", egonrc);
execute(b);
}
execute("(init-windows)");
execute("(create-menus)");
fileio_init();
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
strcpy(path, argv[i]);
free_buffer(w_list->buf);
buf = new_buffer(buffer_name(argv[i]), path);
loadmatrix(path, buf, guess_file_format(path));
buf->change = FALSE;
w_list->buf = buf;
}
}
pr_scr_flag = TRUE;
execute("(popup-editor)");
/* this works, for reasons beyond my comprehension */
execute("(print-version)");
execute("(print-version)");
activate_window(w_list);
#ifdef HAVE_LIBTCL
Tcl_Main(argc, argv, Tcl_AppInit);
#else
mainloop();
#endif
}
int main(int argc, char **argv)
{
struct cmdline_config config = {
.run_foreground = false,
.bind_local_only = false,
.user_name = NULL,
.passwd_file = NULL,
.request_target = "/api/jet/",
};
init_parser();
int c;
while ((c = getopt (argc, argv, "flp:r:u:")) != -1) {
switch (c) {
case 'f':
config.run_foreground = true;
break;
case 'l':
config.bind_local_only = true;
break;
case 'p':
config.passwd_file = optarg;
break;
case 'r':
config.request_target = optarg;
break;
case 'u':
config.user_name = optarg;
break;
case '?':
fprintf(stderr, "Usage: %s [-l] [-f] [-r <request target>] [-u <username>] [-p <password file>]\n", argv[0]);
return EXIT_FAILURE;
break;
}
}
if (load_passwd_data(config.passwd_file) < 0) {
log_err("Cannot load password file!\n");
return EXIT_FAILURE;
}
signal(SIGPIPE, SIG_IGN);
int ret = EXIT_SUCCESS;
if ((state_hashtable_create()) == -1) {
log_err("Cannot allocate hashtable for states!\n");
ret = EXIT_FAILURE;
goto state_hashtable_create_failed;
}
struct eventloop_epoll eloop = {
.epoll_fd = 0,
.loop = {
.this_ptr = &eloop,
.init = eventloop_epoll_init,
.destroy = eventloop_epoll_destroy,
.run = eventloop_epoll_run,
.add = eventloop_epoll_add,
.remove = eventloop_epoll_remove,
},
};
log_info("%s version %s started", CJET_NAME, CJET_VERSION);
if (run_io(&eloop.loop, &config) < 0) {
ret = EXIT_FAILURE;
goto run_io_failed;
}
log_info("%s stopped", CJET_NAME);
run_io_failed:
state_hashtable_delete();
state_hashtable_create_failed:
free_passwd_data();
return ret;
}
int main(
int argc,
char ** argv)
{
char *tmp;
char *profile_pathname = 0;
BOOLEAN using_stdin = false;
exit_values_ty exit_status;
#if defined (HAVE_SETLOCALE)
setlocale(LC_ALL, "");
#endif
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
#if defined (_WIN32) && !defined (__CYGWIN__)
/* wildcard expansion of commandline arguments, see wildexp.c */
extern void wildexp(int *argc, char ***argv);
wildexp(&argc, &argv);
#endif /* defined (_WIN32) && !defined (__CYGWIN__) */
#ifdef DEBUG
if (debug)
{
debug_init();
}
#endif
/* 'size_t', 'wchar_t' and 'ptrdiff_t' are guarenteed to be
* available in ANSI C.
*
* These pointers will be freed in cleanup_user_specials().
*/
tmp = xmalloc(7);
memcpy(tmp, "size_t", 7);
addkey(tmp, rw_decl);
tmp = xmalloc(8);
memcpy(tmp, "wchar_t", 8);
addkey(tmp, rw_decl);
tmp = xmalloc(10);
memcpy(tmp, "ptrdiff_t", 10);
addkey(tmp, rw_decl);
init_parser ();
initialize_backups ();
exit_status = total_success;
input_files = 0;
in_file_names = (char **) xmalloc(max_input_files * sizeof (char *));
set_defaults();
profile_pathname = handle_profile(argc, argv);
exit_status = process_args(argc, argv, &using_stdin);
if (exit_status == total_success)
{
if (settings.verbose && profile_pathname)
{
fprintf (stderr, _("Read profile %s\n"), profile_pathname);
}
set_defaults_after();
exit_status = indent_all(using_stdin);
}
if (profile_pathname)
xfree(profile_pathname);
xfree(in_file_names);
uninit_parser();
cleanup_user_specials();
return exit_status;
}
int
main(int argc, char **argv)
{
int /*ch, */ i, ii, ret, err_flag = 0;
clock_t beg, end, Beg, End;
int files = 0;
struct tms ts;
char buf[256];
char *e;
prgname = strrchr(argv[0], '/');
if (prgname)
prgname++;
else
prgname = argv[0];
e = getenv("CLIP_HOSTCS");
if (e && *e)
{
sourceCharset = targetCharset = strdup(e);
}
else if (!e)
{
e = getenv("CLIP_LANG");
if (e == NULL)
e = getenv("LANG");
if (!e || !*e || !strcmp(e, "C"))
e = getenv("LC_MESSAGES");
if (!e || !*e || !strcmp(e, "C"))
e = getenv("LC_ALL");
if (e && *e)
{
char *s = strrchr(e, '.');
if (s)
{
snprintf(buf, sizeof(buf), "%s", s + 1);
for (s = buf; *s; s++)
*s = tolower(*s);
sourceCharset = targetCharset = strdup(buf);
}
}
}
{
e = getenv("CLIP_LANG");
if (e == NULL)
e = getenv("LANG");
if (!e || !*e || !strcmp(e, "C"))
e = getenv("LC_MESSAGES");
if (!e || !*e || !strcmp(e, "C"))
e = getenv("LC_ALL");
if (e && *e)
{
char *s = strrchr(e, '.');
if (s)
{
snprintf(buf, sizeof(buf), "%s", s + 1);
for (s = buf; *s; s++)
*s = tolower(*s);
out_charset = strdup(buf);
}
}
}
{
char *locale;
locale = getenv("CLIP_LANG");
if (!locale || !*locale)
locale = getenv("LANG");
/*if (locale && *locale &&
strcasecmp(locale, "C") && strcasecmp(locale, "POSIX")) */
/*
setlocale(LC_ALL, locale);
*/
}
if (!sourceCharset)
sourceCharset = targetCharset = strdup("c");
getEnvironment();
init_Coll(&includePaths, NULL, NULL);
init_Coll(&lib_dirs, NULL, NULL);
init_Coll(&arglibs, NULL, NULL);
#if 1
insert_Coll(&includePaths, ".");
snprintf(buf, sizeof(buf), "%s/include", CLIPROOT);
insert_Coll(&includePaths, strdup(buf));
#ifdef STD_LIBDIR
snprintf(buf, sizeof(buf), STD_LIB_DIR);
insert_Coll(&lib_dirs, strdup(buf));
#endif
snprintf(buf, sizeof(buf), "%s/lib", CLIPROOT);
insert_Coll(&lib_dirs, strdup(buf));
#endif
init_Coll(&predefines, NULL, NULL);
init_Coll(&poName, NULL, NULL);
init_Coll(&paName, NULL, NULL);
init_Coll(&include_files, NULL, NULL);
snprintf(buf, sizeof(buf), "__CLIP__=\"%s\"", CLIP_VERSION);
append_Coll(&predefines, strdup(buf));
init_module();
{
char buf[256], *s;
s = getenv("HOME");
if (s && *s)
{
snprintf(buf, sizeof(buf), "%s/.cliprc", s);
getrc(buf);
}
}
getrc(".cliprc");
{
char buf[256], *s;
DIR *dp;
s = CLIPROOT;
if (s && *s)
{
snprintf(buf, sizeof(buf), "%s/.cliprc", s);
getrc(buf);
}
snprintf(buf, sizeof(buf), "%s/cliprc", CLIPROOT);
dp = opendir(buf);
if (dp)
{
struct dirent *ep;
struct stat st;
Coll files;
int i;
init_Coll(&files, free, strcmp);
while ((ep = readdir(dp)))
{
snprintf(buf, sizeof(buf), "%s/cliprc/%s", CLIPROOT, ep->d_name);
if (stat(buf, &st))
continue;
if (!S_ISREG(st.st_mode))
continue;
if (access(buf, R_OK))
continue;
insert_Coll(&files, strdup(buf));
}
closedir(dp);
for (i = 0; i < files.count_of_Coll; i++)
{
char *name = (char *) files.items_of_Coll[i];
getrc(name);
}
destroy_Coll(&files);
}
}
argc--;
argv++;
get_opt(argc, argv);
argc -= optind;
argv += optind;
if (err_flag)
return 1;
#if 0
insert_Coll(&includePaths, ".");
snprintf(buf, sizeof(buf), "%s/include", CLIPROOT);
insert_Coll(&includePaths, strdup(buf));
#ifdef STD_LIBDIR
snprintf(buf, sizeof(buf), STD_LIBDIR);
insert_Coll(&lib_dirs, strdup(buf));
#endif
snprintf(buf, sizeof(buf), "%s/lib", CLIPROOT);
insert_Coll(&lib_dirs, strdup(buf));
#endif
if (syntax_tree_flag)
{
write_obj_flag = 0;
codegen_flag = 1;
compile_flag = 0;
pcode_flag = 0;
pc_flag = 0;
asm_flag = 0;
exec_flag = 0;
}
if (!write_obj_flag)
{
/*codegen_flag = 0; */
compile_flag = 0;
}
if (preproc_flag)
{
write_obj_flag = 0;
codegen_flag = 0;
syntax_tree_flag = 0;
compile_flag = 0;
exec_flag = 0;
pcode_flag = 0;
pc_flag = 0;
asm_flag = 0;
shared_flag = 0;
}
if (pcode_flag)
{
pc_flag = 0;
asm_flag = 0;
shared_flag = 0;
}
if (pc_flag)
{
pcode_flag = 1;
#ifdef USE_AS
if (use_asm)
asm_flag = 1;
else
asm_flag = 0;
#endif
}
if (xpc_flag)
{
pcode_flag = 1;
pc_flag = 1;
#ifdef USE_AS
if (use_asm)
asm_flag = 0;
else
asm_flag = 1;
#endif
}
#if 0
if (shared_flag && pcode_flag)
{
v_printf(0, "conflict between -s and -p flags\n");
exit(1);
}
#endif
if (pcode_flag && c_flag)
{
v_printf(0, "conflict between -c and -p flags\n");
exit(1);
}
/*if ( exec_flag && !main_flag && !shared_flag)
{
v_printf(0, "-e(xec) flag without -M(ain) or -s(hared) flags\n");
exit(2);
} */
if (pcode_flag)
{
compile_flag = 0;
}
if (nomain_flag && main_flag)
{
v_printf(0, "conflict between -n and -m flags\n");
exit(1);
}
if (!exec_flag && oname)
{
char *e;
if (oname[0] == '/')
snprintf(buf, sizeof(buf), "%s", oname);
else
snprintf(buf, sizeof(buf), "%s%s%s", outdir ? outdir : "", outdir ? "/" : "", oname);
e = strrchr(buf, '/');
if (e)
{
*e = 0;
outdir = strdup(buf);
}
}
if (!outdir)
outdir = ".";
if (outdir)
{
char cdir[256];
getcwd(cdir, sizeof(cdir));
if (!chdir(outdir))
{
getcwd(buf, sizeof(buf));
outdir = strdup(buf);
chdir(cdir);
}
else
{
yyerror("cannot change to output dir '%s': %s", outdir, strerror(errno));
exit(1);
}
}
if (!preproc_flag)
{
v_printf(2, "set source charset to %s\n", sourceCharset);
v_printf(2, "set target charset to %s\n", targetCharset);
}
init_lex();
init_parser();
if (argc < 1)
ii = -1;
else
ii = 0;
Beg = times(&ts);
if (argc > 0)
{
for (i = 0; i < argc; i++)
{
char *e;
e = argv[i];
if (e[0] == '-' && e[1] == 'L')
{
insert_Coll(&lib_dirs, strdup(e + 2));
continue;
}
e = strrchr(argv[i], '.');
if (!e)
{
e = argv[i];
if (e[0] == '-' && e[1] == 'l')
/*append_Coll(&arglibs, strdup(e+2)) */ ;
else
yyerror("unknown file type '' file '%s'", argv[i]);
continue;
}
else if (!strcasecmp(e, ".po"))
insert_Coll(&poName, strdup(argv[i]));
else if (!strcasecmp(e, ".pa"))
insert_Coll(&paName, strdup(argv[i]));
else if (strcasecmp(e, ".prg") && strcasecmp(e, ".c") && strcasecmp(e, ".cc") && strcasecmp(e, OBJSUF) && strcasecmp(e, SOBJSUF) && strcasecmp(e, ".a") && strcasecmp(e, ".lib"))
{
/*yywarning("unknown file type '%s' file '%s'", e, argv[i]); */
continue;
}
}
}
for (; clic_errorcount == 0 && ii < argc; ii++)
{
++files;
if (ii < 0)
{
v_printf(1, "no input files, so use stdin; -h will help\n");
fflush(stderr);
set_locale_name("stdin");
ret = clic_parse("stdin", stdin);
add_name("stdin");
}
else
{
char *e;
e = strrchr(argv[ii], '.');
add_name(argv[ii]);
if (!e)
continue;
else if (!strcasecmp(e, ".c") || !strcasecmp(e, ".cc") || !strcasecmp(e, ".cpp"))
{
if (!preproc_flag)
{
v_printf(1, "process file '%s' ..", argv[ii]);
v_neednl = 1;
}
beg = times(&ts);
compile_CFile(argv[ii]);
end = times(&ts);
if (!preproc_flag)
{
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
}
continue;
}
else if (strcasecmp(e, ".prg"))
{
continue;
}
if (ii > 0)
main_flag = 0;
if (!preproc_flag)
{
v_printf(1, "parsing file '%s' ..", argv[ii]);
v_neednl = 1;
}
beg = times(&ts);
set_locale_name(argv[ii]);
ret = clic_parse(argv[ii], 0);
end = times(&ts);
if (!preproc_flag)
{
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done (%d/%d %s, %d %s, %s)\n",
clic_line, all_lines, _clic_ngettext("line", "lines", clic_line), clic_warncount, _clic_ngettext("warning", "warnings", clic_warncount), diff_clock(beg, end));
else
vr_printf(1, "%d %s, %d %s\n", clic_errorcount, _clic_ngettext("error", "errors", clic_errorcount), clic_warncount, _clic_ngettext("warning", "warnings", clic_warncount));
}
}
if (ret)
break;
if (clic_errorcount == 0 && codegen_flag)
{
v_printf(2, "codegen file '%s' ..", curFile->name_of_File);
v_neednl = 1;
beg = times(&ts);
codegen_File(curFile);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(2, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(2);
}
if (clic_errorcount == 0 && syntax_tree_flag)
{
print_File(curFile);
}
if (clic_errorcount == 0 && write_obj_flag)
{
if (pcode_flag)
{
long len;
v_printf(1, "writing file '%s' ..", curFile->s_cname_of_File);
v_neednl = 1;
beg = times(&ts);
write_OFile(curFile, &len);
write_names(curFile);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %ld %s ,%s\n", len, _clic_ngettext("byte", "bytes", len), diff_clock(beg, end));
else
pr_errorcount(1);
}
else
{
v_printf(2, "writing file '%s' ..", curFile->s_cname_of_File);
v_neednl = 1;
write_File(curFile);
write_names(curFile);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(2, ".. done\n");
else
pr_errorcount(2);
}
}
if (clic_errorcount == 0 && (compile_flag || pc_flag))
{
if (ii)
main_flag = 0;
v_printf(1, "compile file '%s' ..", curFile->s_cname_of_File);
v_neednl = 1;
beg = times(&ts);
compile_File(curFile->cname_of_File);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
if (clic_errorcount == 0 && shared_flag && !exec_flag)
{
v_printf(1, "make shared object '%s' ..", curFile->s_cname_of_File);
v_neednl = 1;
beg = times(&ts);
share_File(curFile->cname_of_File);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
}
}
if (ii < 0)
break;
delete_File(curFile);
curFile = NULL;
}
if (clic_errorcount == 0 && exec_flag)
{
char cmd[1024 * 8], *e;
char cfuncname[256], ofuncname[256];
char *libroot;
int i;
Coll ex, nm;
init_Coll(&ex, free, strcasecmp);
init_Coll(&nm, free, strcasecmp);
#ifdef STD_LIBDIR
libroot = 0;
#else
libroot = CLIPROOT;
#endif
++files;
#ifdef STD_LIBDIR
if (eshared_flag || shared_flag)
{
snprintf(cmd, sizeof(cmd), "-lclip");
add_name(cmd);
}
else
#endif
{
e = (eshared_flag || shared_flag) ? CLIPSLIB : CLIPLIB;
lib_name(cmd, sizeof(cmd), libroot, "lib", e, strlen(e));
add_name(cmd);
}
for (e = CLIPLIBS; *e;)
{
int l;
l = strspn(e, " \t");
e += l;
l = strcspn(e, " \t");
if (!l)
break;
lib_name(cmd, sizeof(cmd), libroot, "lib", e, l);
add_name(cmd);
e += l;
}
for (e = ADDLIBS; *e;)
{
int l;
l = strspn(e, " \t");
e += l;
l = strcspn(e, " \t");
if (!l)
break;
memcpy(cmd, e, l);
cmd[l] = 0;
add_name(cmd);
e += l;
}
add_name(MATHLIB);
add_name(DLLIB);
/* generate _cfunctions */
if (asm_flag)
sprintf(cfuncname, "%s_ref.s", oname);
else
sprintf(cfuncname, "%s_ref.c", oname);
sprintf(ofuncname, "%s_ref.o", oname);
v_printf(1, "generate reference file '%s' ..", cfuncname);
v_neednl = 1;
beg = times(&ts);
write_Cfunc(cfuncname, onum, ovect, &ex, &nm);
check_names(&ex, &nm);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
if (clic_errorcount)
goto end;
v_printf(1, "compile file '%s' ..", cfuncname);
v_neednl = 1;
beg = times(&ts);
compile_File(cfuncname);
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
#ifdef USE_LD
if (use_asm && (shared_flag || eshared_flag))
{
int ll;
const char *ld_prg, *ld_end;
if (shared_flag || eshared_flag)
{
ld_prg = LD_PRG;
ld_end = LD_END;
}
else
{
ld_prg = LDS_PRG;
ld_end = LDS_END;
}
snprintf(cmd, sizeof(cmd), "%s", ld_prg);
ll = strlen(cmd);
for (e = cmd + ll, i = 0; i < lib_dirs.count_of_Coll; ++i)
{
snprintf(e, sizeof(cmd) - ll, " -L%s", (char *) lib_dirs.items_of_Coll[i]);
ll = strlen(cmd);
e = cmd + ll;
}
ll = strlen(cmd);
snprintf(cmd + ll, sizeof(cmd) - ll, " %s %s %s -o %s", optLevel ? COPT : "", genDebug ? CDBG : "", ofuncname, oname);
ll = strlen(cmd);
for (e = cmd + ll, i = 0; i < onum; ++i)
{
snprintf(e, sizeof(cmd) - ll, " %s", ovect[i]);
ll = strlen(cmd);
e = cmd + ll;
}
ll = strlen(cmd);
snprintf(cmd + ll, sizeof(cmd) - ll, " %s", ld_end);
}
else
#endif
{
sprintf(cmd, "%s", CC);
for (e = cmd + strlen(cmd), i = 0; i < includePaths.count_of_Coll; ++i)
{
sprintf(e, " %s %s", INCLUDE_FLAG, (char *) includePaths.items_of_Coll[i]);
e = cmd + strlen(cmd);
}
for (e = cmd + strlen(cmd), i = 0; i < lib_dirs.count_of_Coll; ++i)
{
sprintf(e, " -L%s", (char *) lib_dirs.items_of_Coll[i]);
e = cmd + strlen(cmd);
}
sprintf(cmd + strlen(cmd), " %s %s %s %s %s %s %s", optLevel ? COPT : "", genDebug ? CDBG : "", CFLAGS, ADDCFLAGS, ofuncname, OUT_FLAG, oname);
for (e = cmd + strlen(cmd), i = 0; i < onum; ++i)
{
sprintf(e, " %s", ovect[i]);
e = cmd + strlen(cmd);
}
}
v_printf(1, "make file '%s' ..", oname);
v_neednl = 1;
beg = times(&ts);
v_printf(2, "%s\n", cmd);
if (system(cmd))
yyerror("C level error in command: %s", cmd);
else if (rmc_flag)
{
unlink(cfuncname);
unlink(ofuncname);
}
end = times(&ts);
v_neednl = 0;
if (clic_errorcount == 0)
v_printf(1, ".. done, %s\n", diff_clock(beg, end));
else
pr_errorcount(1);
}
end:
End = times(&ts);
resume_parser();
resume_lex();
resume_locale();
if (!preproc_flag)
v_printf(1, "clip: %d %s, %s\n", files, _clic_ngettext("file", "files", files), diff_clock(Beg, End));
return clic_errorcount == 0 ? 0 : 1;
}
translation_unit_t *get_ast(const char *input, const char* fname,
bool _strict_mode)
{
strict_mode = _strict_mode;
bparser_debug = false;
init_parser(fname);
translation_unit_t *transl_unit;
yyscan_t scanner;
YY_BUFFER_STATE state;
// yydebug = 1;
if (yylex_init(&scanner)) {
// couldn't initialize
return NULL;
}
// std::cerr << "text: " << yyget_text(scanner) << std::endl;
state = yy_scan_string(input, scanner);
// std::cerr << "text: " << yyget_text(scanner) << std::endl;
if (yyparse(&transl_unit, scanner)) {
// error parsing
return NULL;
}
// std::cerr << "text: " << yyget_text(scanner) << std::endl;
/* std::cout << "token vector: " << std::endl;
dumper_t dumper;
std::vector<token_t*>& tokens = get_token_vector();
for(std::vector<token_t*>::const_iterator itr = tokens.begin();
itr != tokens.end(); ++itr)
{
(*itr)->accept(dumper);
}*/
#if 0
std::cout << "comparing input buffer with token string..." << std::endl;
dumper_t dumper;
std::vector<token_t*>& tokens = get_token_vector();
for(std::vector<token_t*>::const_iterator itr = tokens.begin();
itr != tokens.end(); ++itr)
{
(*itr)->accept(dumper);
}
#endif
yy_delete_buffer(state, scanner);
yylex_destroy(scanner);
// run geometry visitor at first so other visitors can
// show the geometry of an error
std::vector<terminal_t*>& tv = get_token_vector();
func_visitor<geom_completor> g;
for(std::vector<terminal_t*>::const_iterator itr = tv.begin();
itr != tv.end(); ++itr)
{
int val = (*itr)->value();
if(val == ' ' || val == '\t' || val == '\n')
(*itr)->accept(g);
}
transl_unit->accept(g);
// output incomplete AST for debugging purposes
// not valgrind-safe yet :( TODO!
// std::cout << *transl_unit << std::endl;
// run the type completor
io_visitor<type_completor> f;
transl_unit->accept(f);
return transl_unit;
}
ERL_NIF_TERM parse_buffer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
Parser par;
Parser* parser = ∥
ErlNifBinary buffer;
if(!enif_inspect_binary(env, argv[0], &buffer)) return enif_make_badarg(env);
if(!init_parser(parser, env, argv[0], &buffer, argv[1])) return enif_make_badarg(env);
ERL_NIF_TERM reply = argv[2];
ERL_NIF_TERM return_value;
parser->remaining_length = buffer.size;
parser->pointer = buffer.data + parser->frame_start;
while (parser->frame_start < parser->buffer_size) {
parser->frame_size = D3I(parser->pointer);
parser->pointer += 3;
unsigned long seg_num = D1(parser->pointer);
parser->pointer += 1;
parser->remaining_length -= (parser->frame_size + 4);
if (parser->remaining_length < 0) {
return_value = enif_make_tuple3(env,
parser->atoms->atom_incomplete,
reply,
enif_make_sub_binary(env, parser->raw, parser->frame_start, parser->buffer_size - parser->frame_start));
break;
}
if (*parser->pointer == MYSQL_RESP_EOF) {
ERL_NIF_TERM remaining_buffer = enif_make_sub_binary(env, parser->raw, parser->frame_start + parser->frame_size + 4, parser->remaining_length);
if (parser->frame_size == 5) {
unsigned long server_status = D2I(parser->pointer + 3);
return_value = enif_make_tuple5(env,
parser->atoms->atom_eof,
enif_make_uint(env, server_status),
enif_make_uint(env, seg_num),
reply,
remaining_buffer);
}
else return_value = enif_make_tuple4(env,
parser->atoms->atom_eof,
enif_make_uint(env, seg_num),
reply,
remaining_buffer);
break;
}
parser->frame_start += 4;
ERL_NIF_TERM row = parse_line(parser);
reply = enif_make_list_cell(env, row, reply);
parser->frame_start += parser->frame_size;
parser->pointer += parser->frame_size;
}
if (parser->frame_start >= parser->buffer_size) return_value = enif_make_tuple3(env,
parser->atoms->atom_incomplete,
reply,
parser->atoms->atom_empty);
destroy_parser(parser);
return return_value;
}
static void
setup(void)
{
init_parser(NULL);
}
SETUP()
{
init_parser(&getenv_value);
}
static void
setup(void)
{
init_parser(ge);
}
