// Expands the given macro application form.
static Obj *macroexpand(void *root, Obj **env, Obj **obj) {
if ((*obj)->type != TCELL || (*obj)->car->type != TSYMBOL)
return *obj;
DEFINE3(bind, macro, args);
*bind = find(env, (*obj)->car);
if (!*bind || (*bind)->cdr->type != TMACRO)
return *obj;
*macro = (*bind)->cdr;
*args = (*obj)->cdr;
return apply_func(root, env, macro, args);
}
// Apply fn with args.
static Obj *apply(void *root, Obj **env, Obj **fn, Obj **args) {
if (!is_list(*args))
error("argument must be a list");
if ((*fn)->type == TPRIMITIVE)
return (*fn)->fn(root, env, args);
if ((*fn)->type == TFUNCTION) {
DEFINE1(eargs);
*eargs = eval_list(root, env, args);
return apply_func(root, env, fn, eargs);
}
error("not supported");
}
void filters_apply(unsigned char *frame)
{
int i;
void (*apply_func)(unsigned char *frame);
for(i = 0; filter_funcs[i]; i++)
{
if(filter_enabled[i])
{
apply_func = filter_funcs[i];
apply_func(frame);
}
}
}
ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
{
Bucket *p;
IS_CONSISTENT(ht);
HASH_PROTECT_RECURSION(ht);
p = ht->pListHead;
while (p != NULL) {
int result = apply_func(p->pData TSRMLS_CC);
if (result & ZEND_HASH_APPLY_REMOVE) {
p = zend_hash_apply_deleter(ht, p);
} else {
p = p->pListNext;
}
if (result & ZEND_HASH_APPLY_STOP) {
break;
}
}
HASH_UNPROTECT_RECURSION(ht);
}
int main(int argc, char **argv)
{
if(argc != 2)
{
printf("Usage: %s double\n", argv[0]);
return EXIT_FAILURE;
}
errno = 0;
char *endptr;
double val = strtod(argv[1], &endptr);
if(errno || argv[1] == endptr)
{
fprintf(stderr, "%s\n", "strtod");
return EXIT_FAILURE;
}
apply_func(val);
return EXIT_SUCCESS;
}
bool gen_rule::__apply(const uint x, const uint y, gen_sudoku* s) const{
return apply_func(x, y, s);
}
static MUST_CHECK value_t calc2(oper_t op) {
value_t v1 = op->v1, v2 = op->v2;
enum func_e func;
struct values_s *v;
size_t args;
struct oper_s oper;
switch (v2->obj->type) {
case T_FUNCTION:
switch (op->op->u.oper.op) {
case O_CMP:
if (v1->u.function.func < v1->u.function.func) return int_from_int(-1);
return val_reference(int_value[v1->u.function.func > v2->u.function.func]);
case O_EQ: return truth_reference(v1->u.function.func == v2->u.function.func);
case O_NE: return truth_reference(v1->u.function.func != v2->u.function.func);
case O_LT: return truth_reference(v1->u.function.func < v2->u.function.func);
case O_LE: return truth_reference(v1->u.function.func <= v2->u.function.func);
case O_GT: return truth_reference(v1->u.function.func > v2->u.function.func);
case O_GE: return truth_reference(v1->u.function.func >= v2->u.function.func);
default: break;
}
break;
case T_FUNCARGS:
v = v2->u.funcargs.val;
args = v2->u.funcargs.len;
switch (op->op->u.oper.op) {
case O_FUNC:
func = v1->u.function.func;
switch (func) {
case F_HYPOT:
case F_ATAN2:
case F_POW:
if (args != 2) {
err_msg_argnum(args, 2, 2, op->epoint2);
return val_reference(none_value);
}
oper.v1 = v[0].val;
oper.v2 = v[1].val;
oper.epoint = &v[0].epoint;
oper.epoint2 = &v[1].epoint;
oper.epoint3 = op->epoint;
return apply_func2(&oper, func);
case F_RANGE: return function_range(v2, op->epoint2);
case F_FORMAT: return isnprintf(v2, op->epoint);
default:
if (args != 1) {
err_msg_argnum(args, 1, 1, op->epoint2);
return val_reference(none_value);
}
return apply_func(v[0].val, func, &v[0].epoint);
}
default: break;
}
break;
case T_NONE:
case T_ERROR:
case T_LIST:
case T_TUPLE:
case T_DICT:
if (op->op != &o_MEMBER && op->op != &o_INDEX && op->op != &o_X) {
return v2->obj->rcalc2(op);
}
default: break;
}
return obj_oper_error(op);
}
static MUST_CHECK value_t apply_func(value_t v1, enum func_e func, linepos_t epoint) {
value_t err, v;
double real;
switch (func) {
case F_ANY: return v1->obj->truth(v1, TRUTH_ANY, epoint);
case F_ALL: return v1->obj->truth(v1, TRUTH_ALL, epoint);
case F_LEN: return v1->obj->len(v1, epoint);
default: break;
}
if (v1->obj == TUPLE_OBJ || v1->obj == LIST_OBJ) {
if (v1->u.list.len) {
int error = 1;
size_t i;
value_t *vals;
v = val_alloc(v1->obj);
vals = list_create_elements(v, v1->u.list.len);
for (i = 0; i < v1->u.list.len; i++) {
value_t val = apply_func(v1->u.list.data[i], func, epoint);
if (val->obj == ERROR_OBJ) { if (error) {err_msg_output(val); error = 0;} val_destroy(val); val = val_reference(none_value); }
vals[i] = val;
}
v->u.list.len = i;
v->u.list.data = vals;
return v;
}
return val_reference(v1);
}
switch (func) {
case F_SIZE: return v1->obj->size(v1, epoint);
case F_SIGN: return v1->obj->sign(v1, epoint);
case F_ABS: return v1->obj->abs(v1, epoint);
case F_REPR: return v1->obj->repr(v1, epoint);
default: break;
}
err = FLOAT_OBJ->create(v1, epoint);
if (err->obj != FLOAT_OBJ) return err;
real = err->u.real;
val_destroy(err);
switch (func) {
case F_FLOOR: real = floor(real);break;
case F_CEIL: real = ceil(real);break;
case F_SQRT:
if (real < 0.0) {
return new_error_obj(ERROR_SQUARE_ROOT_N, epoint);
}
real = sqrt(real);
break;
case F_LOG10:
if (real <= 0.0) {
return new_error_obj(ERROR_LOG_NON_POSIT, epoint);
}
real = log10(real);
break;
case F_LOG:
if (real <= 0.0) {
return new_error_obj(ERROR_LOG_NON_POSIT, epoint);
}
real = log(real);
break;
case F_EXP: real = exp(real);break;
case F_SIN: real = sin(real);break;
case F_COS: real = cos(real);break;
case F_TAN: real = tan(real);break;
case F_ACOS:
if (real < -1.0 || real > 1.0) {
return new_error_obj(ERROR___MATH_DOMAIN, epoint);
}
real = acos(real);
break;
case F_ASIN:
if (real < -1.0 || real > 1.0) {
return new_error_obj(ERROR___MATH_DOMAIN, epoint);
}
real = asin(real);
break;
case F_ATAN: real = atan(real);break;
case F_CBRT: real = cbrt(real);break;
case F_ROUND: real = round(real);break;
case F_TRUNC: real = trunc(real);break;
case F_FRAC: real -= trunc(real);break;
case F_RAD: real = real * M_PI / 180.0;break;
case F_DEG: real = real * 180.0 / M_PI;break;
case F_COSH: real = cosh(real);break;
case F_SINH: real = sinh(real);break;
case F_TANH: real = tanh(real);break;
default: real = HUGE_VAL; break; /* can't happen */
}
return float_from_double2(real, epoint);
}
typename super_t::reference dereference() const
{
apply_func();
return *this->base();
}
inline bool apply (OT::hb_apply_context_t *c) const { return apply_func (obj, c); }
