root/1.8.3/trunk/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},
  {"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