pointer parse_file_to_tree(const char* file_location, symbol_table* table)
{
parser* parse = init_parser(table);
FILE* fin = fopen(file_location, "r");
if(!fin)
{
printf("Input File \"%s\" does not exist.\n", file_location);
return NIL;
}
fseek(fin, 0, SEEK_END);
size_t flen = ftell(fin);
rewind(fin);
char* buffer = new char[flen+1];
fread(buffer, 1, flen, fin);
buffer[flen] = '\0';
fclose(fin);
pointer ret = parser_parse_expression(parse, buffer);
destroy_parser(parse);
delete buffer;
return ret;
}
int main(int argc, char** argv) {
// extra's
// + Change env to a hash table so that we don't have to
// compare all the f*****g strings all the time?
// + Make macro to easier get union child (!) (!)
// + define a 'let' builtin
LispyParser* lispy = new_parser(argc, argv);
if (argc == 1) {
puts("Lispy version 0.0.10");
puts("Press C-c to quit\n");
while(1) {
char* input = readline("Lispy> ");
add_history(input);
eval_and_print(lispy, input);
free(input);
}
}
destroy_parser(&lispy);
return 0;
}
RTcmix::~RTcmix()
{
run_status = RT_SHUTDOWN;
waitForMainLoop(); // This calls close()
free_globals();
#ifdef EMBEDDED
destroy_parser(); // clean up symbols, etc
#endif
}
static void
assert_log_message_dropped(const gchar *input)
{
LogParser *parser = create_parser(NULL);
LogMessage *msg = copy_str_into_log_message(input);
cr_assert_not(_process_log_message(parser, msg));
log_msg_unref(msg);
destroy_parser(parser);
}
bool ft_rcompile(t_regex *dst, t_sub pattern, t_regex_err *err)
{
t_parse_reg parser;
parser = (t_parse_reg){pattern.str, pattern.length, 0, 0, NULL, 0, SUB0()};
dst->reg = compile_regex(&parser);
dst->capture_count = parser.capture_index;
if (dst->reg == NULL && err != NULL)
*err = (t_regex_err){parser.err_str, parser.err_offset};
destroy_parser(&parser);
return (BOOL_OF(dst->reg != NULL));
}
static void
assert_log_message_name_values_with_options(TestParserOptions *options, const gchar *input,
TestNameValue *expected, gsize number_of_expected)
{
LogParser *parser = create_parser(options);
LogMessage *msg = parse_str_into_log_message(parser, input);
for (int i=0; i < number_of_expected; i++)
assert_log_message_value_by_name(msg, expected[i].name, expected[i].value);
log_msg_unref(msg);
destroy_parser(parser);
}
static void
exmpp_xml_stop(ErlDrvData drv_data)
{
struct exmpp_xml_data *edd;
edd = (struct exmpp_xml_data *)drv_data;
/* Destroy the parser. */
destroy_parser(edd);
/* Free generic context. */
free_context(&edd->ctx);
/* Free driver data structure. */
driver_free(edd);
}
static void
exmpp_xml_stop(ErlDrvData drv_data)
{
struct exmpp_xml_data *edd;
edd = (struct exmpp_xml_data *)drv_data;
/* Free the declared_nss list. */
if (edd->declared_nss) {
ei_x_free(edd->declared_nss);
driver_free(edd->declared_nss);
edd->declared_nss = NULL;
}
/* Destroy the parser. */
destroy_parser(edd);
/* Free generic context. */
free_context(&edd->ctx);
/* Free driver data structure. */
driver_free(edd);
}
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);
}
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;
}
