root/1.8.3/tags/p6/src/function.c

/**
 * \file function.c
 *
 * \brief The function parser.
 *
 *
 */
#include "copyrite.h"

#include "config.h"
#include <limits.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include "conf.h"
#include "externs.h"
#include "attrib.h"
#include "dbdefs.h"
#include "mushdb.h"
#include "function.h"
#include "match.h"
#include "htab.h"
#include "parse.h"
#include "lock.h"
#include "flags.h"
#include "game.h"
#include "mymalloc.h"
#include "sort.h"
#include "funs.h"
#include "confmagic.h"
#include "ansi.h"

static void func_hash_insert(const char *name, FUN *func);
extern void local_functions(void);
static int apply_restrictions(unsigned int result, const char *restriction);
static char *build_function_report(dbref player, FUN *fp);

USERFN_ENTRY *userfn_tab;   /**< Table of user-defined functions */
HASHTAB htab_function;      /**< Function hash table */
HASHTAB htab_user_function; /**< User-defined function hash table */
slab *function_slab; /**< slab for 'struct fun' allocations */
slab *userfun_slab; /**< slab for 'struct userfn_entry' allocations */

/* -------------------------------------------------------------------------*
 * Utilities.
 */

/* Save and restore regexp data */
void
save_regexp_context(struct re_save *save)
{
  save->re_code = global_eval_context.re_code;
  save->re_from = global_eval_context.re_from;
  save->re_subpatterns = global_eval_context.re_subpatterns;
  save->re_offsets = global_eval_context.re_offsets;
}

void
restore_regexp_context(struct re_save *save)
{
  global_eval_context.re_code = save->re_code;
  global_eval_context.re_from = save->re_from;
  global_eval_context.re_subpatterns = save->re_subpatterns;
  global_eval_context.re_offsets = save->re_offsets;
}

/** Save a single q-register
 */
void
save_partial_global_reg(const char *funcname, char *preserve[], int i)
{
  preserve[i] = mush_strdup(global_eval_context.renv[i], funcname);
}

/** Restore q-registers saved with save_partial_global_reg()
 */
void
restore_partial_global_regs(const char *funcname, char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    if (preserve[i]) {
      mush_strncpy(global_eval_context.renv[i], preserve[i], BUFFER_LEN);
      mush_free(preserve[i], funcname);
    }
  }
}

/** Save a copy of the q-registers.
 * \param funcname name of function calling (for memory leak testing)
 * \param preserve pointer to array to store the q-registers in.
 */
void
save_global_regs(const char *funcname, char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    if (!global_eval_context.renv[i][0])
      preserve[i] = NULL;
    else {
      preserve[i] = mush_strdup(global_eval_context.renv[i], funcname);
    }
  }
}

/** Restore the q-registers, freeing the storage array.
 * \param funcname name of function calling (for memory leak testing)
 * \param preserve pointer to array to restore the q-registers from.
 */
void
restore_global_regs(const char *funcname, char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    if (preserve[i]) {
      mush_strncpy(global_eval_context.renv[i], preserve[i], BUFFER_LEN);
      mush_free(preserve[i], funcname);
      preserve[i] = NULL;
    } else {
      global_eval_context.renv[i][0] = '\0';
    }
  }
}

/** Free the storage array for the q-registers, without restoring
 * \param funcname name of function calling (for memory leak testing)
 * \param preserve pointer to array to free q-registers from.
 */
void
free_global_regs(const char *funcname, char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    if (preserve[i])
      mush_free(preserve[i], funcname);
  }
}

/** Initilalize an array for the q-registers, setting all NULL.
 * \param preserve pointer to array to free q-registers from.
 */
void
init_global_regs(char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    preserve[i] = NULL;
  }
}

/** Restore the q-registers, without freeing the storage array.
 * \param preserve pointer to array to restore the q-registers from.
 */
void
load_global_regs(char *preserve[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    if (preserve[i]) {
      strcpy(global_eval_context.renv[i], preserve[i]);
    } else {
      global_eval_context.renv[i][0] = '\0';
    }
  }
}

/** Save a copy of the environment (%0-%9)
 * \param funcname name of function calling (for memory leak testing)
 * \param preserve pointer to array to store %0-%9 in.
 */
void
save_global_env(const char *funcname __attribute__ ((__unused__)),
                char *preserve[])
{
  int i;
  for (i = 0; i < 10; i++)
    preserve[i] = global_eval_context.wenv[i];
}

/** Restore the environment (%0-%9)
 * \param funcname name of function calling (for memory leak testing)
 * \param preserve pointer to array to restore %0-%9 from.
 */
void
restore_global_env(const char *funcname __attribute__ ((__unused__)),
                   char *preserve[])
{
  int i;
  for (i = 0; i < 10; i++)
    global_eval_context.wenv[i] = preserve[i];
}

/** Save a copy of the wnxt and rnxt state
 * This function must deal with both the addresses and the values
 * of these variables, because they get modified in all sorts of
 * nasty ways that we may not account for.
 * \param funcname name of function calling (for memory leak testing)
 * \param preservew pointer to array to store the wnxt address in.
 * \param preserver pointer to array to store the rnxt address in.
 * \param valw pointer to array to store the wnxt value in.
 * \param valr pointer to array to store the rnxt value in.
 */
void
save_global_nxt(const char *funcname, char *preservew[], char *preserver[],
                char *valw[], char *valr[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    preserver[i] = global_eval_context.rnxt[i];
    if (!global_eval_context.rnxt[i])
      valr[i] = NULL;
    else {
      valr[i] = mush_strdup(global_eval_context.rnxt[i], funcname);
    }
  }
  for (i = 0; i < 10; i++) {
    preservew[i] = global_eval_context.wnxt[i];
    if (!global_eval_context.wnxt[i])
      valw[i] = NULL;
    else {
      valw[i] = mush_strdup(global_eval_context.wnxt[i], funcname);
    }
  }
}

/** Restore a copy of the wnxt and rnxt state
 * \param funcname name of function calling (for memory leak testing)
 * \param preservew pointer to array to restore the wnxt address from.
 * \param preserver pointer to array to restore the rnxt address from.
 * \param valw pointer to array to restore the wnxt value from.
 * \param valr pointer to array to restore the rnxt value from.
 */
void
restore_global_nxt(const char *funcname, char *preservew[], char *preserver[],
                   char *valw[], char *valr[])
{
  int i;
  for (i = 0; i < NUMQ; i++) {
    global_eval_context.rnxt[i] = preserver[i];
    if (preserver[i]) {
      /* There was a former address, so we can restore to it */
      mush_strncpy(global_eval_context.rnxt[i], valr[i], BUFFER_LEN);
      mush_free(valr[i], funcname);
      valr[i] = NULL;
    }
  }
  for (i = 0; i < 10; i++) {
    global_eval_context.wnxt[i] = preservew[i];
    if (preservew[i]) {
      /* There was a former address, so we can restore to it */
      mush_strncpy(global_eval_context.wnxt[i], valw[i], BUFFER_LEN);
      mush_free(valw[i], funcname);
      valw[i] = NULL;
    }
  }
}


/** Check for a delimiter in an argument of a function call.
 * This function checks a given argument of a function call and sees
 * if it could be used as a delimiter. A delimiter must be a single
 * character. If the argument isn't present or is null, we return
 * the default delimiter, a space.
 * \param buff unused.
 * \param bp unused.
 * \param nfargs number of arguments to the function.
 * \param fargs array of function arguments.
 * \param sep_arg index of the argument to check for a delimiter.
 * \param sep pointer to separator character, used to return separator.
 * \retval 0 illegal separator argument.
 * \retval 1 successfully returned a separator (maybe the default one).
 */
int
delim_check(char *buff, char **bp, int nfargs, char *fargs[], int sep_arg,
            char *sep)
{
  /* Find a delimiter. */

  if (nfargs >= sep_arg) {
    if (!*fargs[sep_arg - 1])
      *sep = ' ';
    else if (strlen(fargs[sep_arg - 1]) != 1) {
      safe_str(T("#-1 SEPARATOR MUST BE ONE CHARACTER"), buff, bp);
      return 0;
    } else
      *sep = *fargs[sep_arg - 1];
  } else
    *sep = ' ';

  return 1;
}

/* --------------------------------------------------------------------------
 * The actual function handlers
 */

/** An entry in the function table.
 * This structure represents a function's entry in the function table.
 */
typedef struct fun_tab {
  const char *name;     /**< Name of the function, uppercase. */
  function_func fun;    /**< Pointer to code to call for this function. */
  int minargs;  /**< Minimum args required. */
  int maxargs;  /**< Maximum args, or INT_MAX. If <0, last arg may have commas */
  int flags;    /**< Flags to control how the function is parsed. */
} FUNTAB;


/** The function table. Functions can also be added at runtime with
 * add_function().
 */
FUNTAB flist[] = {
  {"@@", fun_atat, 1, -1, FN_NOPARSE},
  {"ABS", fun_abs, 1, 1, FN_REG},
  {"ACCENT", fun_accent, 2, 2, FN_REG},
  {"ACCNAME", fun_accname, 1, 1, FN_REG},
  {"ADD", fun_add, 2, INT_MAX, FN_REG},
  {"AFTER", fun_after, 2, 2, FN_REG},
  {"ALIAS", fun_alias, 1, 2, FN_REG},
  {"ALIGN", fun_align, 2, INT_MAX, FN_REG},
  {"ALLOF", fun_allof, 2, INT_MAX, FN_NOPARSE},
  {"ALPHAMAX", fun_alphamax, 1, INT_MAX, FN_REG},
  {"ALPHAMIN", fun_alphamin, 1, INT_MAX, FN_REG},
  {"AND", fun_and, 2, INT_MAX, FN_REG},
  {"ANDFLAGS", fun_andflags, 2, 2, FN_REG},
  {"ANDLFLAGS", fun_andlflags, 2, 2, FN_REG},
  {"ANDLPOWERS", fun_andlflags, 2, 2, FN_REG},
  {"ANDPOWERS", fun_andflags, 2, 2, FN_REG},
  {"ANSI", fun_ansi, 2, -2, FN_REG},
#ifdef ANSI_DEBUG
  {"ANSIINSPECT", fun_ansiinspect, 1, 2, FN_REG},
#endif
  {"APOSS", fun_aposs, 1, 1, FN_REG},
  {"ART", fun_art, 1, 1, FN_REG},
  {"ATRLOCK", fun_atrlock, 1, 2, FN_REG},
  {"ATTRIB_SET", fun_attrib_set, 1, -2, FN_REG},
  {"BAND", fun_band, 1, INT_MAX, FN_REG},
  {"BASECONV", fun_baseconv, 3, 3, FN_REG},
  {"BEEP", fun_beep, 0, 1, FN_REG},
  {"BEFORE", fun_before, 2, 2, FN_REG},
  {"BNAND", fun_bnand, 2, 2, FN_REG},
  {"BNOT", fun_bnot, 1, 1, FN_REG},
  {"BOR", fun_bor, 1, INT_MAX, FN_REG},
  {"BOUND", fun_bound, 2, 3, FN_REG},
  {"BRACKETS", fun_brackets, 1, 1, FN_REG},
  {"BXOR", fun_bxor, 1, INT_MAX, FN_REG},
  {"CAND", fun_cand, 2, INT_MAX, FN_NOPARSE},
  {"CAPSTR", fun_capstr, 1, -1, FN_REG},
  {"CASE", fun_switch, 3, INT_MAX, FN_NOPARSE},
  {"CASEALL", fun_switch, 3, INT_MAX, FN_NOPARSE},
  {"CAT", fun_cat, 1, INT_MAX, FN_REG},
  {"CBUFFER", fun_cinfo, 1, 1, FN_REG},
  {"CDESC", fun_cinfo, 1, 1, FN_REG},
  {"CEMIT", fun_cemit, 2, 3, FN_REG},
  {"CFLAGS", fun_cflags, 1, 2, FN_REG},
  {"CHANNELS", fun_channels, 0, 2, FN_REG},
  {"CLFLAGS", fun_cflags, 1, 2, FN_REG},
  {"CLOCK", fun_clock, 1, 2, FN_REG},
  {"CMSGS", fun_cinfo, 1, 1, FN_REG},
  {"COWNER", fun_cowner, 1, 1, FN_REG},
  {"CRECALL", fun_crecall, 1, 5, FN_REG},
  {"CSTATUS", fun_cstatus, 2, 2, FN_REG},
  {"CTITLE", fun_ctitle, 2, 2, FN_REG},
  {"CUSERS", fun_cinfo, 1, 1, FN_REG},
  {"CWHO", fun_cwho, 1, 1, FN_REG},
  {"CENTER", fun_center, 2, 4, FN_REG},
  {"CHILDREN", fun_lsearch, 1, 1, FN_REG},
  {"CHR", fun_chr, 1, 1, FN_REG},
  {"CHECKPASS", fun_checkpass, 2, 2, FN_REG | FN_WIZARD},
  {"CLONE", fun_clone, 1, 1, FN_REG},
  {"CMDS", fun_cmds, 1, 1, FN_REG},
  {"COMP", fun_comp, 2, 3, FN_REG},
  {"CON", fun_con, 1, 1, FN_REG},
  {"COND", fun_if, 2, INT_MAX, FN_NOPARSE},
  {"CONDALL", fun_if, 2, INT_MAX, FN_NOPARSE},
  {"CONFIG", fun_config, 1, 1, FN_REG},
  {"CONN", fun_conn, 1, 1, FN_REG},
  {"CONTROLS", fun_controls, 2, 2, FN_REG},
  {"CONVSECS", fun_convsecs, 1, 2, FN_REG},
  {"CONVUTCSECS", fun_convsecs, 1, 1, FN_REG},
  {"CONVTIME", fun_convtime, 1, 1, FN_REG},
  {"COR", fun_cor, 2, INT_MAX, FN_NOPARSE},
  {"CREATE", fun_create, 1, 2, FN_REG},
  {"CSECS", fun_csecs, 1, 1, FN_REG},
  {"CTIME", fun_ctime, 1, 2, FN_REG},
  {"DEC", fun_dec, 1, 1, FN_REG},
  {"DECODE64", fun_decode64, 1, -1, FN_REG},
  {"DECOMPOSE", fun_decompose, 1, -1, FN_REG},
  {"DECRYPT", fun_decrypt, 2, 3, FN_REG},
  {"DEFAULT", fun_default, 2, INT_MAX, FN_NOPARSE},
  {"DELETE", fun_delete, 3, 3, FN_REG},
  {"DIE", fun_die, 2, 3, FN_REG},
  {"DIG", fun_dig, 1, 3, FN_REG},
  {"DIGEST", fun_digest, 2, -2, FN_REG},
  {"DIST2D", fun_dist2d, 4, 4, FN_REG},
  {"DIST3D", fun_dist3d, 6, 6, FN_REG},
  {"DIV", fun_div, 2, 2, FN_REG},
  {"DOING", fun_doing, 1, 1, FN_REG},
  {"EDEFAULT", fun_edefault, 2, 2, FN_NOPARSE},
  {"EDIT", fun_edit, 3, INT_MAX, FN_REG},
  {"ELEMENT", fun_element, 3, 3, FN_REG},
  {"ELEMENTS", fun_elements, 2, 4, FN_REG},
  {"ELIST", fun_itemize, 1, 5, FN_REG},
  {"ELOCK", fun_elock, 2, 2, FN_REG},
  {"EMIT", fun_emit, 1, -1, FN_REG},
  {"ENCODE64", fun_encode64, 1, -1, FN_REG},
  {"ENCRYPT", fun_encrypt, 2, 3, FN_REG},
  {"ENTRANCES", fun_entrances, 0, 4, FN_REG},
  {"ETIMEFMT", fun_etimefmt, 2, 2, FN_REG},
  {"EQ", fun_eq, 2, 2, FN_REG},
  {"EVAL", fun_eval, 2, 2, FN_REG},
  {"ESCAPE", fun_escape, 1, -1, FN_REG},
  {"EXIT", fun_exit, 1, 1, FN_REG},
  {"EXTRACT", fun_extract, 1, 4, FN_REG},
  {"FILTER", fun_filter, 2, 4, FN_REG},
  {"FILTERBOOL", fun_filter, 2, 4, FN_REG},
  {"FINDABLE", fun_findable, 2, 2, FN_REG},
  {"FIRST", fun_first, 1, 2, FN_REG},
  {"FIRSTOF", fun_firstof, 0, INT_MAX, FN_NOPARSE},
  {"FLAGS", fun_flags, 0, 1, FN_REG},
  {"FLIP", fun_flip, 1, -1, FN_REG},
  {"FLOORDIV", fun_floordiv, 2, 2, FN_REG},
  {"FN", fun_fn, 1, INT_MAX, FN_NOPARSE},
  {"FOLD", fun_fold, 2, 4, FN_REG},
  {"FOLDERSTATS", fun_folderstats, 0, 2, FN_REG},
  {"FOLLOWERS", fun_followers, 1, 1, FN_REG},
  {"FOLLOWING", fun_following, 1, 1, FN_REG},
  {"FOREACH", fun_foreach, 2, 4, FN_REG},
  {"FRACTION", fun_fraction, 1, 1, FN_REG},
  {"FUNCTIONS", fun_functions, 0, 1, FN_REG},
  {"FULLALIAS", fun_fullalias, 1, 1, FN_REG},
  {"FULLNAME", fun_fullname, 1, 1, FN_REG},
  {"GET", fun_get, 1, 1, FN_REG},
  {"GET_EVAL", fun_get_eval, 1, 1, FN_REG},
  {"GRAB", fun_grab, 2, 3, FN_REG},
  {"GRABALL", fun_graball, 2, 4, FN_REG},
  {"GREP", fun_grep, 3, 3, FN_REG},
  {"GREPI", fun_grep, 3, 3, FN_REG},
  {"GT", fun_gt, 2, 2, FN_REG},
  {"GTE", fun_gte, 2, 2, FN_REG},
  {"HASATTR", fun_hasattr, 2, 2, FN_REG},
  {"HASATTRP", fun_hasattr, 2, 2, FN_REG},
  {"HASATTRPVAL", fun_hasattr, 2, 2, FN_REG},
  {"HASATTRVAL", fun_hasattr, 2, 2, FN_REG},
  {"HASFLAG", fun_hasflag, 2, 2, FN_REG},
  {"HASPOWER", fun_haspower, 2, 2, FN_REG},
  {"HASTYPE", fun_hastype, 2, 2, FN_REG},
  {"HEIGHT", fun_height, 1, 2, FN_REG},
  {"HIDDEN", fun_hidden, 1, 1, FN_REG},
  {"HOME", fun_home, 1, 1, FN_REG},
  {"HOST", fun_hostname, 1, 1, FN_REG},
  {"HOSTNAME", fun_hostname, 1, 1, FN_REG},
  {"IDLE", fun_idlesecs, 1, 1, FN_REG},
  {"IDLESECS", fun_idlesecs, 1, 1, FN_REG},
  {"IF", fun_if, 2, 3, FN_NOPARSE},
  {"IFELSE", fun_if, 3, 3, FN_NOPARSE},
  {"ILEV", fun_ilev, 0, 0, FN_REG},
  {"INAME", fun_iname, 1, 1, FN_REG},
  {"INC", fun_inc, 1, 1, FN_REG},
  {"INDEX", fun_index, 4, 4, FN_REG},
  {"INSERT", fun_insert, 3, 4, FN_REG},
  {"INUM", fun_inum, 1, 1, FN_REG},
  {"IPADDR", fun_ipaddr, 1, 1, FN_REG},
  {"ISDAYLIGHT", fun_isdaylight, 0, 0, FN_REG},
  {"ISDBREF", fun_isdbref, 1, 1, FN_REG},
  {"ISINT", fun_isint, 1, 1, FN_REG},
  {"ISNUM", fun_isnum, 1, 1, FN_REG},
  {"ISOBJID", fun_isobjid, 1, 1, FN_REG},
  {"ISWORD", fun_isword, 1, 1, FN_REG},
  {"ITER", fun_iter, 2, 4, FN_NOPARSE},
  {"ITEMS", fun_items, 2, 2, FN_REG},
  {"ITEMIZE", fun_itemize, 1, 4, FN_REG},
  {"ITEXT", fun_itext, 1, 1, FN_REG},
  {"LAST", fun_last, 1, 2, FN_REG},
  {"LATTR", fun_lattr, 1, 2, FN_REG},
  {"LATTRP", fun_lattr, 1, 2, FN_REG},
  {"LCON", fun_dbwalker, 1, 1, FN_REG},
  {"LCSTR", fun_lcstr, 1, -1, FN_REG},
  {"LDELETE", fun_ldelete, 2, 3, FN_REG},
  {"LEFT", fun_left, 2, 2, FN_REG},
  {"LEMIT", fun_lemit, 1, -1, FN_REG},
  {"LETQ", fun_letq, 1, INT_MAX, FN_NOPARSE},
  {"LEXITS", fun_dbwalker, 1, 1, FN_REG},
  {"LFLAGS", fun_lflags, 0, 1, FN_REG},
  {"LINK", fun_link, 2, 3, FN_REG},
  {"LIST", fun_list, 1, 1, FN_REG},
  {"LIT", fun_lit, 1, -1, FN_LITERAL},
  {"LJUST", fun_ljust, 2, 3, FN_REG},
  {"LLOCKFLAGS", fun_lockflags, 0, 1, FN_REG},
  {"LLOCKS", fun_locks, 1, 1, FN_REG},
  {"LMATH", fun_lmath, 2, 3, FN_REG},
  {"LNUM", fun_lnum, 1, 3, FN_REG},
  {"LOC", fun_loc, 1, 1, FN_REG},
  {"LOCALIZE", fun_localize, 1, 1, FN_NOPARSE},
  {"LOCATE", fun_locate, 3, 3, FN_REG},
  {"LOCK", fun_lock, 1, 2, FN_REG},
  {"LOCKFLAGS", fun_lockflags, 0, 1, FN_REG},
  {"LOCKS", fun_locks, 1, 1, FN_REG},
  {"LPARENT", fun_lparent, 1, 1, FN_REG},
  {"LPLAYERS", fun_dbwalker, 1, 1, FN_REG},
  {"LPORTS", fun_lports, 0, 1, FN_REG},
  {"LPOS", fun_lpos, 2, 2, FN_REG},
  {"LSEARCH", fun_lsearch, 1, INT_MAX, FN_REG},
  {"LSEARCHR", fun_lsearch, 1, INT_MAX, FN_REG},
  {"LSET", fun_lset, 2, 2, FN_REG},
  {"LSTATS", fun_lstats, 0, 1, FN_REG},
  {"LT", fun_lt, 2, 2, FN_REG},
  {"LTE", fun_lte, 2, 2, FN_REG},
  {"LTHINGS", fun_dbwalker, 1, 1, FN_REG},
  {"LVCON", fun_dbwalker, 1, 1, FN_REG},
  {"LVEXITS", fun_dbwalker, 1, 1, FN_REG},
  {"LVPLAYERS", fun_dbwalker, 1, 1, FN_REG},
  {"LVTHINGS", fun_dbwalker, 1, 1, FN_REG},
  {"LWHO", fun_lwho, 0, 1, FN_REG},
  {"LWHOID", fun_lwho, 0, 1, FN_REG},
  {"MAIL", fun_mail, 0, 2, FN_REG},
  {"MAILFROM", fun_mailfrom, 1, 2, FN_REG},
  {"MAILSEND", fun_mailsend, 2, 2, FN_REG},
  {"MAILSTATS", fun_mailstats, 1, 1, FN_REG},
  {"MAILDSTATS", fun_mailstats, 1, 1, FN_REG},
  {"MAILFSTATS", fun_mailstats, 1, 1, FN_REG},
  {"MAILSTATUS", fun_mailstatus, 1, 2, FN_REG},
  {"MAILSUBJECT", fun_mailsubject, 1, 2, FN_REG},
  {"MAILTIME", fun_mailtime, 1, 2, FN_REG},
  {"MALIAS", fun_malias, 0, 2, FN_REG},
  {"MAP", fun_map, 2, 4, FN_REG},
  {"MAPSQL", fun_mapsql, 2, 4, FN_REG},
  {"MATCH", fun_match, 2, 3, FN_REG},
  {"MATCHALL", fun_matchall, 2, 4, FN_REG},
  {"MAX", fun_max, 1, INT_MAX, FN_REG},
  {"MEAN", fun_mean, 1, INT_MAX, FN_REG},
  {"MEDIAN", fun_median, 1, INT_MAX, FN_REG},
  {"MEMBER", fun_member, 2, 3, FN_REG},
  {"MERGE", fun_merge, 3, 3, FN_REG},
  {"MESSAGE", fun_message, 3, 13, FN_REG},
  {"MID", fun_mid, 3, 3, FN_REG},
  {"MIN", fun_min, 1, INT_MAX, FN_REG},
  {"MIX", fun_mix, 3, 12, FN_REG},
  {"MODULO", fun_modulo, 2, 2, FN_REG},
  {"MONEY", fun_money, 1, 1, FN_REG},
  {"MSECS", fun_msecs, 1, 1, FN_REG},
  {"MTIME", fun_mtime, 1, 2, FN_REG},
  {"MUDNAME", fun_mudname, 0, 0, FN_REG},
  {"MUL", fun_mul, 2, INT_MAX, FN_REG},
  {"MUNGE", fun_munge, 3, 5, FN_REG},
  {"MWHO", fun_lwho, 0, 0, FN_REG},
  {"MWHOID", fun_lwho, 0, 0, FN_REG},
  {"NAME", fun_name, 0, 2, FN_REG},
  {"NAMELIST", fun_namelist, 1, 1, FN_REG},
  {"NAMEGRAB", fun_namegrab, 2, 3, FN_REG},
  {"NAMEGRABALL", fun_namegraball, 2, 3, FN_REG},
  {"NAND", fun_nand, 1, INT_MAX, FN_REG},
  {"NATTR", fun_nattr, 1, 1, FN_REG},
  {"NATTRP", fun_nattr, 1, 1, FN_REG},
  {"NCHILDREN", fun_lsearch, 1, 1, FN_REG},
  {"NCON", fun_dbwalker, 1, 1, FN_REG},
  {"NCOND", fun_if, 2, INT_MAX, FN_NOPARSE},
  {"NCONDALL", fun_if, 2, INT_MAX, FN_NOPARSE},
  {"NEXITS", fun_dbwalker, 1, 1, FN_REG},
  {"NPLAYERS", fun_dbwalker, 1, 1, FN_REG},
  {"NEARBY", fun_nearby, 2, 2, FN_REG},
  {"NEQ", fun_neq, 2, 2, FN_REG},
  {"NEXT", fun_next, 1, 1, FN_REG},