/*
 * This file specifies types and arguments for efuns.
 * An argument can have two different types with the syntax 'type1 | type2'.
 * An argument is marked as optional if it also takes the type 'void'.
 *
 * Look at the end for the list of functions that are optionally available.
 * If you don't want them, simply comment out them. All other functions must
 * remain defined.
 */

%tokens

/*
 * These are token values that needn't have an associated code for the
 * compiled file
 */

if else
case default 
while do for continue
int status string_decl float_decl object closure_decl symbol_decl void mixed
static private no_mask protected public varargs virtual
inherit colon_colon
arrow quoted_aggregate

%codes

/* This code should come first, to detect corrupted code */
	illegal

/*
 * These are the predefined functions that can be accessed from LPC.
 */
	identifier
	return
	string
	number
	float
	mapping
	closure
	symbol
"++"	inc
"--"	dec
"&&"	land
"||"	lor
	assign
"+"	add
	subtract
"*"	multiply
"/"	divide
"<"	lt
">"	gt
"=="	eq
">="	ge
"<="	le
"!="	ne
	break
	switch
	sscanf
	parse_command
	local
"%"	mod
"~"	compl
"&"	and
"|"	or
"^"	xor
"<<"	lsh
">>"	rsh
	catch
"!"	not
".."	range

/*
 * These values are used by the stack machine, and can not be directly
 * called from LPC.
 */
pop_value
dup
call_function_by_address
call_explicit_inherited
push_identifier_lvalue
virtual_variable
push_virtual_variable_lvalue
push_local_variable_lvalue
push_indexed_lvalue
push_rindexed_lvalue
index_lvalue
rindex_lvalue
index
rindex
const0
const1
lbranch
lbranch_when_zero
lbranch_when_non_zero
branch
branch_when_zero
branch_when_non_zero
bbranch_when_zero
bbranch_when_non_zero
simul_efun
return0
"++x"	pre_inc
"--x"	pre_dec
"x++"	post_inc
"x--"	post_dec
cstring0 cstring1 cstring2 cstring3
clit
nclit
void_assign
"(void)+=" void_add_eq
"+="	add_eq
"-="	sub_eq
"/="	div_eq
"*="	mult_eq
"%="	mod_eq
"&="	and_eq
"|="	or_eq
"^="	xor_eq
"<<="	lsh_eq
">>="	rsh_eq
range_lvalue
aggregate
escape
extract2
previous_object0
lambda_cconstant lambda_constant

#ifdef MAPPINGS
m_aggregate
m_caggregate
map_index
push_indexed_map_lvalue
#endif

#ifdef INITIALIZATION_BY___INIT
jump
#endif

%efuns

string *regexp(string *, string);
void add_action(string, void|string, void|int);
void add_worth(int, void|object);
object *all_inventory(object default: F_THIS_OBJECT);
mixed *allocate(int);
mixed assoc(mixed, mixed *, mixed|void, mixed|void);
void break_point();
closure bind_lambda(closure, object default: F_CONST1);
unknown call_other(object|string, string, ...);
void call_out(string|closure, int, void|mixed, ...);
mixed *call_out_info();
string capitalize(string);
int cat(string, void|int, void|int);
string clear_bit(string, int);
object clone_object(string);
int command(string, void|object);
string crypt(string, string|int default: F_CONST0);
string ctime(int default: F_TIME);
object *deep_inventory(object default: F_THIS_OBJECT);
void destruct(object);
void disable_commands();
int ed(void|string, void|string);
void enable_commands();
object environment(void|object);
int exec(object, object);
string *explode(string, string);
string file_name(object default: F_THIS_OBJECT);
int file_size(string);
mixed *filter_array(mixed *, string|closure, ...);
int find_call_out(string);
object find_living(string);
object find_object(string);
object find_player(string);
string function_exists(string, object default: F_THIS_OBJECT);
string implode(string *, string);
int input_to(string, void|int, ...);
mixed insert_alist(mixed, mixed, ...);
int interactive(object default: F_THIS_OBJECT);
mixed *intersect_alist(mixed *,mixed *);
int intp(mixed);
int living(object);
string lower_case(string);
mixed *get_dir(string, int default: F_CONST1);
mixed *map_array(mixed *, string|closure, ...);
int member_array(mixed, mixed *|string);
int member(mixed *|string|mapping, mixed);
int mkdir(string);
void move_object(object|string, object|string);
mixed negate(int|float);
void notify_fail(string);
int objectp(mixed);
mixed *order_alist(mixed *, void|mixed *, ...);
int pointerp(mixed);
object present(object|string, void|object);
string process_string(string);
mixed *query_actions(object|string, int|object|string default: F_CONST1);
string query_host_name();
int query_idle(object);
string query_ip_name(void|object);
string query_ip_number(void|object);
string query_load_average();
object query_snoop(object);
string query_verb();
int random(int);
string read_bytes(string, void|int, void|int);
string read_file(string, void|int, void|int);
int remove_call_out(string);
void remove_interactive(object);
int rename(string, string);
void replace_program(string);
int restore_object(string);
int rm(string);
int rmdir(string);
#if defined(HAVE_GETRUSAGE) || defined(POSIX)
mixed *rusage();
#endif
void save_object(string);
void say(string|mixed *, void|object|object *);
string set_bit(string, int);
int set_heart_beat(int);
int set_light(int);
void set_living_name(string);
void set_this_object(object);
object shadow(object, int);
void shout(string);
int sizeof(mixed *|mapping);
mixed *slice_array F_RANGE (mixed *,int,int);
int snoop(object, void|object);
mixed *sort_array(mixed *,string|closure,object|string default: F_THIS_OBJECT);
int stringp(mixed);
int strlen(string);
int tail(string);
void tell_object(object, string);
void tell_room(object|string, string|mixed *, void|object *);
int test_bit(string, int);
object this_interactive();
object this_object();
object this_player();
void throw(mixed);
int time();
mixed *unique_array(mixed *, string, mixed default: F_CONST0);
object *users();
void write(mixed);
int write_bytes(string, int, string);
int write_file(string, string);

/*
 * List of functions only used in compatibility mode.
 */
#ifndef NATIVE_MODE
string creator(object);
int transfer(object, object|string);
#endif

/*
 * List of functions not used in compat mode.
 */
#ifndef COMPAT_MODE
void export_uid(object);
string geteuid(object default: F_THIS_OBJECT);
string getuid
#ifndef NATIVE_MODE
              F_CREATOR
#endif
                        (object default: F_THIS_OBJECT);
int seteuid(string|int);
#endif

#ifdef MALLOC_malloc
/*
 * This one is needed if you use the old malloc.c, which is no longer
 * supplied. It is called from church.c in the original 2.4.5 mudlib. This
 * call is not needed if malloc.c is not used, and should be removed.
 */
int combine_free_list();
#endif

/*
 *
 * The following functions are optional. Comment out the ones not wanted.
 * Beware that some may be used in mudlib 2.4.5.
 *
 */
#ifdef FLOATS
int floatp(mixed);
#endif

#ifdef MAPPINGS
mapping filter_mapping(mapping, string|closure,  ...);
mapping m_delete(mapping, mixed);
mixed *m_indices(mapping);
int m_sizeof F_SIZEOF (mapping);
mixed *m_values(mapping);
mapping map_mapping(mapping, string|closure, ...);
int mappingp(mixed);
mapping mkmapping(mixed *, ...);
#endif /* MAPPINGS */

object first_inventory(object|string default: F_THIS_OBJECT);
object next_inventory(object default: F_THIS_OBJECT);
string *inherit_list(object default: F_THIS_OBJECT);
void    printf(string, ...);
string sprintf(string, ...);
mixed quote(mixed *|quoted_array|symbol|string);
closure lambda(mixed *, mixed);
closure symbol_function(symbol|string, string|object default: F_CONST0);
mixed apply(closure, mixed|mixed &, ...);
/* funcall accepts mixed as a single argument, but the only useful application
 * is with mixed variables that might hold closures, which will work anyways.
 */
mixed funcall (closure, ...);
int symbolp(mixed);
int closurep(mixed);

%xcodes

end_catch
break_continue
breakn_continue
nr_range
rn_range
rr_range
extract1
push_protected_indexed_lvalue
push_protected_rindexed_lvalue
push_protected_indexed_map_lvalue
nr_range_lvalue
rn_range_lvalue
rr_range_lvalue
extract_lvalue
protected_index_lvalue
protected_rindex_lvalue
protected_range_lvalue
protected_nr_range_lvalue
protected_rn_range_lvalue
protected_rr_range_lvalue
protected_extract_lvalue
undef

%xefuns

void add_verb(string);
void add_xverb(string);
string extract(string, int, int);
object previous_object(int);
void shutdown();
int strstr(string, string, int default: F_CONST0);
int program_time(object default: F_THIS_OBJECT);
void swap(object);		/* Only used for debugging */
void unshadow();
mixed *filter_objects(mixed *, string, ...);
mixed *map_objects(mixed *, string, ...);
int query_once_interactive(object);
int to_int(string|float);
float to_float(string|int);
string to_string(mixed);
int *to_array(string);
void wizlist(void|string);
void  set_extra_wizinfo_size(int);
void  set_extra_wizinfo(object|string, mixed);
mixed get_extra_wizinfo(object|string);
int caller_stack_depth();

/* A few interesting comm functions for the internet mud protocol */
#ifdef UDP_SEND
int send_imp(string, int, string);
#endif
int query_mud_port();
#ifdef CATCH_UDP_PORT
int query_imp_port();
#endif

object query_input_pending(object|string);
mixed query_editing(object|string);

#if defined( FLOATS ) && defined( TRANSCENDENT_FUNCTIONS )
float sin(float);
float asin(float);
float cos(float);
float acos(float);
float tan(float);
float atan(float);
float log(float);
float exp(float);
float sqrt(float);
#endif /* TRANSCENDENT_FUNCTIONS */

#ifdef MAPPINGS
int mapping_contains(mixed & | mapping, mixed & | mixed, ...);
mapping allocate_mapping(int, int default: F_CONST1);
mapping copy_mapping(mapping);
#endif /* MAPPINGS */

int call_resolved(mixed &, object|string, string, ...);
int referencep(mixed &);
void set_auto_include_string(string);
void raise_error(string);
int get_eval_cost();
void garbage_collection();
int typeof(mixed);
mixed get_type_info(mixed, int default: F_THIS_OBJECT);

int set_is_wizard(object, int default: F_CONST1);
int cindent(string);
object set_modify_command(object|string default: F_THIS_OBJECT);
mixed *get_error_file(string, int default: F_CONST1);
mixed *heart_beat_info();
string set_prompt(string|closure|int, object default: F_THIS_PLAYER);
mixed *transpose_array(mixed *);
mixed *wizlist_info();
string *functionlist(object|string, int default: F_CONST1);
int trace(int);
string traceprefix(string|int);
void rename_object(object, string);
string *regexplode(string, string);
closure unbound_lambda(mixed *, mixed);

mixed debug_info(int, ...);
void walk_mapping(mapping, string|closure, ...);