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