static int reil_if(RAnalEsil *esil) { RAnalReilInst *ins; RAnalReilArg *op2, *op1; op2 = reil_pop_arg (esil); if (!op2) return false; op1 = reil_pop_arg (esil); if (!op1) { R_FREE (op2); return false; } ins = R_NEW0 (RAnalReilInst); if (!ins) { R_FREE (op2); R_FREE (op1); return false; } ins->opcode = REIL_JCC; ins->arg[0] = op1; ins->arg[2] = op2; ins->arg[1] = R_NEW0 (RAnalReilArg); if (!ins->arg[1]) { reil_free_inst (ins); return false; } reil_make_arg (esil, ins->arg[1], " "); reil_print_inst (esil, ins); reil_free_inst (ins); return true; }
// n = 8, 4, 2, 1 static int reil_peekn(RAnalEsil *esil, ut8 n) { RAnalReilArg *op2; RAnalReilArg *op1 = reil_pop_arg (esil); if (!op1) return false; reil_push_arg (esil, op1); reil_peek (esil); // No need to cast if n = 0 if (n == 0) { R_FREE (op1); return true; } R_FREE (op1); op1 = reil_pop_arg (esil); if (!op1) return false; op2 = R_NEW0 (RAnalReilArg); if (!op2) { R_FREE (op1); return false; } op2->size = n * 8; op2->type = ARG_TEMP; get_next_temp_reg (esil, op2->name); reil_cast_size (esil, op1, op2); esil->Reil->lastsz = 8 * n; R_FREE (op2); return true; }
// TODO: Add in a Coverity modelling file char *strcat_dup(char *s1, char *s2, st32 n_free) { char *res; ut32 len_s1 = s1? strlen (s1) : 0; ut32 len_s2 = s2? strlen (s2) : 0; if (!(res = (char *)malloc (len_s1 + len_s2 + 1))) { return NULL; } if (len_s1 > 0) { memcpy (res, s1, len_s1); } if (len_s2 > 0) { memcpy (res + len_s1, s2, len_s2); } res[len_s1 + len_s2] = '\0'; if (n_free == 1) { R_FREE (s1); } else if (n_free == 2) { R_FREE (s2); } else if (n_free == 3) { R_FREE (s1); R_FREE (s2); } return res; }
R_API bool r_anal_op_fini(RAnalOp *op) { if (!op) { return false; } if (((ut64)(size_t)op) == UT64_MAX) { return false; } if (((ut64)(size_t)op->mnemonic) == UT64_MAX) { return false; } r_anal_var_free (op->var); r_anal_value_free (op->src[0]); r_anal_value_free (op->src[1]); r_anal_value_free (op->src[2]); r_anal_value_free (op->dst); r_strbuf_fini (&op->esil); r_anal_switch_op_free (op->switch_op); op->src[0] = NULL; op->src[1] = NULL; op->src[2] = NULL; op->dst = NULL; op->var = NULL; op->switch_op = NULL; R_FREE (op->mnemonic); R_FREE (op->reg); return true; }
void r_bin_bflt_free(struct r_bin_bflt_obj *obj) { if (obj) { R_FREE (obj->hdr); R_FREE (obj->b); R_FREE (obj); } }
// Free ins and all its arguments void reil_free_inst(RAnalReilInst *ins) { if (!ins) return; if (ins->arg[0]) R_FREE(ins->arg[0]); if (ins->arg[1]) R_FREE(ins->arg[1]); if (ins->arg[2]) R_FREE(ins->arg[2]); R_FREE(ins); }
static void rcc_element(REgg *egg, char *str) { REggEmit *e = egg->remit; char *p = strrchr (str, ','); int num, num2; if (CTX) { nargs = 0; if (mode == GOTO) mode = NORMAL; // XXX while (p) { *p = '\0'; p = (char *)skipspaces (p+1); rcc_pusharg (egg, p); p = strrchr (str, ','); } if (callname) rcc_pusharg (egg, str); else if (mode == NORMAL) { if (!atoi (str)) { if (dstvar == NULL) /* return string */ dstvar = strdup (".fix0"); rcc_pushstr (egg, str, 1); } } } else { switch (mode) { case ALIAS: e->equ (egg, dstvar, str); R_FREE (dstvar); mode = NORMAL; break; case SYSCALL: syscalls[nsyscalls].name = strdup (dstvar); syscalls[nsyscalls].arg = strdup (str); nsyscalls++; R_FREE (dstvar); break; case GOTO: elem[elem_n] = 0; e->jmp (egg, elem, 0); break; default: p = strchr (str, ','); if (p) { *p='\0'; num2 = atoi (p+1); } else num2 = 0; num = atoi (str) + num2; stackframe = num; stackfixed = num2; if (mode != NAKED) e->frame (egg, stackframe+stackfixed); } elem[0] = 0; elem_n = 0; } }
int get_template(char *buf, SStrInfo *str_info) { int len = 0; unsigned int i = 0; char *str_type_code = 0; char *tmp = strstr(buf, "@"); STypeCodeStr type_code_str; RListIter *it = 0; RList *saved_abbr_names = abbr_names; // save current abbr names, this if (!tmp) { goto get_template_err; } if (!init_type_code_str_struct(&type_code_str)) { goto get_template_err; } abbr_names = r_list_new (); // get/copy template len/name len += (tmp - buf + 1); copy_string(&type_code_str, buf, len - 1); buf += len; if (*buf != '@') { copy_string(&type_code_str, "<", 0); } // get identifier while (*buf != '@') { if (i) { copy_string (&type_code_str, ", ", 0); } if (get_type_code_string (buf, &i, &str_type_code) != eDemanglerErrOK) { len = 0; goto get_template_err; } copy_string (&type_code_str, str_type_code, 0); buf += i; len += i; R_FREE (str_type_code); } if (*buf != '@') { len = 0; goto get_template_err; } copy_string (&type_code_str, ">", 0); buf++; len++; str_info->str_ptr = type_code_str.type_str; str_info->len = type_code_str.curr_pos; get_template_err: #if 0 it = r_list_iterator (abbr_names); r_list_foreach (abbr_names, it, tmp) { R_FREE (tmp); }
static int parsedatachar(REgg *egg, char c) { static int inlinectr = 0; char *str; int i, j; if (!dstval) { return 0; } /* skip until '{' */ if (c == '{') { /* XXX: repeated code!! */ rcc_context (egg, 1); if (++inlinectr==1) return (ndstval = 0); } else if (inlinectr == 0) { /* capture value between parenthesis foo@data(NNN) { ... } */ if (c==')') { stackframe = atoi (dstval); ndstval = 0; } else { dstval[ndstval++] = c; } return 0; } /* capture body */ if (c == '}') { /* XXX: repeated code!! */ if (CTX< 2) { inlinectr = 0; rcc_context (egg, -1); slurp = 0; mode = NORMAL; /* register */ if (dstval != NULL && dstvar != NULL) { dstval[ndstval]='\0'; egg->remit->comment (egg, "data (%s)(%s)size=(%d)\n", dstvar, dstval, stackframe); r_egg_printf (egg, ".data\n"); for (str=dstval; is_space (*str); str++); j = (stackframe)? stackframe: 1; /* emit label */ r_egg_printf (egg, "%s:\n", dstvar); for (i=1; i<=j; i++) { if (*str=='"') r_egg_printf (egg, ".ascii %s%s\n", dstval, (i==j)?"\"\\x00\"":""); else r_egg_printf (egg, ".long %s\n", dstval); } r_egg_printf (egg, ".text\n"); R_FREE (dstvar); R_FREE (dstval); ndstval = 0; CTX = 0; return 1; } } } dstval[ndstval++] = c; return 0; }
static int __close(RIODesc *fd) { RIOSparse *riom; if (!fd || !fd->data) { return -1; } riom = fd->data; R_FREE (riom->buf); R_FREE (fd->data); return 0; }
static int __close(RIODesc *fd) { RIOBfdbg *riom; if (!fd || !fd->data) { return -1; } riom = fd->data; bfvm_free (riom->bfvm); R_FREE (riom->buf); R_FREE (fd->data); return 0; }
int init_pdb_parser(R_PDB *pdb, const char *filename) { char *signature = NULL; int bytes_read = 0; if (!pdb) { eprintf ("struct R_PDB is not correct\n"); goto error; } if (!pdb->cb_printf) pdb->cb_printf = (PrintfCallback)printf; pdb->buf = r_buf_file(filename); // pdb->fp = r_sandbox_fopen (filename, "rb"); // if (!pdb->fp) { // eprintf ("file %s can not be open\n", filename); // goto error; // } signature = (char *)calloc (1, PDB7_SIGNATURE_LEN); if (!signature) { eprintf ("memory allocation error\n"); goto error; } bytes_read = r_buf_read(pdb->buf, (unsigned char *)signature, PDB7_SIGNATURE_LEN); if (bytes_read != PDB7_SIGNATURE_LEN) { eprintf ("file reading error\n"); goto error; } r_buf_seek(pdb->buf, 0, 0); if (!memcmp (signature, PDB7_SIGNATURE, PDB7_SIGNATURE_LEN)) { pdb->pdb_parse = pdb7_parse; } else { goto error; } R_FREE (signature); pdb->pdb_streams = r_list_new (); pdb->stream_map = 0; pdb->finish_pdb_parse = finish_pdb_parse; pdb->print_types = print_types; pdb->print_gvars = print_gvars; // printf("init_pdb_parser() finish with success\n"); return 1; error: R_FREE (signature); return 0; }
R_API RPrint *r_print_free(RPrint *p) { if (!p) return NULL; r_strht_free (p->formats); p->formats = NULL; if (p->zoom) { free (p->zoom->buf); free (p->zoom); p->zoom = NULL; } R_FREE (p->lines_cache); R_FREE (p->row_offsets); free (p); return NULL; }
R_API void r_cons_pal_free () { int i; RCons *cons = r_cons_singleton (); for (i = 0; i < R_CONS_PALETTE_LIST_SIZE; i++) { if (cons->pal.list[i]) R_FREE (cons->pal.list[i]); } }
R_API void r_cons_pal_random () { RCons *cons = r_cons_singleton (); ut8 r, g, b; char val[32]; const char *k; int i; for (i = 0; ; i++) { k = r_cons_pal_get_i (i); if (!k) break; if (cons->truecolor > 0) { r = r_num_rand (0xff); g = r_num_rand (0xff); b = r_num_rand (0xff); sprintf (val, "rgb:%02x%02x%02x", r, g, b); r_cons_pal_set (k, val); } else { char *s = r_cons_color_random_string (0); if (s) { r_cons_pal_set (k, s); free (s); } else { r_cons_pal_set (k, "red"); } } } for (i = 0; i < R_CONS_PALETTE_LIST_SIZE; i++) { if (cons->pal.list[i]) R_FREE (cons->pal.list[i]); cons->pal.list[i] = r_cons_color_random (0); } }
static pyc_object *get_tuple_object_generic(RBuffer *buffer, ut32 size) { pyc_object *ret = R_NEW0 (pyc_object); if (!ret) return NULL; ret->type = TYPE_TUPLE; ret->data = r_list_new (); if (!ret->data) { free (ret); return NULL; } for (ut32 i = 0; i < size; ++i) { pyc_object *tmp = get_object (buffer); if (!tmp) { r_list_free (ret->data); R_FREE (ret); break; } if (!r_list_append (ret->data, tmp)) { free (tmp); r_list_free (ret->data); break; } } return ret; }
R_API RList *r_core_list_themes(RCore *core) { RList *files = NULL; RListIter *iter; const char *fn; char *home = r_str_home (".config/radare2/cons/"); RList *list = r_list_new (); getNext = false; if (home) { files = r_sys_dir (home); r_list_foreach (files, iter, fn) { if (*fn && *fn != '.') { r_list_append (list, strdup (fn)); } } r_list_free (files); R_FREE (home); } files = r_sys_dir (R2_DATDIR"/radare2/"R2_VERSION"/cons/"); r_list_foreach (files, iter, fn) { if (*fn && *fn != '.') { r_list_append (list, strdup (fn)); } } r_list_free (files); files = NULL; return list; }
static int reil_neg(RAnalEsil *esil) { char tmp_buf[REGBUFSZ]; RAnalReilInst *ins; RAnalReilArg *op = reil_pop_arg (esil); if (!op) return false; ins = R_NEW0 (RAnalReilInst); if (!ins) { R_FREE (op); return false; } ins->opcode = REIL_EQ; ins->arg[0] = op; r_anal_esil_pushnum (esil, 0); ins->arg[1] = reil_pop_arg(esil); if (!ins->arg[1]) { reil_free_inst (ins); return false; } ins->arg[2] = R_NEW0 (RAnalReilArg); if (!ins->arg[2]) { reil_free_inst (ins); return false; } get_next_temp_reg (esil, tmp_buf); reil_make_arg(esil, ins->arg[2], tmp_buf); if (ins->arg[0]->size < ins->arg[1]->size) ins->arg[1]->size = ins->arg[0]->size; ins->arg[2]->size = 1; reil_print_inst (esil, ins); reil_push_arg (esil, ins->arg[2]); reil_free_inst (ins); return true; }
R_API R2Pipe *r2p_open(const char *cmd) { R2Pipe *r2p = R_NEW0 (R2Pipe); r2p->magic = R2P_MAGIC; if (cmd == NULL) { r2p->child = -1; #if __UNIX__ { char *out = r_sys_getenv ("R2PIPE_IN"); char *in = r_sys_getenv ("R2PIPE_OUT"); int done = R_FALSE; if (in && out) { int i_in = atoi (in); int i_out = atoi (out); if (i_in>=0 && i_out>=0) { r2p->input[0] = r2p->input[1] = i_in; r2p->output[0] = r2p->output[1] = i_out; done = R_TRUE; } } if (!done) { eprintf ("Cannot find R2PIPE_IN or R2PIPE_OUT environment\n"); R_FREE (r2p); } free (in); free (out); } return r2p; #else eprintf ("r2p_open(NULL) not supported on windows\n"); return NULL; #endif } #if __WINDOWS__ w32_createPipe (r2p, cmd); r2p->child = (int)(r2p->pipe); #else pipe (r2p->input); pipe (r2p->output); r2p->child = fork (); if (r2p->child == -1) { r2p_close (r2p); return NULL; } env ("R2PIPE_IN", r2p->input[0]); env ("R2PIPE_OUT", r2p->output[1]); if (r2p->child) { eprintf ("Child is %d\n", r2p->child); } else { int rc; if (cmd && *cmd) { rc = r_sandbox_system (cmd, 1); } else rc = 0; r2p_close (r2p); exit (0); return NULL; } #endif return r2p; }
static int reil_peek(RAnalEsil *esil) { RAnalReilInst *ins; char tmp_buf[REGBUFSZ]; RAnalReilArg *op1 = reil_pop_arg(esil); if (!op1) return false; ins = R_NEW0 (RAnalReilInst); if (!ins) { R_FREE (op1); return false; } ins->opcode = REIL_LDM; ins->arg[0] = op1; ins->arg[1] = R_NEW0(RAnalReilArg); if (!ins->arg[1]) { reil_free_inst (ins); return false; } ins->arg[2] = R_NEW0(RAnalReilArg); if (!ins->arg[2]) { reil_free_inst (ins); return false; } reil_make_arg(esil, ins->arg[1], " "); get_next_temp_reg(esil, tmp_buf); reil_make_arg(esil, ins->arg[2], tmp_buf); ins->arg[2]->size = ins->arg[0]->size; reil_print_inst(esil, ins); reil_push_arg(esil, ins->arg[2]); reil_free_inst(ins); return true; }
static char *projectScriptPath(RCore *core, const char *file) { const char *magic = "# r2 rdb project file"; char *data, *prjfile; if (r_file_is_abspath (file)) { prjfile = strdup (file); } else { if (!is_valid_project_name (file)) { return NULL; } prjfile = r_file_abspath (r_config_get (core->config, "dir.projects")); prjfile = r_str_append (prjfile, R_SYS_DIR); prjfile = r_str_append (prjfile, file); if (!r_file_exists (prjfile) || r_file_is_directory (prjfile)) { prjfile = r_str_append (prjfile, R_SYS_DIR "rc"); } } data = r_file_slurp (prjfile, NULL); if (data) { if (strncmp (data, magic, strlen (magic))) { R_FREE (prjfile); } } free (data); return prjfile; }
R_API ut8* r_socket_slurp(RSocket *s, int *len) { int blockSize = 4096; ut8 *ptr, *buf = malloc (blockSize); int copied = 0; if (len) { *len = 0; } for (;;) { int rc = r_socket_read (s, buf + copied, blockSize); if (rc > 0) { copied += rc; } ptr = realloc (buf, copied + blockSize); if (ptr) { buf = ptr; } else { break; } if (rc < 1) { break; } } if (copied == 0) { R_FREE (buf); } if (len) { *len = copied; } return buf; }
R_API int r_strbuf_append(RStrBuf *sb, const char *s) { int l = strlen (s); if (l<1) return false; if ((sb->len + l + 1) < sizeof (sb->buf)) { memcpy (sb->buf + sb->len, s, l + 1); R_FREE (sb->ptr); } else { int newlen = sb->len + l + 128; char *p = sb->ptr; bool allocated = true; if (!sb->ptr) { p = malloc (newlen); if (p && sb->len > 0) { memcpy (p, sb->buf, sb->len); } } else if (sb->len + l + 1 > sb->ptrlen) { p = realloc (sb->ptr, newlen); } else { allocated = false; } if (allocated) { if (!p) return false; sb->ptr = p; sb->ptrlen = newlen; } memcpy (p + sb->len, s, l + 1); } sb->len += l; return true; }
R_API void r_id_storage_delete(RIDStorage* storage, ut32 id) { if (!storage || !storage->data || (storage->size <= id)) { return; } storage->data[id] = NULL; if (id == storage->top_id) { while (storage->top_id && !storage->data[storage->top_id]) { storage->top_id--; } if (!storage->top_id) { if (storage->data[storage->top_id]) { id_storage_reallocate (storage, 2); } else { RIDPool* pool = r_id_pool_new (storage->pool->start_id, storage->pool->last_id); R_FREE (storage->data); storage->size = 0; r_id_pool_free (storage->pool); storage->pool = pool; return; } } else if ((storage->top_id + 1) < (storage->size / 4)) { id_storage_reallocate (storage, storage->size / 2); } } r_id_pool_kick_id (storage->pool, id); }
SDB_API bool sdb_disk_create(Sdb* s) { int nlen; char *str; const char *dir; if (!s || s->fdump >= 0) { return false; // cannot re-create } if (!s->dir && s->name) { s->dir = strdup (s->name); } dir = s->dir ? s->dir : "./"; R_FREE (s->ndump); nlen = strlen (dir); str = malloc (nlen + 5); if (!str) { return false; } memcpy (str, dir, nlen + 1); r_sys_mkdirp (str); memcpy (str + nlen, ".tmp", 5); if (s->fdump != -1) { close (s->fdump); } s->fdump = open (str, O_BINARY | O_RDWR | O_CREAT | O_TRUNC, SDB_MODE); if (s->fdump == -1) { eprintf ("sdb: Cannot open '%s' for writing.\n", str); free (str); return false; } cdb_make_start (&s->m, s->fdump); s->ndump = str; return true; }
static R2Pipe* r2pipe_open_spawn(R2Pipe* r2pipe) { #if __UNIX__ || defined(__CYGWIN__) char *out = r_sys_getenv ("R2PIPE_IN"); char *in = r_sys_getenv ("R2PIPE_OUT"); int done = false; if (in && out) { int i_in = atoi (in); int i_out = atoi (out); if (i_in >= 0 && i_out >= 0) { r2pipe->input[0] = r2pipe->input[1] = i_in; r2pipe->output[0] = r2pipe->output[1] = i_out; done = true; } } if (!done) { eprintf ("Cannot find R2PIPE_IN or R2PIPE_OUT environment\n"); R_FREE (r2pipe); } free (in); free (out); return r2pipe; #else eprintf ("r2pipe_open(NULL) not supported on windows\n"); return NULL; #endif }
static ut8 *slurp(RCore **c, const char *file, int *sz) { RIODesc *d; RIO *io; if (c && file && strstr (file, "://")) { ut8 *data = NULL; ut64 size; if (!*c) { *c = opencore (NULL); } io = (*c)->io; d = r_io_open (io, file, 0, 0); if (!d) { return NULL; } size = r_io_size (io); if (size > 0 || size < ST32_MAX) { data = calloc (1, size); if (r_io_read_at (io, 0, data, size) == size) { if (sz) { *sz = size; } } else { eprintf ("slurp: read error\n"); R_FREE (data); } } else { eprintf ("slurp: File is too big\n"); } r_io_close (io, d); return data; } return (ut8*)r_file_slurp (file, sz); }
static int reil_cmp(RAnalEsil *esil) { RAnalReilInst *ins; char tmp_buf[REGBUFSZ]; RAnalReilArg *op2, *op1; op2 = reil_pop_arg(esil); if (!op2) return false; op1 = reil_pop_arg(esil); if (!op1) { R_FREE (op2); return false; } ins = R_NEW0 (RAnalReilInst); if (!ins) { R_FREE (op1); R_FREE (op2); return false; } ins->opcode = REIL_EQ; ins->arg[0] = op2; ins->arg[1] = op1; ins->arg[2] = R_NEW0(RAnalReilArg); if (!ins->arg[2]) { reil_free_inst (ins); return false; } get_next_temp_reg(esil, tmp_buf); reil_make_arg(esil, ins->arg[2], tmp_buf); ins->arg[2]->size = 1; reil_print_inst(esil, ins); // Set vars needed to determine flags. snprintf(esil->Reil->cur, sizeof(esil->Reil->old) - 1, "%s:%d", ins->arg[2]->name, ins->arg[2]->size); snprintf(esil->Reil->old, sizeof(esil->Reil->cur) - 1, "%s:%d", op2->name, op2->size); if (r_reg_get(esil->anal->reg, op2->name, -1)) { esil->Reil->lastsz = op2->size; } else if (r_reg_get(esil->anal->reg, op1->name, -1)) { esil->Reil->lastsz = op1->size; } reil_push_arg(esil, ins->arg[2]); reil_free_inst(ins); return true; }
// General function for operations that take 2 operands static int reil_binop(RAnalEsil *esil, RAnalReilOpcode opcode) { RAnalReilInst *ins; char tmp_buf[REGBUFSZ]; ut8 dst_size; RAnalReilArg *op2, *op1; op2 = reil_pop_arg(esil); if (!op2) return false; op1 = reil_pop_arg(esil); if (!op1) { R_FREE (op2); return false; } ins = R_NEW0 (RAnalReilInst); if (!ins) { R_FREE (op1); R_FREE (op2); return false; } ins->opcode = opcode; ins->arg[0] = op2; ins->arg[1] = op1; if (!ins->arg[1]) { reil_free_inst (ins); return false; } ins->arg[2] = R_NEW0(RAnalReilArg); if (!ins->arg[2]) { reil_free_inst (ins); return false; } get_next_temp_reg(esil, tmp_buf); reil_make_arg(esil, ins->arg[2], tmp_buf); // Choose the larger of the two sizes as the size of dst dst_size = ins->arg[0]->size; if (dst_size < ins->arg[1]->size) dst_size = ins->arg[1]->size; // REIL_LT has a dst_size of 1. if (opcode == REIL_LT) dst_size = 1; ins->arg[2]->size = dst_size; reil_print_inst(esil, ins); reil_push_arg(esil, ins->arg[2]); reil_free_inst(ins); return true; }
R_API int r_core_lines_initcache(RCore *core, ut64 start_addr, ut64 end_addr) { int i, line_count; int bsz = core->blocksize; char *buf; ut64 off = start_addr; ut64 baddr; if (start_addr == UT64_MAX || end_addr == UT64_MAX) { return -1; } free (core->print->lines_cache); core->print->lines_cache = R_NEWS0 (ut64, bsz); if (!core->print->lines_cache) { return -1; } { RIOSection *s = r_io_section_mget_in (core->io, core->offset); baddr = s? s->paddr: r_config_get_i (core->config, "bin.baddr"); } line_count = start_addr? 0: 1; core->print->lines_cache[0] = start_addr? 0: baddr; buf = malloc (bsz); if (!buf) { return -1; } r_cons_break_push (NULL, NULL); while (off < end_addr) { if (r_cons_is_breaked ()) { break; } r_io_read_at (core->io, off, (ut8 *) buf, bsz); for (i = 0; i < bsz; i++) { if (buf[i] == '\n') { core->print->lines_cache[line_count] = start_addr? off + i + 1: off + i + 1 + baddr; line_count++; if (line_count % bsz == 0) { ut64 *tmp = realloc (core->print->lines_cache, (line_count + bsz) * sizeof (ut64)); if (tmp) { core->print->lines_cache = tmp; } else { R_FREE (core->print->lines_cache); goto beach; } } } } off += bsz; } free (buf); r_cons_break_pop (); return line_count; beach: free (buf); r_cons_break_pop (); return -1; }