// 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); }