int main(int argc, char *argv[]) { int res; if (strcmp(argv[0], "[") == 0) { if (strcmp(argv[--argc], "]")) errx(2, "missing ]"); argv[argc] = NULL; } /* Implement special cases from POSIX.2, section 4.62.4 */ switch (argc) { case 1: return 1; case 2: return (*argv[1] == '\0'); case 3: if (argv[1][0] == '!' && argv[1][1] == '\0') { return !(*argv[2] == '\0'); } break; case 4: if (argv[1][0] != '!' || argv[1][1] != '\0') { if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1]; return (binop() == 0); } } break; case 5: if (argv[1][0] == '!' && argv[1][1] == '\0') { if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[2]; return !(binop() == 0); } } break; } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) syntax(*t_wp, "unknown operand"); return res; }
extern int test_main(int argc, char** argv) { int res; if (strcmp(applet_name, "[") == 0) { if (strcmp(argv[--argc], "]")) error_msg_and_die("missing ]"); argv[argc] = NULL; } /* Implement special cases from POSIX.2, section 4.62.4 */ switch (argc) { case 1: exit( 1); case 2: exit (*argv[1] == '\0'); case 3: if (argv[1][0] == '!' && argv[1][1] == '\0') { exit (!(*argv[2] == '\0')); } break; case 4: if (argv[1][0] != '!' || argv[1][1] != '\0') { if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1]; exit (binop() == 0); } } break; case 5: if (argv[1][0] == '!' && argv[1][1] == '\0') { if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[2]; exit (!(binop() == 0)); } } break; } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) syntax(*t_wp, "unknown operand"); return( res); }
void EvalStack::exec(char chr) { AttributeValue a, b, c; switch (chr) { case '+': case '-': case '*': case '/': case '>': case '<': case funcMin: case funcMax: case funcTable: if (vals.size() < 2) return; b = vals.top(); vals.pop(); a = vals.top(); vals.pop(); vals.push(binop(a, b, chr)); break; case '~': if (vals.size() < 1) return; if (vals.top().text.empty()) { a = vals.top(); vals.pop(); vals.emplace(-a.max, -a.min); } break; case ':': if (vals.size() < 3) return; c = vals.top(); vals.pop(); b = vals.top(); vals.pop(); a = vals.top(); vals.pop(); vals.push(a.max ? b : c); break; } }
extern "C" PyObject* PyNumber_And(PyObject* lhs, PyObject* rhs) { try { return binop(lhs, rhs, AST_TYPE::BitAnd); } catch (Box* b) { Py_FatalError("unimplemented"); } }
/* <value to be concatenated onto named parameter> . */ void o_catassign (memel *argp) { char *pname = (char *) argp; char *pk, *t, *p, *f; char s1[1024+1]; struct operand o1, o2; struct param *pp; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); paramget (pp, *f); /* If param value is undefined merely assign into it, otherwise * concatenate operand to current value. */ o1 = popop(); if (!opundef(&o1)) { /* Must copy string value off of operand stack or the next * pushop below will reuse the space! */ o2 = popop(); strncpy (s1, o2.o_val.v_s, 1024); s1[1024] = EOS; o2.o_val.v_s = s1; pushop (&o1); pushop (&o2); binop (OP_CONCAT); } paramset (pp, *f); pp->p_flags |= P_SET; }
int bb_test(int argc, char **argv) { int res; if (LONE_CHAR(argv[0], '[')) { --argc; if (NOT_LONE_CHAR(argv[argc], ']')) { bb_error_msg("missing ]"); return 2; } argv[argc] = NULL; } else if (strcmp(argv[0], "[[") == 0) { --argc; if (strcmp(argv[argc], "]]")) { bb_error_msg("missing ]]"); return 2; } argv[argc] = NULL; } res = setjmp(leaving); if (res) return res; /* resetting ngroups is probably unnecessary. it will * force a new call to getgroups(), which prevents using * group data fetched during a previous call. but the * only way the group data could be stale is if there's * been an intervening call to setgroups(), and this * isn't likely in the case of a shell. paranoia * prevails... */ ngroups = 0; /* Implement special cases from POSIX.2, section 4.62.4 */ if (argc == 1) return 1; if (argc == 2) return *argv[1] == '\0'; //assert(argc); if (LONE_CHAR(argv[1], '!')) { bool _off; if (argc == 3) return *argv[2] != '\0'; _off = argc - 4; t_lex(argv[2 + _off]); if (t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1 + _off]; return binop() == 0; } } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) { bb_error_msg("%s: unknown operand", *t_wp); return 2; } return res; }
static arith_t primary(enum token n) { arith_t res; if (n == EOI) { syntax(NULL, "argument expected"); } if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); default: return filstat(*t_wp, n); } } if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
static struct IntAndTable interpExp(A_exp exp, Table_ t) { struct IntAndTable ret; assert (exp != NULL); if (exp->kind == A_idExp) { ret.i = lookup(t, exp->u.id); ret.t = t; return ret; } else if (exp->kind == A_numExp) { ret.i = exp->u.num; ret.t = t; return ret; } else if (exp->kind == A_opExp) { struct IntAndTable left_iat = interpExp(exp->u.op.left, t); struct IntAndTable right_iat = interpExp(exp->u.op.right, left_iat.t); ret.i = binop(left_iat.i, right_iat.i, exp->u.op.oper); ret.t = right_iat.t; return ret; } else { assert (exp->kind == A_eseqExp); t = interpStm(exp->u.eseq.stm, t); return interpExp(exp->u.eseq.exp, t); } }
void XMLAstVisitor::createLogicBinop(Binop *node, std::string op) { xml::Node binop("LogicBinop", xml::Namespace::math); binop.setAttribute("op", op); binop.addChild(this->accept(node->getLeft())); binop.addChild(this->accept(node->getRight())); this->setValue(binop); }
static arith_t primary(enum token n) { arith_t res; if (n == EOI) { syntax(NULL, "argument expected"); } if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); if (n == STREZ) return t_wp[0][0] == '\0'; if (n == STRNZ) return t_wp[0][0] != '\0'; if (n == FILTT) return isatty(getn(*t_wp)); return filstat(*t_wp, n); } t_lex(t_wp[1]); if (t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return t_wp[0][0] != '\0'; }
/* The code below starts the part that still needs reworking for the * new geometry based tokens/logic */ static int primary(enum token n, struct exists_data *ed) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { ed->t_wp_op = NULL; if ((nn = t_lex(*++(ed->t_wp), ed)) == RPAREN) return 0; /* missing expression */ res = oexpr(nn, ed); if (t_lex(*++(ed->t_wp), ed) != RPAREN) { bu_vls_printf(ed->message , "closing paren expected"); return 0; } return res; } if (ed->t_wp_op && ed->t_wp_op->op_type == UNOP) { /* unary expression */ if (!ed->no_op) { if (*++(ed->t_wp) == NULL) { bu_vls_printf(ed->message , "argument expected"); return 0; } } switch (n) { case OCOMB: bu_log("comb case"); /*return is_comb();*/ case OEXIST: return db_object_exists(ed); /*return db_lookup();*/ case ONULL: bu_log("null case"); /*return is_null();*/ case ONNULL: /* default case */ return db_object_exists_and_non_null(ed); case OPRIM: bu_log("primitive case"); /*return is_prim();*/ case OBVOL: bu_log("bounding volume case"); /*return has_vol();*/ default: /* not reached */ return 0; } } if (t_lex(ed->t_wp[1], ed), ed->t_wp_op && ed->t_wp_op->op_type == BINOP) { return binop(ed); } return 0; }
/* Store a value to memory. If a value requires more than 8 bytes a series of 8-byte stores will be generated. */ static __inline__ void store(IRSB *irsb, IREndness endian, HWord haddr, IRExpr *data) { IROp high, low; IRExpr *addr, *next_addr; if (VEX_HOST_WORDSIZE == 8) { addr = mkU64(haddr); next_addr = binop(Iop_Add64, addr, mkU64(8)); } else if (VEX_HOST_WORDSIZE == 4) { addr = mkU32(haddr); next_addr = binop(Iop_Add32, addr, mkU32(8)); } else { vpanic("invalid #bytes for address"); } IRType type = typeOfIRExpr(irsb->tyenv, data); vassert(type == Ity_I1 || sizeofIRType(type) <= 16); switch (type) { case Ity_I128: high = Iop_128HIto64; low = Iop_128to64; goto store128; case Ity_F128: high = Iop_F128HItoF64; low = Iop_F128LOtoF64; goto store128; case Ity_D128: high = Iop_D128HItoD64; low = Iop_D128LOtoD64; goto store128; store128: /* Two stores of 64 bit each. */ if (endian == Iend_BE) { /* The more significant bits are at the lower address. */ store_aux(irsb, endian, addr, unop(high, data)); store_aux(irsb, endian, next_addr, unop(low, data)); } else { /* The more significant bits are at the higher address. */ store_aux(irsb, endian, addr, unop(low, data)); store_aux(irsb, endian, next_addr, unop(high, data)); } return; default: store_aux(irsb, endian, addr, data); return; } }
/* Load a value from memory. Loads of more than 8 byte are split into a series of 8-byte loads and combined using appropriate IROps. */ static IRExpr * load(IREndness endian, IRType type, HWord haddr) { IROp concat; IRExpr *addr, *next_addr; vassert(type == Ity_I1 || sizeofIRType(type) <= 16); if (VEX_HOST_WORDSIZE == 8) { addr = mkU64(haddr); next_addr = binop(Iop_Add64, addr, mkU64(8)); } else if (VEX_HOST_WORDSIZE == 4) { addr = mkU32(haddr); next_addr = binop(Iop_Add32, addr, mkU32(8)); } else { vpanic("invalid #bytes for address"); } switch (type) { case Ity_I128: concat = Iop_64HLto128; type = Ity_I64; goto load128; case Ity_F128: concat = Iop_F64HLtoF128; type = Ity_F64; goto load128; case Ity_D128: concat = Iop_D64HLtoD128; type = Ity_D64; goto load128; load128: /* Two loads of 64 bit each. */ if (endian == Iend_BE) { /* The more significant bits are at the lower address. */ return binop(concat, load_aux(endian, type, addr), load_aux(endian, type, next_addr)); } else { /* The more significant bits are at the higher address. */ return binop(concat, load_aux(endian, type, next_addr), load_aux(endian, type, addr)); } default: return load_aux(endian, type, addr); } }
int subt(void){ arg1=pop(); EMPTYS; savk = sunputc(arg1); chsign(arg1); sputc(arg1,savk); pushp(arg1); if(eqk() != 0)return(1); binop('+'); return(0); }
expr *parse_expr() { expr *l = parse_term(); char c = getchar(); while (c != '\n' && (c == '+' || c == '-')) { expr *r = parse_term(); l = binop(c, l, r); c = getchar(); } ungetc(c, stdin); return l; }
/* Given a, possibly abbreviated, function name to run, look it up and * run it if found. it gets nargs arguments from the operand stack. */ void intrfunc (char *fname, int nargs) { int op_index, op; int i, n, subi[2]; int trim_side = TRIM_LEFT|TRIM_RIGHT; char *trim = " \t"; char sbuf[SZ_LINE+1]; struct operand o; op_index = keyword (ifnames, fname); if (op_index == KWBAD) cl_error (E_UERR, "unknown function `%s'", fname); if (op_index == KWAMBIG) cl_error (E_UERR, "ambiguous function `%s'", fname); op = optbl[op_index]; /* if do this by shifting the cases and op to the right OP_BITS, this * will compile as a jump table. not worth it until it gets larger. */ switch (op & ~OP_MASK) { case UNOP: if (nargs != 1) cl_error (E_UERR, e_onearg, ifnames[op_index]); unop (op & OP_MASK); break; case BINOP: if (nargs != 2) cl_error (E_UERR, e_twoargs, ifnames[op_index]); binop (op & OP_MASK); break; case MULTOP: multop (op & OP_MASK, op_index, nargs); break; case VOCOP: vocop (op & OP_MASK, op_index, nargs); break; case SAMPOP: sampop (op & OP_MASK, op_index, nargs); break; default: err: cl_error (E_IERR, e_badsw, op, "intrfunc()"); } }
/* <value to be multiplied into named parameter> . */ void o_mulassign (memel *argp) { char *pname = (char *) argp; char *pk, *t, *p, *f; struct param *pp; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); validparamget (pp, *f); binop (OP_MUL); paramset (pp, *f); pp->p_flags |= P_SET; }
void cpp_from_isl::process_for(isl_ast_node *node) { auto iter_expr = isl_ast_node_for_get_iterator(node); auto init_expr = isl_ast_node_for_get_init(node); auto cond_expr = isl_ast_node_for_get_cond(node); auto inc_expr = isl_ast_node_for_get_inc(node); auto body_node = isl_ast_node_for_get_body(node); auto iter = process_expr(iter_expr); auto init = process_expr(init_expr); auto cond = process_expr(cond_expr); auto inc = process_expr(inc_expr); auto iter_id = dynamic_pointer_cast<id_expression>(iter); if (!iter_id) throw error("Iterator expression is not an identifier."); auto iter_decl = decl_expr(make_shared<basic_type>("int"), *iter_id, init); auto for_stmt = make_shared<for_statement>(); for_stmt->initialization = iter_decl; for_stmt->condition = cond; for_stmt->update = binop(op::assign_add, iter, inc); { vector<statement_ptr> stmts; m_ctx->push(&stmts); process_node(body_node); m_ctx->pop(); if (stmts.size() == 1) for_stmt->body = stmts.front(); else for_stmt->body = block(stmts); } m_ctx->add(for_stmt); isl_ast_expr_free(iter_expr); isl_ast_expr_free(init_expr); isl_ast_expr_free(cond_expr); isl_ast_expr_free(inc_expr); isl_ast_node_free(body_node); }
static arith_t and(int token, union yystype *val, int op, int noeval) { arith_t a = binop(token, val, op, noeval); arith_t b; op = last_token; if (op != ARITH_AND) return a; token = yylex(); *val = yylval; b = and(token, val, yylex(), noeval | !a); return a && b; }
static int primary(enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { if ((nn = t_lex(++t_wp)) == RPAREN) return 0; /* missing expression */ res = oexpr(nn); if (t_lex(++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); #ifdef HAVE_FACCESSAT case FILRD: return test_file_access(*t_wp, R_OK); case FILWR: return test_file_access(*t_wp, W_OK); case FILEX: return test_file_access(*t_wp, X_OK); #endif default: return filstat(*t_wp, n); } } if (t_lex(t_wp + 1), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
static int primary(enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { parenlevel++; if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) == RPAREN) { parenlevel--; return 0; /* missing expression */ } res = oexpr(nn); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN) syntax(NULL, "closing paren expected"); parenlevel--; return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (--nargc == 0) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*++t_wp) == 0; case STRNZ: return strlen(*++t_wp) != 0; case FILTT: return isatty(getn(*++t_wp)); default: return filstat(*++t_wp, n); } } if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
/* <value to be divided into named parameter> . */ void o_divassign (memel *argp) { char *pname = (char *) argp; char *pk, *t, *p, *f; struct param *pp; struct operand o1, o2; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); validparamget (pp, *f); /* get param value on stack */ o1 = popop(); /* swap operands */ o2 = popop(); pushop (&o1); pushop (&o2); binop (OP_DIV); /* perform the division */ paramset (pp, *f); pp->p_flags |= P_SET; }
/* <value to be subtracted from named parameter> . */ void o_subassign (memel *argp) { /* operands are backwards on stack, so negate and add. can get by * with this as long as subtraction is never defined for strings. * if it is someday, will have to do something like in addassign. */ char *pname = (char *) argp; char *pk, *t, *p, *f; struct param *pp; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); unop (OP_MINUS); validparamget (pp, *f); binop (OP_ADD); paramset (pp, *f); pp->p_flags |= P_SET; }
void sobel(const imagev3* input, imagev3* output) { imagev3 kx(3, 3); imagev3 buffer(input->getWidth(), input->getHeight()); kx.set(0, 0, -la::v3::E) .set(0, 2, -la::v3::E) .set(2, 0, la::v3::E) .set(2, 2, la::v3::E) .set(0, 1, -la::v3::E * 2) .set(2, 1, la::v3::E * 2); convolve(input, &buffer, &kx); imagev3 ky(3, 3); ky.set(0, 0, -la::v3::E) .set(2, 0, -la::v3::E) .set(0, 2, la::v3::E) .set(2, 2, la::v3::E) .set(1, 0, -la::v3::E * 2) .set(1, 2, la::v3::E * 2); convolve(input, output, &ky); binop(&buffer, output, output, imageop::com); }
static int primary(enum token n) { int res; if (n == EOI) syntax(NULL, "argument expected"); if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } /* * We need this, if not binary operations with more than 4 * arguments will always fall into unary. */ if(t_lex_type(t_wp[1]) == BINOP) { t_lex(t_wp[1]); if (t_wp_op && t_wp_op->op_type == BINOP) return binop(); } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); default: return filstat(*t_wp, n); } } return strlen(*t_wp) > 0; }
/* <increment to be added to named parameter> . */ void o_addassign (memel *argp) { /* order of operands will be incorrect. * strictly speaking, only strings are not commutative but we need * to pop both operands anyway to check. */ char *pname = (char *) argp; char *pk, *t, *p, *f; struct param *pp; struct operand o1, o2; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); validparamget (pp, *f); o1 = popop(); o2 = popop(); if ((o2.o_type & OT_BASIC) == OT_STRING) { /* copy o2 onto dictionary to avoid overwriting it on stack * when o1 is pushed. we can get by with not worrying about o1 * as long as whatever code copies the string works when the * strings overlap. */ XINT oldtopd = topd; char *s2 = memneed (btoi (strlen (o2.o_val.v_s) + 1)); strcpy (s2, o2.o_val.v_s); o2.o_val.v_s = s2; pushop (&o1); pushop (&o2); topd = oldtopd; /* discard temp string area */ } else { pushop (&o1); pushop (&o2); } binop (OP_ADD); paramset (pp, *f); pp->p_flags |= P_SET; }
static int primary(shinstance *psh, enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { if ((nn = t_lex(psh, *++psh->t_wp)) == RPAREN) return 0; /* missing expression */ res = oexpr(psh, nn); if (t_lex(psh, *++psh->t_wp) != RPAREN) syntax(psh, NULL, "closing paren expected"); return res; } if (psh->t_wp_op && psh->t_wp_op->op_type == UNOP) { /* unary expression */ if (*++psh->t_wp == NULL) syntax(psh, psh->t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*psh->t_wp) == 0; case STRNZ: return strlen(*psh->t_wp) != 0; case FILTT: return shfile_isatty(&psh->fdtab, getn(psh, *psh->t_wp)); default: return filstat(psh, *psh->t_wp, n); } } if (t_lex(psh, psh->t_wp[1]), psh->t_wp_op && psh->t_wp_op->op_type == BINOP) { return binop(psh); } return strlen(*psh->t_wp) > 0; }
static PyObject * _binop(PyObject* self, PyObject* args) { Imaging out; Imaging im1; Imaging im2; void (*binop)(Imaging, Imaging, Imaging); Py_ssize_t op, i0, i1, i2; if (!PyArg_ParseTuple(args, "nnnn", &op, &i0, &i1, &i2)) return NULL; out = (Imaging) i0; im1 = (Imaging) i1; im2 = (Imaging) i2; binop = (void*) op; binop(out, im1, im2); Py_INCREF(Py_None); return Py_None; }
/* <op1> <op2> . <op2 + op1> */ void o_add (void) { binop (OP_ADD); }
/* <op1> <op2> . <op1 ** op2> */ void o_dopow (void) { binop (OP_POW); }