Пример #1
0
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;
}
Пример #2
0
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);
}
Пример #3
0
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;
  }
}
Пример #4
0
extern "C" PyObject* PyNumber_And(PyObject* lhs, PyObject* rhs) {
    try {
        return binop(lhs, rhs, AST_TYPE::BitAnd);
    } catch (Box* b) {
        Py_FatalError("unimplemented");
    }
}
Пример #5
0
/* <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;
}
Пример #6
0
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;
}
Пример #7
0
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;
}
Пример #8
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);
  }
}
Пример #9
0
 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);
 }
Пример #10
0
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';
}
Пример #11
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;
}
Пример #12
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;
   }
}
Пример #13
0
/* 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);
   }
}
Пример #14
0
int
subt(void){
	arg1=pop();
	EMPTYS;
	savk = sunputc(arg1);
	chsign(arg1);
	sputc(arg1,savk);
	pushp(arg1);
	if(eqk() != 0)return(1);
	binop('+');
	return(0);
}
Пример #15
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;
}
Пример #16
0
/* 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()");
	}
}
Пример #17
0
/* <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;
}
Пример #18
0
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);
}
Пример #19
0
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;
}
Пример #20
0
Файл: test.c Проект: alimon/dash
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;
}
Пример #21
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;
}
Пример #22
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;
}
Пример #23
0
/* <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;
}
Пример #24
0
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);
}
Пример #25
0
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;
}
Пример #26
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;
}
Пример #27
0
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;
}
Пример #28
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;
}
Пример #29
0
/* <op1> <op2> . <op2 + op1>
 */
void 
o_add (void)
{
	binop (OP_ADD);
}
Пример #30
0
/* <op1> <op2> . <op1 ** op2>
 */
void 
o_dopow (void)
{
	binop (OP_POW);
}