static BtorNode * parse_binary (BtorBTORParser * parser, int len, Binary f) { BtorNode *l, *r, *res; assert (len); if (parse_space (parser)) return 0; if (!(l = parse_exp (parser, len, 0))) return 0; if (parse_space (parser)) { RELEASE_L_AND_RETURN_ERROR: btor_release_exp (parser->btor, l); return 0; } if (!(r = parse_exp (parser, len, 0))) goto RELEASE_L_AND_RETURN_ERROR; res = f (parser->btor, l, r); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); assert (btor_get_exp_len (parser->btor, res) == len); return res; }
int main(int argc, char **argv) { int line_number; int fd; char *line; t_list *tokens; if (argc < 2) fatal_error(RAYTRACER, ERR_TOO_FEW_ARGS, 0); if (argc > 2) fatal_error(RAYTRACER, ERR_TOO_MANY_ARGS, 0); line_number = 1; fd = access_file(argv[1]); while (get_next_line(fd, &line)) { ft_lstappend(&tokens, tokenize(line, line_number)); line_number++; free(line); } if (parse_exp(&tokens) && tokens == NULL) ft_putendl("PARSE WIN"); else { WRITE(2, "Parse fail near : '"); ft_putstr_fd(get_token(&tokens)->lexeme, 2); WRITE(2, "' at line "); ft_putnbr_fd(get_token(&tokens)->line, 2); ft_putchar('\n'); } return (0); }
static BtorNode * parse_read (BtorBTORParser * parser, int len) { BtorNode *array, *idx, *res; int idxlen; if (parse_space (parser)) return 0; if (!(array = parse_array_exp (parser, len))) return 0; if (parse_space (parser)) { RELEASE_ARRAY_AND_RETURN_ERROR: btor_release_exp (parser->btor, array); return 0; } idxlen = btor_get_index_exp_len (parser->btor, array); if (!(idx = parse_exp (parser, idxlen, 0))) goto RELEASE_ARRAY_AND_RETURN_ERROR; res = btor_read_exp (parser->btor, array, idx); btor_release_exp (parser->btor, idx); btor_release_exp (parser->btor, array); return res; }
static BtorNode * parse_redunary (BtorBTORParser * parser, int len, Unary f) { BtorNode *tmp, *res; (void) len; assert (len == 1); if (parse_space (parser)) return 0; if (!(tmp = parse_exp (parser, 0, 0))) return 0; if (btor_get_exp_len (parser->btor, tmp) == 1) { (void) btor_perr_btor (parser, "argument of reduction operation of width 1"); btor_release_exp (parser->btor, tmp); return 0; } res = f (parser->btor, tmp); btor_release_exp (parser->btor, tmp); assert (btor_get_exp_len (parser->btor, res) == 1); return res; }
/* If *_PARSE_ENV is set, then environment variables beginning with prefix are read and set, overriding input file if defined there too. */ void parse_environment(const char* prefix) { char* flag; parse_result pc; flag = (char *)malloc(strlen(prefix) + 11); strcpy(flag, prefix); strcat(flag, "PARSE_ENV"); if( getenv(flag)!=NULL ) { if(!disable_write) fprintf(fout, "# %s is set, parsing environment variables\n", flag); /* environ is an array of C strings with all the environment variables, the format of the string is NAME=VALUE, which is directly recognized by parse_exp */ char **env = environ; while(*env) { /* Only consider variables that begin with the prefix, except the PARSE_ENV flag */ if( strncmp(flag, *env, strlen(flag)) != 0 && strncmp(prefix, *env, strlen(prefix)) == 0 ){ if(!disable_write) fprintf(fout, "# parsed from environment: %s\n", (*env) + strlen(prefix)); parse_exp( (*env) + strlen(prefix), &pc); } env++; } } free(flag); }
static BtorNode * parse_write (BtorBTORParser * parser, int len) { BtorNode *array, *idx, *val, *res; int idxlen, vallen; if (parse_space (parser)) return 0; if (parse_positive_int (parser, &idxlen)) return 0; if (parse_space (parser)) return 0; if (!(array = parse_array_exp (parser, len))) return 0; if (parse_space (parser)) { RELEASE_ARRAY_AND_RETURN_ERROR: btor_release_exp (parser->btor, array); return 0; } if (!(idx = parse_exp (parser, idxlen, 0))) goto RELEASE_ARRAY_AND_RETURN_ERROR; if (parse_space (parser)) { RELEASE_ARRAY_AND_IDX_AND_RETURN_ERROR: btor_release_exp (parser->btor, idx); goto RELEASE_ARRAY_AND_RETURN_ERROR; } vallen = btor_get_exp_len (parser->btor, array); if (!(val = parse_exp (parser, vallen, 0))) goto RELEASE_ARRAY_AND_IDX_AND_RETURN_ERROR; res = btor_write_exp (parser->btor, array, idx, val); btor_release_exp (parser->btor, array); btor_release_exp (parser->btor, idx); btor_release_exp (parser->btor, val); return res; }
static BtorNode * parse_slice (BtorBTORParser * parser, int len) { int arglen, upper, lower, delta; BtorNode *res, *arg; if (parse_space (parser)) return 0; if (!(arg = parse_exp (parser, 0, 0))) return 0; if (parse_space (parser)) { RELEASE_ARG_AND_RETURN_ERROR: btor_release_exp (parser->btor, arg); return 0; } arglen = btor_get_exp_len (parser->btor, arg); if (parse_non_negative_int (parser, &upper)) goto RELEASE_ARG_AND_RETURN_ERROR; if (upper >= arglen) { (void) btor_perr_btor (parser, "upper index '%d' >= argument width '%d", upper, arglen); goto RELEASE_ARG_AND_RETURN_ERROR; } if (parse_space (parser)) goto RELEASE_ARG_AND_RETURN_ERROR; if (parse_non_negative_int (parser, &lower)) goto RELEASE_ARG_AND_RETURN_ERROR; if (upper < lower) { (void) btor_perr_btor (parser, "upper index '%d' smaller than lower index '%d'", upper, lower); goto RELEASE_ARG_AND_RETURN_ERROR; } delta = upper - lower + 1; if (delta != len) { (void) btor_perr_btor (parser, "slice width '%d' not equal to expected width '%d'", delta, len); goto RELEASE_ARG_AND_RETURN_ERROR; } res = btor_slice_exp (parser->btor, arg, upper, lower); btor_release_exp (parser->btor, arg); return res; }
static BtorNode * parse_acond (BtorBTORParser * parser, int len) { BtorNode *c, *t, *e, *res; int idxlen; if (parse_space (parser)) return 0; if (parse_positive_int (parser, &idxlen)) return 0; if (parse_space (parser)) return 0; if (!(c = parse_exp (parser, 1, 0))) return 0; if (parse_space (parser)) { RELEASE_C_AND_RETURN_ERROR: btor_release_exp (parser->btor, c); return 0; } if (!(t = parse_array_exp (parser, len))) goto RELEASE_C_AND_RETURN_ERROR; if (idxlen != btor_get_index_exp_len (parser->btor, t)) { (void) btor_perr_btor (parser, "mismatch of index bit width of 'then' array"); RELEASE_C_AND_T_AND_RETURN_ERROR: btor_release_exp (parser->btor, t); goto RELEASE_C_AND_RETURN_ERROR; } if (parse_space (parser)) goto RELEASE_C_AND_T_AND_RETURN_ERROR; if (!(e = parse_array_exp (parser, len))) goto RELEASE_C_AND_T_AND_RETURN_ERROR; if (idxlen != btor_get_index_exp_len (parser->btor, e)) { (void) btor_perr_btor (parser, "mismatch of index bit width of 'else' array"); btor_release_exp (parser->btor, e); goto RELEASE_C_AND_T_AND_RETURN_ERROR; } res = btor_cond_exp (parser->btor, c, t, e); btor_release_exp (parser->btor, e); btor_release_exp (parser->btor, t); btor_release_exp (parser->btor, c); return res; }
static BtorNode * parse_logical (BtorBTORParser * parser, int len, Binary f) { BtorNode * l, * r, * res; if (len != 1) { (void) btor_perr_btor (parser, "logical operator bit width '%d'", len); return 0; } if (parse_space (parser)) return 0; if (!(l = parse_exp (parser, 0, 0))) return 0; if (btor_get_exp_len (parser->btor, l) != 1) { BIT_WIDTH_ERROR_RELEASE_L_AND_RETURN: (void) btor_perr_btor (parser, "expected argument of bit width '1'"); RELEASE_L_AND_RETURN_ERROR: btor_release_exp (parser->btor, l); return 0; } if (parse_space (parser)) goto RELEASE_L_AND_RETURN_ERROR; if (!(r = parse_exp (parser, 0, 0))) goto RELEASE_L_AND_RETURN_ERROR; if (btor_get_exp_len (parser->btor, r) != 1) { btor_release_exp (parser->btor, r); goto BIT_WIDTH_ERROR_RELEASE_L_AND_RETURN; } res = f (parser->btor, l, r); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); assert (btor_get_exp_len (parser->btor, res) == 1); return res; }
static BtorNode * parse_concat (BtorBTORParser * parser, int len) { BtorNode *l, *r, *res; int llen, rlen; if (parse_space (parser)) return 0; if (!(l = parse_exp (parser, 0, 0))) return 0; if (parse_space (parser)) { RELEASE_L_AND_RETURN_ERROR: btor_release_exp (parser->btor, l); return 0; } if (!(r = parse_exp (parser, 0, 0))) goto RELEASE_L_AND_RETURN_ERROR; llen = btor_get_exp_len (parser->btor, l); rlen = btor_get_exp_len (parser->btor, r); if (llen + rlen != len) { (void) btor_perr_btor (parser, "operands widths %d and %d do not add up to %d", llen, rlen, len); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); return 0; } res = btor_concat_exp (parser->btor, l, r); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); assert (btor_get_exp_len (parser->btor, res) == len); return res; }
list<shared_ptr<exp>> Parser::parse_until_close() { list<shared_ptr<exp>> exps; while (*cur != ")" && cur != end) { exps.push_back(parse_exp()); } if (cur == end) throw "unmatched parens"; cur++; return exps; }
static int parse_block_work(const sym_block *blk, int l, int col, parse_result *r) { assert(blk!=NULL); assert(l>=0 && l<blk->n); if(col < 0 || col >= blk->lines[l].n){ fprintf(stderr, "Parser error: column %i out of range [0,%i] when parsing block '%s'.\n", col, blk->lines[l].n-1, blk->name); exit(1); } return parse_exp(blk->lines[l].fields[col], r); }
static int parse_block_work(sym_block *blk, int l, int col, parse_result *r) { assert(blk!=NULL); assert(l>=0 && l<blk->n); assert(col>=0); if(col >= blk->lines[l].n){ fprintf(stderr, "%s\n", "Input error: not enough columns found when parsing block."); exit(1); } return parse_exp(blk->lines[l].fields[col], r); }
static BtorNode * parse_cond (BtorBTORParser * parser, int len) { BtorNode *c, *t, *e, *res; if (parse_space (parser)) return 0; if (!(c = parse_exp (parser, 1, 0))) return 0; if (parse_space (parser)) { RELEASE_C_AND_RETURN_ERROR: btor_release_exp (parser->btor, c); return 0; } if (!(t = parse_exp (parser, len, 0))) goto RELEASE_C_AND_RETURN_ERROR; if (parse_space (parser)) { RELEASE_C_AND_T_AND_RETURN_ERROR: btor_release_exp (parser->btor, t); goto RELEASE_C_AND_RETURN_ERROR; } if (!(e = parse_exp (parser, len, 0))) goto RELEASE_C_AND_T_AND_RETURN_ERROR; res = btor_cond_exp (parser->btor, c, t, e); btor_release_exp (parser->btor, e); btor_release_exp (parser->btor, t); btor_release_exp (parser->btor, c); return res; }
static BtorNode * parse_shift (BtorBTORParser * parser, int len, Shift f) { BtorNode *l, *r, *res; int rlen; for (rlen = 1; rlen <= 30 && len != (1 << rlen); rlen++) ; if (len != (1 << rlen)) { (void) btor_perr_btor (parser, "length %d is not a power of two", len); return 0; } if (parse_space (parser)) return 0; if (!(l = parse_exp (parser, len, 0))) return 0; if (parse_space (parser)) { RELEASE_L_AND_RETURN_ERROR: btor_release_exp (parser->btor, l); return 0; } if (!(r = parse_exp (parser, rlen, 0))) goto RELEASE_L_AND_RETURN_ERROR; res = f (parser->btor, l, r); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); assert (btor_get_exp_len (parser->btor, res) == len); return res; }
static BtorNode * parse_root (BtorBTORParser * parser, int len) { BtorNode *res; if (parse_space (parser)) return 0; if (!(res = parse_exp (parser, len, 0))) return 0; BTOR_PUSH_STACK (parser->mem, parser->outputs, res); return res; }
static BtorNode * parse_next (BtorBTORParser * parser, int len) { int idx; BtorNode * current, * next; Info info; if (parse_space (parser)) return 0; if (parse_positive_int (parser, &idx)) return 0; if (idx >= BTOR_COUNT_STACK (parser->exps) || !(current = parser->exps.start[idx])) { (void) btor_perr_btor (parser, "invalid next index %d", idx); return 0; } info = parser->info.start[idx]; if (!info.var) { (void) btor_perr_btor (parser, "next index %d is not a variable", idx); return 0; } if (info.next) { (void) btor_perr_btor (parser, "next index %d already used", idx); return 0; } if (parse_space (parser)) return 0; assert (!btor_is_array_exp (parser->btor, current)); if (!(next = parse_exp (parser, len, 0))) return 0; BTOR_PUSH_STACK (parser->mem, parser->regs, current); BTOR_PUSH_STACK (parser->mem, parser->nexts, next); parser->info.start[idx].next = 1; return next; }
static BtorNode * parse_array_exp (BtorBTORParser * parser, int len) { BtorNode * res; res = parse_exp (parser, len, 1); if (!res) return 0; if (btor_is_array_exp (parser->btor, res)) return res; (void) btor_perr_btor (parser, "expected array expression"); btor_release_exp (parser->btor, res); return 0; }
static BtorNode * parse_unary (BtorBTORParser * parser, int len, Unary f) { BtorNode *tmp, *res; assert (len); if (parse_space (parser)) return 0; if (!(tmp = parse_exp (parser, len, 0))) return 0; res = f (parser->btor, tmp); btor_release_exp (parser->btor, tmp); assert (btor_get_exp_len (parser->btor, res) == len); return res; }
struct expression *parse_prop() { struct expression *exp = parse_exp(); if (is_empty_expression(exp) || current_token == NULL) return NULL; switch (current_token->type) { case OpOr: advanceToken(); struct expression *prop = new_op_expression(OrExp, exp, parse_prop()); if (is_right_child_empty(prop)) { destroy_expression(exp); return NULL; } return prop; default: return exp; } }
static BtorNode * parse_ext (BtorBTORParser * parser, int len, Extend f) { BtorNode *res, *arg; int alen, elen; if (parse_space (parser)) return 0; if (!(arg = parse_exp (parser, 0, 0))) return 0; alen = btor_get_exp_len (parser->btor, arg); if (parse_space (parser)) { RELEASE_ARG_AND_RETURN_ERROR: btor_release_exp (parser->btor, arg); return 0; } if (parse_non_negative_int (parser, &elen)) goto RELEASE_ARG_AND_RETURN_ERROR; if (alen + elen != len) { (void) btor_perr_btor (parser, "argument length of %d plus %d does not match %d", alen, elen, len); goto RELEASE_ARG_AND_RETURN_ERROR; } res = f (parser->btor, arg, elen); assert (btor_get_exp_len (parser->btor, res) == len); btor_release_exp (parser->btor, arg); return res; }
struct expression *parse_exp() { struct expression *term = parse_term(); if (is_empty_expression(term)) return NULL; if (current_token == NULL) return NULL; switch (current_token->type) { case OpAnd: advanceToken(); struct expression *exp = new_op_expression(AndExp, term, parse_exp()); if (is_right_child_empty(exp)) { destroy_expression(exp); return NULL; } return exp; default: return term; } }
int parse_input(const char *file_in, int set_used) { FILE *f; char *s; int c, length = 0; parse_result pc; if(strcmp(file_in, "-") == 0) f = stdin; else f = fopen(file_in, "r"); if(!f) return -1; /* error opening file */ /* we now read in the file and parse */ /* note: 40 is just a starter length, it is not a maximum */ length = 40; s = (char *)malloc(length + 1); do{ c = parse_get_line(f, &s, &length); if(*s){ if(strncmp("include ", s, 8) == 0 ){ /* include another file */ /* wipe out leading 'include' with blanks */ strncpy(s, " ", 7); str_trim(s); if(!disable_write) fprintf(fout, "# including file '%s'\n", s); c = parse_input(s, 0); if(c != 0) { fprintf(stderr, "Parser error: cannot open included file '%s'.\n", s); exit(1); } } else if(*s == '%'){ /* we have a block */ *s = ' '; str_trim(s); if(getsym(s) != NULL){ /* error */ fprintf(stderr, "Parser warning: %s \"%s\" %s.\n", "Block", s, "already defined"); do{ /* skip block */ c = parse_get_line(f, &s, &length); }while(c != EOF && *s != '%'); }else{ /* parse block */ symrec *rec; rec = putsym(s, S_BLOCK); rec->value.block = (sym_block *)malloc(sizeof(sym_block)); rec->value.block->n = 0; rec->value.block->lines = NULL; do{ c = parse_get_line(f, &s, &length); if(*s && *s != '%'){ char *s1, *tok; int l, col; l = rec->value.block->n; rec->value.block->n++; rec->value.block->lines = (sym_block_line *) realloc((void *)rec->value.block->lines, sizeof(sym_block_line)*(l+1)); rec->value.block->lines[l].n = 0; rec->value.block->lines[l].fields = NULL; /* parse columns */ for(s1 = s; (tok = strtok(s1, "|\t")) != NULL; s1 = NULL){ char *tok2 = strdup(tok); str_trim(tok2); col = rec->value.block->lines[l].n; rec->value.block->lines[l].n++; rec->value.block->lines[l].fields = (char **) realloc((void *)rec->value.block->lines[l].fields, sizeof(char *)*(col+1)); rec->value.block->lines[l].fields[col] = tok2; } } }while(c != EOF && *s != '%'); } }else{ /* we can parse it np */ parse_exp(s, &pc); } } }while(c != EOF); free(s); if(f != stdin) fclose(f); if(set_used == 1) sym_mark_table_used(); return 0; }
shared_ptr<exp> Parser::parse() { cur = tokens.begin(); end = tokens.end(); return parse_exp(); }
shared_ptr<exp> Parser::parse_exp() { if (isNumeric(*cur)) { return shared_ptr<exp>{new num(std::stoi(*cur++))}; } else if (*cur == "(") { string first = *++cur; cur++; if (first == "+") { return shared_ptr<exp>{new add(parse_until_close())}; } else if (first == "-") { return shared_ptr<exp>{new sub(parse_until_close())}; } else if (first == "*") { return shared_ptr<exp>{new mul(parse_until_close())}; } else if (first == "/") { return shared_ptr<exp>{new expressions::div(parse_until_close())}; } else if (first == "lambda") { if (*cur != "(") throw "ill-formed lambda"; cur++; list<string> params; while (*cur != ")" && cur != end) { params.push_back(*cur); cur++; } if (*cur != ")") throw "ill-formed lambda"; cur++; shared_ptr<exp> body = parse_exp(); if (*cur != ")") throw "ill-formed lambda"; cur++; return shared_ptr<exp>{new lambda(params, body)}; } else if (first == "if0") { list<shared_ptr<exp>> exps = parse_until_close(); if (exps.size() != 3) throw "ill-formed if0"; shared_ptr<exp> t = exps.front(); exps.pop_front(); shared_ptr<exp> tb = exps.front(); exps.pop_front(); shared_ptr<exp> fb = exps.front(); return shared_ptr<exp>{new if0(t, tb, fb)}; } else if (first == "let") { if (*cur != "(") throw "ill-formed let"; if (*++cur != "[") throw "ill-formed let"; string id = *++cur; cur++; shared_ptr<exp> bound = parse_exp(); if (*cur != "]") throw "ill-formed let"; if (*++cur != ")") throw "ill-formed let"; cur++; shared_ptr<exp> body = parse_exp(); if (*cur != ")") throw "ill-formed let"; cur++; return shared_ptr<exp>{new let(id, bound, body)}; } else { cur--; return shared_ptr<exp>{new app(parse_until_close())}; } } else { // any other token is a variable auto tv = *cur; cur++; return shared_ptr<exp>{new var(tv)}; } }
static void get_operand (char **ptr, struct z8k_op *mode, unsigned int dst ATTRIBUTE_UNUSED) { char *src = *ptr; char *end; mode->mode = 0; while (*src == ' ') src++; if (*src == '#') { mode->mode = CLASS_IMM; imm_operand = &(mode->exp); src = parse_exp (src + 1, &(mode->exp)); } else if (*src == '@') { mode->mode = CLASS_IR; src = parse_reg (src + 1, &mode->regsize, &mode->reg); } else { unsigned int regn; end = parse_reg (src, &mode->mode, ®n); if (end) { int nw; unsigned int nr; src = end; if (*src == '(') { src++; end = parse_reg (src, &nw, &nr); if (end) { /* Got Ra(Rb). */ src = end; if (*src != ')') as_bad (_("Missing ) in ra(rb)")); else src++; regaddr (mode->mode, "ra(rb) ra"); mode->mode = CLASS_BX; mode->reg = regn; mode->x_reg = nr; reg[ARG_RX] = nr; } else { /* Got Ra(disp). */ if (*src == '#') src++; src = parse_exp (src, &(mode->exp)); src = checkfor (src, ')'); mode->mode = CLASS_BA; mode->reg = regn; mode->x_reg = 0; imm_operand = &(mode->exp); } } else { mode->reg = regn; mode->x_reg = 0; } } else { /* No initial reg. */ src = parse_exp (src, &(mode->exp)); if (*src == '(') { src++; end = parse_reg (src, &(mode->mode), ®n); regword (mode->mode, "addr(Ra) ra"); mode->mode = CLASS_X; mode->reg = regn; mode->x_reg = 0; da_operand = &(mode->exp); src = checkfor (end, ')'); } else { /* Just an address. */ mode->mode = CLASS_DA; mode->reg = 0; mode->x_reg = 0; da_operand = &(mode->exp); } } } *ptr = src; }
int parse_input(char *file_in) { FILE *f; char *s; int c, length = 0; if(strcmp(file_in, "-") == 0) f = stdin; else f = fopen(file_in, "r"); if(!f) return -1; /* error opening file */ /* we now read in the file and parse */ length = 40; s = (char *)malloc(length + 1); do{ c = parse_get_line(f, &s, &length); if(*s){ if(*s == '%'){ /* we have a block */ *s = ' '; str_trim(s); if(getsym(s) != NULL){ /* error */ fprintf(stderr, "%s \"%s\" %s", "Block", s, "already defined"); do{ /* skip block */ c = parse_get_line(f, &s, &length); }while(c != EOF && *s != '%'); }else{ /* parse block */ symrec *rec; rec = putsym(s, S_BLOCK); rec->value.block = (sym_block *)malloc(sizeof(sym_block)); rec->value.block->n = 0; rec->value.block->lines = NULL; do{ c = parse_get_line(f, &s, &length); if(*s && *s != '%'){ char *s1, *tok; int l, col; l = rec->value.block->n; rec->value.block->n++; rec->value.block->lines = (sym_block_line *) realloc((void *)rec->value.block->lines, sizeof(sym_block_line)*(l+1)); rec->value.block->lines[l].n = 0; rec->value.block->lines[l].fields = NULL; /* parse columns */ for(s1 = s; (tok = strtok(s1, "|\t")) != NULL; s1 = NULL){ char *tok2 = strdup(tok); str_trim(tok2); col = rec->value.block->lines[l].n; rec->value.block->lines[l].n++; rec->value.block->lines[l].fields = (char **) realloc((void *)rec->value.block->lines[l].fields, sizeof(char *)*(col+1)); rec->value.block->lines[l].fields[col] = tok2; } } }while(c != EOF && *s != '%'); } }else{ /* we can parse it np */ parse_result c; parse_exp(s, &c); } } }while(c != EOF); free(s); if(f != stdin) fclose(f); #define OCT_ENV_HEADER "OCT_" /*now read options from environment variables (by X) */ if( getenv("OCT_PARSE_ENV")!=NULL ) { /* environ is an array of C strings with all the environment variables, the format of the string is NAME=VALUE, which is directly recognized by parse_exp */ char **env = environ; while(*env) { /* Only consider variables that begin with OCT_ */ if( strncmp(OCT_ENV_HEADER, *env, strlen(OCT_ENV_HEADER)) == 0 ){ parse_result c; parse_exp( (*env) + strlen(OCT_ENV_HEADER), &c); } env++; } } sym_clear_reserved(); return 0; }
static BtorNode * parse_compare_and_overflow (BtorBTORParser * parser, int len, Binary f, int can_be_array) { BtorNode *l, *r, *res; int llen, rlen; if (len != 1) { (void) btor_perr_btor (parser, "comparison or overflow operator returns %d bits", len); return 0; } if (parse_space (parser)) return 0; if (!(l = parse_exp (parser, 0, can_be_array))) return 0; if (parse_space (parser)) { RELEASE_L_AND_RETURN_ERROR: btor_release_exp (parser->btor, l); return 0; } if (!(r = parse_exp (parser, 0, can_be_array))) goto RELEASE_L_AND_RETURN_ERROR; llen = btor_get_exp_len (parser->btor, l); rlen = btor_get_exp_len (parser->btor, r); if (llen != rlen) { (void) btor_perr_btor (parser, "operands have different bit width %d and %d", llen, rlen); RELEASE_L_AND_R_AND_RETURN_ZERO: btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); return 0; } if (can_be_array) { if (btor_is_array_exp (parser->btor, l) && !btor_is_array_exp (parser->btor, r)) { (void) btor_perr_btor (parser, "first operand is array and second not"); goto RELEASE_L_AND_R_AND_RETURN_ZERO; } if (!btor_is_array_exp (parser->btor, l) && btor_is_array_exp (parser->btor, r)) { (void) btor_perr_btor (parser, "second operand is array and first not"); goto RELEASE_L_AND_R_AND_RETURN_ZERO; } if (btor_is_array_exp (parser->btor, l) && btor_is_array_exp (parser->btor, r)) { llen = btor_get_index_exp_len (parser->btor, l); rlen = btor_get_index_exp_len (parser->btor, r); if (llen != rlen) { (void) btor_perr_btor ( parser, "array operands have different index width %d and %d", llen, rlen); goto RELEASE_L_AND_R_AND_RETURN_ZERO; } } } res = f (parser->btor, l, r); btor_release_exp (parser->btor, r); btor_release_exp (parser->btor, l); assert (btor_get_exp_len (parser->btor, res) == 1); return res; }