add_action.c:	(void) apply(APPLY_INIT, dest, 0, ORIGIN_DRIVER);
add_action.c:	    (void) apply(APPLY_INIT, item, 0, ORIGIN_DRIVER);
add_action.c:	    (void) apply(APPLY_INIT, ob, 0, ORIGIN_DRIVER);
add_action.c:	(void) apply(APPLY_INIT, item, 0, ORIGIN_DRIVER);
add_action.c:	    ret = apply(s->function.s, s->ob, 1, where);
array.c:	    sv = apply(func, (v->item + i)->u.ob, 0, ORIGIN_EFUN);
array.c:	v = fp ? call_function_pointer(fp, numex + 1) : apply(func, ob, 1 + numex, ORIGIN_EFUN);
array.c:	    else v = apply(func, current_object, 1, ORIGIN_EFUN);
avltree.c:This code is hereby placed in the public domain, unless restrictions apply
backend.c:    apply(APPLY_LOGON, ob, 0, ORIGIN_DRIVER);
backend.c:     * Note that if it is in the apply_low cache, it will also
backend.c:    svp = apply(APPLY_CLEAN_UP, ob, 1, ORIGIN_DRIVER);
backend.c: * returned by apply() will be freed at next call of apply(), which means that
backend.c:    ret = apply_master_ob(APPLY_EPILOG, 1);
backend.c:  (void) apply_master_ob(APPLY_PRELOAD, 1);
backend.c:  int apply_valid_hide = 1, display_hidden = 0;
backend.c:      if (apply_valid_hide) {
backend.c:        apply_valid_hide = 0;
binaries.c:    ret = safe_apply_master_ob(APPLY_VALID_SAVE_BINARY, 1);
call_out.c:      (void) apply(cop->function.s, cop->ob, extra,
comm.c:    apply(APPLY_RECEIVE_SNOOP, snooper, 1, ORIGIN_DRIVER);
comm.c:        if (apply(APPLY_CATCH_TELL, ob, 1, ORIGIN_DRIVER))      
comm.c:                                    apply(APPLY_WINDOW_SIZE, ip->ob, 2, ORIGIN_DRIVER);
comm.c:                                    apply(APPLY_TERMINAL_TYPE, ip->ob, 1, ORIGIN_DRIVER);
comm.c:                                apply(APPLY_TELNET_SUBOPTION, ip->ob, 1, ORIGIN_DRIVER);
comm.c:                    apply(APPLY_PROCESS_INPUT, ip->ob, 1, ORIGIN_DRIVER);
comm.c:                        apply(APPLY_PROCESS_INPUT, ip->ob, 1, ORIGIN_DRIVER);
comm.c:                apply(APPLY_PROCESS_INPUT, ip->ob, 1, ORIGIN_DRIVER);
comm.c:    ret = apply_master_ob(APPLY_CONNECT, 1);
comm.c:    ret = apply(APPLY_PROCESS_INPUT, command_giver, 1, ORIGIN_DRIVER);
comm.c:     * getting called recursively by CLOSING.  safe_apply() should be
comm.c:        safe_apply(APPLY_NET_DEAD, ob, 0, ORIGIN_DRIVER);
comm.c:     * We must all references to input_to fields before the call to apply(),
comm.c:       (void) apply(function, ob, num_arg + 1, ORIGIN_INTERNAL);
comm.c:        else if (!apply(APPLY_WRITE_PROMPT, ip->ob, 0, ORIGIN_DRIVER)) {
comm.c:            apply(call_back->u.string, current_object, 2, ORIGIN_INTERNAL);
comm.c:            apply(call_back->u.string, current_object, 2, ORIGIN_INTERNAL);
comm.c:                apply(call_back->u.string, current_object, 2, ORIGIN_INTERNAL);
comm.c:                safe_apply(ipnumbertable[i].call_back.u.string, 
compile_file.c:    mret = apply_master_ob(APPLY_VALID_COMPILE_TO_C, 0);
crypt.c: *  This doesn't apply, of course, if you change any of the settings
ed.c:	safe_apply(exit_fn, exit_ob, 0, ORIGIN_INTERNAL);
ed.c:        res = safe_apply(ED_BUFFER->write_fn, ED_BUFFER->exit_ob, 2, ORIGIN_INTERNAL);
ed.c:        safe_apply(ED_BUFFER->write_fn, ED_BUFFER->exit_ob, 2, ORIGIN_INTERNAL);
ed.c:	ret = apply_master_ob(APPLY_MAKE_PATH_ABSOLUTE, 1);
ed.c:	ret = apply_master_ob(APPLY_SAVE_ED_SETUP, 2);
ed.c:    setup = apply_master_ob(APPLY_RETRIEVE_ED_SETUP, 1);
ed.c:    stmp = safe_apply_master_ob(APPLY_GET_ED_BUFFER_SAVE_FILE_NAME, 2);
ed.c:    setup = apply_master_ob(APPLY_RETRIEVE_ED_SETUP, 1);
ed.c:    stmp = apply_master_ob(APPLY_GET_ED_BUFFER_SAVE_FILE_NAME, 1);
edit_source.c:    int apply_number = 0;
edit_source.c:	    fprintf(out, "#define APPLY_%-30s\t%i\n", buf, apply_number++);
edit_source.c:	    fprintf(out, "#define APPLY_%-30s\t%i\n", buf, apply_number++);
edit_source.c:    fprintf(out, "\n#define NUM_MASTER_APPLIES\t%i\n\n#endif\n", apply_number);
efuns_main.c:    res = apply_master_ob(APPLY_VALID_BIND, 3);
efuns_main.c:             100 * ((double) apply_low_cache_hits / apply_low_call_others));
efuns_main.c:    outbuf_addv(ob, "call_others:     %10lu\n", apply_low_call_others);
efuns_main.c:    outbuf_addv(ob, "cache hits:      %10lu\n", apply_low_cache_hits);
efuns_main.c:    outbuf_addv(ob, "slots used:      %10lu\n", apply_low_slots_used);
efuns_main.c:                100 * ((double) apply_low_slots_used / APPLY_CACHE_SIZE));
efuns_main.c:    outbuf_addv(ob, "collisions:      %10lu\n", apply_low_collisions);
efuns_main.c:             100 * ((double) apply_low_collisions / apply_low_call_others));
efuns_main.c:    if (apply_low(funcname, ob, num_arg - 2) == 0) {    /* Function not found */
efuns_main.c:    ret = apply_master_ob(APPLY_VALID_LINK, 2);
eoperators.c:	/* Don't need to use apply() since we have the pointer directly;
file.c:    mret = safe_apply_master_ob(APPLY_LOG_ERROR, 2);
file.c: * Otherwise, the returned path is temporarily allocated by apply(), which
file.c: * means it will be deallocated at next apply().
file.c:	v = apply_master_ob(APPLY_VALID_WRITE, 3);
file.c:	v = apply_master_ob(APPLY_VALID_READ, 3);
file.c:	extern svalue_t apply_ret_value;
file.c:	free_svalue(&apply_ret_value, "check_valid_path");
file.c:	apply_ret_value.type = T_STRING;
file.c:	apply_ret_value.subtype = STRING_MALLOC;
file.c:	path = apply_ret_value.u.string = string_copy(path, "check_valid_path");
file.c:    extern svalue_t apply_ret_value;
file.c:    assign_svalue(&from_sv, &apply_ret_value);
file.c:    assign_svalue(&to_sv, &apply_ret_value);
file.c:    extern svalue_t apply_ret_value;
file.c:    assign_svalue(&from_sv, &apply_ret_value);
file.c:    assign_svalue(&to_sv, &apply_ret_value);
function.c:		free_svalue(&apply_ret_value, "call_function_pointer");
function.c:		    apply_ret_value = const0;
function.c:		    apply_ret_value = *sp--;
function.c:		return &apply_ret_value;
function.c:    free_svalue(&apply_ret_value, "call_function_pointer");
function.c:    apply_ret_value = *sp--;
function.c:    return &apply_ret_value;
grammar.tab.c:	    res = safe_apply_master_ob(APPLY_VALID_OVERRIDE, 3);
grammar.tab.c:	res = safe_apply_master_ob(APPLY_VALID_OVERRIDE, 3);
interpret.c:svalue_t apply_ret_value = {T_NUMBER};
interpret.c:    ret = apply_master_ob(APPLY_VALID_SHADOW, 1);
interpret.c:  v = apply(ftc->f.str, ftc->ob, n + ftc->narg, ORIGIN_EFUN);
interpret.c: * apply a function to it.
interpret.c:   * LPC must return a value. This does not apply to control
interpret.c: * the caller of apply().
interpret.c:static char debug_apply_fun[30];/* For debugging */
interpret.c:unsigned int apply_low_call_others = 0;
interpret.c:unsigned int apply_low_cache_hits = 0;
interpret.c:unsigned int apply_low_slots_used = 0;
interpret.c:unsigned int apply_low_collisions = 0;
interpret.c:void mark_apply_low_cache() {
interpret.c:int apply_low P3(char *, fun, object_t *, ob, int, num_arg)
interpret.c:    strncpy(debug_apply_fun, fun, sizeof(debug_apply_fun));
interpret.c:    debug_apply_fun[sizeof debug_apply_fun - 1] = '\0';
interpret.c:    DEBUG_CHECK(ob->flags & O_DESTRUCTED,"apply() on destructed object\n");
interpret.c:    apply_low_call_others++;
interpret.c:  apply_low_cache_hits++;
interpret.c:          "Bad csp after execution in apply_low.\n");
interpret.c:      apply_low_slots_used++;
interpret.c:      apply_low_collisions++;
interpret.c:    reference_prog(entry->oprogp, "apply_low() cache [oprogp]");
interpret.c:    reference_prog(entry->progp, "apply_low() cache [progp]");
interpret.c:          "Bad csp after execution in apply_low\n");
interpret.c:  reference_prog(entry->oprogp, "apply_low() cache [oprogp miss]");
interpret.c: * area in apply(), which will be overwritten by the next call to apply.
interpret.c:svalue_t *apply P4(char *, fun, object_t *, ob, int, num_arg,
interpret.c:    if (apply_low(fun, ob, num_arg) == 0)
interpret.c:    free_svalue(&apply_ret_value, "sapply");
interpret.c:    apply_ret_value = *sp--;
interpret.c:    return &apply_ret_value;
interpret.c:    "Bad csp after execution in apply_low\n");
interpret.c: * this is a "safe" version of apply
interpret.c: * after the apply. (such as the ed exit function, and the net_dead function).
interpret.c: * compared to a normal apply().  Use sparingly.
interpret.c:safe_apply P4(char *, fun, object_t *, ob, int, num_arg, int, where)
interpret.c:      ret = apply(fun, ob, num_arg, where);
interpret.c:  if (apply_low(func, ob, numargs)) *rptr = *sp--;
interpret.c: * This function is similar to apply(), except that it will not
interpret.c: * it's faster to just try to call it and check if apply() returns zero.
interpret.c:     * won't make the object_name() apply and save_context() might fail
main.c:    apply_master_ob(APPLY_FLAG, 1);
main.c:    apply_master_ob(APPLY_CRASH, 3);
master.c:svalue_t *apply_master_ob P2(int, fun, int, num_arg)
master.c:	    do_trace("master apply", master_applies[fun].func->name, "\n");
master.c:	free_svalue(&apply_ret_value, "apply_master_ob");
master.c:	apply_ret_value = *sp--;
master.c:	return &apply_ret_value;
master.c:svalue_t *safe_apply_master_ob P2(int, fun, int, num_arg)
master.c:    return safe_apply(applies_table[fun], master_ob, num_arg, ORIGIN_DRIVER);
master.c:    ret = apply_master_ob(APPLY_GET_ROOT_UID, 0);
master.c:	ret = apply_master_ob(APPLY_GET_BACKBONE_UID, 0);
md.c:    extern svalue_t apply_ret_value;
md.c:	mark_apply_low_cache();
md.c:	mark_svalue(&apply_ret_value);
object.c:    ret = apply_master_ob(APPLY_VALID_HIDE, 1);
object.c:    apply(APPLY_CATCH_TELL, ob, 1, ORIGIN_DRIVER);
object.c:    if (!apply(APPLY_RESET, ob, 0, ORIGIN_DRIVER)) {
object.c:    apply(APPLY_CREATE, ob, num_arg, ORIGIN_DRIVER);
parse.c:	ret = apply(APPLY_QGET_PLURID, ob, 0, ORIGIN_DRIVER);
parse.c:	ret = apply(APPLY_QGET_ID, ob, 0, ORIGIN_DRIVER);
parse.c:	ret = apply(APPLY_QGET_ADJID, ob, 0, ORIGIN_DRIVER);
parse.c:    pval = apply(APPLY_QGET_ID, master_ob, 0, ORIGIN_DRIVER);
parse.c:	pval->u.arr->ref++;	/* Otherwise next sapply will free it */
parse.c:    pval = apply(APPLY_QGET_PLURID, master_ob, 0, ORIGIN_DRIVER);
parse.c:	pval->u.arr->ref++;	/* Otherwise next sapply will free it */
parse.c:    pval = apply(APPLY_QGET_ADJID, master_ob, 0, ORIGIN_DRIVER);
parse.c:	pval->u.arr->ref++;	/* Otherwise next sapply will free it */
parse.c:    pval = apply_master_ob(APPLY_QGET_PREPOS, 0);
parse.c:	pval->u.arr->ref++;	/* Otherwise next sapply will free it */
parse.c:    pval = apply_master_ob(APPLY_QGET_ALLWORD, 0);
simulate.c:	value = apply_master_ob(APPLY_PRIVS_FILE, 1);
simulate.c:	value = apply(applies_table[APPLY_PRIVS_FILE], ob, 1, ORIGIN_DRIVER);
simulate.c:    ret = apply_master_ob(APPLY_CREATOR_FILE, 1);
simulate.c:     * Now we are sure that we have a creator name. Do not call apply()
simulate.c:    v = apply_master_ob(APPLY_COMPILE_OBJECT, argc);
simulate.c:    mret = apply_master_ob(APPLY_VALID_OBJECT, 1);
simulate.c:	ret = apply(APPLY_ID, ob->super, 1, ORIGIN_DRIVER);
simulate.c:	ret = apply(APPLY_ID, ob, 1, ORIGIN_DRIVER);
simulate.c:	(void)apply(APPLY_MOVE, ob->contains, 1, ORIGIN_DRIVER);
simulate.c:	safe_apply_master_ob(APPLY_CRASH, 3);
simulate.c:	mret = apply_master_ob(APPLY_ERROR_HANDLER,2);
simulate.c:	mret = apply_master_ob(APPLY_ERROR_HANDLER,1);
simulate.c:	/* This can happen via errors in the object_name() apply. */
simulate.c:    amo = apply_master_ob(APPLY_SLOW_SHUTDOWN, 1);
simulate.c:		apply(APPLY_RECEIVE_MESSAGE, ob, 2, ORIGIN_DRIVER);
simulate.c:	/* need to set the flag here to prevent infinite loops in apply_low */
socket_efuns.c:    mret = apply_master_ob(APPLY_VALID_SOCKET, 3);
socket_efuns.c:	safe_apply(callback.s, lpc_socks[fd].owner_ob, num_arg, ORIGIN_INTERNAL);
socket_efuns.c:	    debug(sockets, ("read_socket_handler: apply\n"));
socket_efuns.c:	debug(sockets, ("read_socket_handler: apply read callback\n"));
socket_efuns.c:	    debug(sockets, ("read_socket_handler: apply read callback\n"));
socket_efuns.c:	    debug(sockets, ("read_socket_handler: apply read callback\n"));
socket_efuns.c:    debug(sockets, ("write_socket_handler: apply write_callback\n"));
socket_efuns.c:	debug(sockets, ("read_socket_handler: apply close callback\n"));
socket_efuns.c:	safe_apply(callback->u.string, ob, 2, ORIGIN_INTERNAL);
sprintf.c: *        "@") is applyed to each element of the array.
sprintf.c:		temp = safe_apply_master_ob(APPLY_OBJECT_NAME, 1);
swap.c:	debug(d_flag, ("  object not swapped - inherited or interactive or in apply_low() cache."));
y.tab.c:	    res = safe_apply_master_ob(APPLY_VALID_OVERRIDE, 3);
y.tab.c:	res = safe_apply_master_ob(APPLY_VALID_OVERRIDE, 3);