root/1.8.3/trunk/src/funmisc.c

/**
 * \file funmisc.c
 *
 * \brief Miscellaneous functions for mushcode.
 *
 *
 */
#include "copyrite.h"

#include "config.h"
#include <time.h>
#include <string.h>
#include <ctype.h>
#include "conf.h"
#include "case.h"
#include "externs.h"
#include "version.h"
#include "htab.h"
#include "flags.h"
#include "lock.h"
#include "match.h"
#include "mushdb.h"
#include "dbdefs.h"
#include "parse.h"
#include "function.h"
#include "command.h"
#include "game.h"
#include "attrib.h"
#include "confmagic.h"
#include "ansi.h"

#ifdef WIN32
#pragma warning( disable : 4761)        /* NJG: disable warning re conversion */
#endif

extern FUN flist[];
static char *soundex(char *str);
extern char cf_motd_msg[BUFFER_LEN], cf_wizmotd_msg[BUFFER_LEN],
  cf_downmotd_msg[BUFFER_LEN], cf_fullmotd_msg[BUFFER_LEN];
extern HASHTAB htab_function;

/* ARGSUSED */
FUNCTION(fun_valid)
{
  /* Checks to see if a given <something> is valid as a parameter of a
   * given type (such as an object name.)
   */

  if (!args[0] || !*args[0])
    safe_str("#-1", buff, bp);
  else if (!strcasecmp(args[0], "name"))
    safe_boolean(ok_name(args[1]), buff, bp);
  else if (!strcasecmp(args[0], "attrname"))
    safe_boolean(good_atr_name(upcasestr(args[1])), buff, bp);
  else if (!strcasecmp(args[0], "playername"))
    safe_boolean(ok_player_name(args[1], executor, executor), buff, bp);
  else if (!strcasecmp(args[0], "password"))
    safe_boolean(ok_password(args[1]), buff, bp);
  else if (!strcasecmp(args[0], "command"))
    safe_boolean(ok_command_name(upcasestr(args[1])), buff, bp);
  else if (!strcasecmp(args[0], "function"))
    safe_boolean(ok_function_name(upcasestr(args[1])), buff, bp);
  else
    safe_str("#-1", buff, bp);
}

/* ARGSUSED */
FUNCTION(fun_pemit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = PEMIT_LIST;
  dbref saved_orator = orator;
  if (!command_check_byname(executor, ns ? "@nspemit" : "@pemit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  if (ns)
    flags |= PEMIT_SPOOF;
  do_pemit_list(executor, args[0], args[1], flags);
  orator = saved_orator;
}

FUNCTION(fun_message)
{
  int i;
  char *argv[10];

  for (i = 0; (i + 3) < nargs; i++) {
    argv[i] = args[i + 3];
  }

  do_message_list(executor, executor, args[0], args[2], args[1], 0, i, argv);
}

/* ARGSUSED */
FUNCTION(fun_oemit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = ns ? PEMIT_SPOOF : 0;
  if (!command_check_byname(executor, ns ? "@nsoemit" : "@oemit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  do_oemit_list(executor, args[0], args[1], flags);
}

/* ARGSUSED */
FUNCTION(fun_emit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = ns ? PEMIT_SPOOF : 0;
  if (!command_check_byname(executor, ns ? "@nsemit" : "@emit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  do_emit(executor, args[0], flags);
}

/* ARGSUSED */
FUNCTION(fun_remit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = ns ? PEMIT_SPOOF : 0;
  if (!command_check_byname(executor, ns ? "@nsremit" : "@remit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  do_remit(executor, args[0], args[1], flags);
}

/* ARGSUSED */
FUNCTION(fun_lemit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = ns ? PEMIT_SPOOF : 0;
  if (!command_check_byname(executor, ns ? "@nslemit" : "@lemit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  do_lemit(executor, args[0], flags);
}

/* ARGSUSED */
FUNCTION(fun_zemit)
{
  int ns = string_prefix(called_as, "NS");
  int flags = ns ? PEMIT_SPOOF : 0;
  if (!command_check_byname(executor, ns ? "@nszemit" : "@zemit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  do_zemit(executor, args[0], args[1], flags);
}

/* ARGSUSED */
FUNCTION(fun_prompt)
{
  int ns = string_prefix(called_as, "NS");
  int flags = PEMIT_LIST | PEMIT_PROMPT;
  if (!command_check_byname(executor, ns ? "@nspemit" : "@pemit") ||
      fun->flags & FN_NOSIDEFX) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  orator = executor;
  if (ns)
    flags |= PEMIT_SPOOF;
  do_pemit_list(executor, args[0], args[1], flags);
}


extern signed char qreg_indexes[UCHAR_MAX + 1];
/* ARGSUSED */
FUNCTION(fun_setq)
{
  /* sets a variable into a local register */
  int qindex;
  int n;

  if ((nargs % 2) != 0) {
    safe_format(buff, bp,
                T("#-1 FUNCTION (%s) EXPECTS AN EVEN NUMBER OF ARGUMENTS"),
                called_as);
    return;
  }

  for (n = 0; n < nargs; n += 2) {
    if (*args[n] && (*(args[n] + 1) == '\0') &&
        ((qindex = qreg_indexes[(unsigned char) args[n][0]]) != -1)
        && global_eval_context.renv[qindex]) {
      strcpy(global_eval_context.renv[qindex], args[n + 1]);
      if (n == 0 && !strcmp(called_as, "SETR"))
        safe_strl(args[n + 1], arglens[n + 1], buff, bp);
    } else
      safe_str(T("#-1 REGISTER OUT OF RANGE"), buff, bp);
  }
}

FUNCTION(fun_letq)
{
  char **values = NULL;
  int *regs = NULL;
  int npairs;
  int n;
  char tbuf[BUFFER_LEN], *tbp;
  char *preserve[NUMQ];
  const char *p;

  if ((nargs % 2) != 1) {
    safe_str(T("#-1 FUNCTION (letq) EXPECTS AN ODD NUMBER OF ARGUMENTS"),
             buff, bp);
    return;
  }

  npairs = (nargs - 1) / 2;

  for (n = 0; n < NUMQ; n++)
    preserve[n] = NULL;

  if (npairs) {
    values = mush_calloc(npairs, sizeof(char *), "letq.values");
    if (!values) {
      safe_str(T("#-1 UNABLE TO ALLOCATE MEMORY"), buff, bp);
      return;
    }

    regs = mush_calloc(npairs, sizeof(int), "letq.registers");
    if (!regs) {
      safe_str(T("#-1 UNABLE TO ALLOCATE MEMORY"), buff, bp);
      mush_free(values, "letq.values");
      return;
    }

    for (n = 0; n < npairs; n++) {
      int i = n * 2;

      tbp = tbuf;
      p = args[i];
      process_expression(tbuf, &tbp, &p, executor, caller, enactor, PE_DEFAULT,
                         PT_DEFAULT, pe_info);
      *tbp = '\0';
      regs[n] = qreg_indexes[(unsigned char) tbuf[0]];
      if (regs[n] < 0) {
        safe_str(T("#-1 REGISTER OUT OF RANGE"), buff, bp);
        goto cleanup;
      }

      tbp = tbuf;
      p = args[i + 1];
      process_expression(tbuf, &tbp, &p, executor, caller, enactor, PE_DEFAULT,
                         PT_DEFAULT, pe_info);
      *tbp = '\0';
      values[n] = mush_strdup(tbuf, "letq.value");
      if (!values[n]) {
        safe_str(T("#-1 UNABLE TO ALLOCATE MEMORY"), buff, bp);
        goto cleanup;
      }
    }

    for (n = 0; n < npairs; n++) {
      save_partial_global_reg("letq", preserve, regs[n]);
      mush_strncpy(global_eval_context.renv[regs[n]], values[n], BUFFER_LEN);
    }
  }
  p = args[nargs - 1];
  process_expression(buff, bp, &p, executor, caller, enactor, PE_DEFAULT,
                     PT_DEFAULT, pe_info);

cleanup:
  if (regs)
    mush_free(regs, "letq.registers");
  if (values) {
    restore_partial_global_regs("letq", preserve);
    for (n = 0; n < npairs; n++)
      mush_free(values[n], "letq.value");
    mush_free(values, "letq.values");
  }
}

/* ARGSUSED */
FUNCTION(fun_r)
{
  /* returns a local register */
  int qindex;

  if (*args[0] && (*(args[0] + 1) == '\0') &&
      ((qindex = qreg_indexes[(unsigned char) args[0][0]]) != -1)
      && global_eval_context.renv[qindex])
    safe_str(global_eval_context.renv[qindex], buff, bp);
  else
    safe_str(T("#-1 REGISTER OUT OF RANGE"), buff, bp);
}

/* --------------------------------------------------------------------------
 * Utility functions: RAND, DIE, SECURE, SPACE, BEEP, SWITCH, EDIT,
 *      ESCAPE, SQUISH, ENCRYPT, DECRYPT, LIT
 */

/* ARGSUSED */
FUNCTION(fun_rand)
{
  /*
   * Uses Sh'dow's random number generator, found in utils.c.  Better
   * distribution than original, w/ minimal speed losses.
   */
  int low, high;
  if (!is_integer(args[0])) {
    safe_str(T(e_int), buff, bp);
    return;
  }
  if (nargs == 1) {
    low = 0;
    high = parse_integer(args[0]) - 1;
  } else {
    if (!is_integer(args[1])) {
      safe_str(T(e_ints), buff, bp);
      return;
    }
    low = parse_integer(args[0]);
    high = parse_integer(args[1]);
  }

  if (low > high) {
    safe_str(T(e_range), buff, bp);
    return;
  }

  safe_integer(get_random_long(low, high), buff, bp);
}

/* ARGSUSED */
FUNCTION(fun_die)
{
  unsigned int n;
  unsigned int die;
  unsigned int count;
  unsigned int total = 0;
  int show_all = 0, first = 1;

  if (!is_uinteger(args[0]) || !is_uinteger(args[1])) {
    safe_str(T(e_uints), buff, bp);
    return;
  }
  n = parse_uinteger(args[0]);
  die = parse_uinteger(args[1]);
  if (nargs == 3)
    show_all = parse_boolean(args[2]);

  if (n == 0 || n > 20) {
    safe_str(T("#-1 NUMBER OUT OF RANGE"), buff, bp);
    return;
  }
  if (show_all) {
    for (count = 0; count < n; count++) {
      if (first)
        first = 0;
      else
        safe_chr(' ', buff, bp);
      safe_uinteger(get_random_long(1, die), buff, bp);
    }
  } else {
    for (count = 0; count < n; count++)
      total += get_random_long(1, die);

    safe_uinteger(total, buff, bp);
  }
}

/* ARGSUSED */
FUNCTION(fun_switch)
{
  /* this works a bit like the @switch command: it returns the string
   * appropriate to the match. It picks the first match, like @select
   * does, though.
   * Args to this function are passed unparsed. Args are not evaluated
   * until they are needed.
   */

  int j, per;
  char mstr[BUFFER_LEN], pstr[BUFFER_LEN], *dp;
  char const *sp;
  char *tbuf1 = NULL;
  int first = 1, found = 0, exact = 0;

  if (strstr(called_as, "ALL"))
    first = 0;

  if (string_prefix(called_as, "CASE"))
    exact = 1;

  dp = mstr;
  sp = args[0];
  process_expression(mstr, &dp, &sp, executor, caller, enactor,
                     PE_DEFAULT, PT_DEFAULT, pe_info);
  *dp = '\0';

  /* try matching, return match immediately when found */

  for (j = 1; j < (nargs - 1); j += 2) {
    dp = pstr;
    sp = args[j];
    process_expression(pstr, &dp, &sp, executor, caller, enactor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    *dp = '\0';

    if ((!exact)
        ? local_wild_match(pstr, mstr)
        : (strcmp(pstr, mstr) == 0)) {
      /* If there's a #$ in a switch's action-part, replace it with
       * the value of the conditional (mstr) before evaluating it.
       */
      if (!exact)
        tbuf1 = replace_string("#$", mstr, args[j + 1]);
      else
        tbuf1 = args[j + 1];

      sp = tbuf1;

      per = process_expression(buff, bp, &sp,
                               executor, caller, enactor,
                               PE_DEFAULT, PT_DEFAULT, pe_info);
      if (!exact)
        mush_free((Malloc_t) tbuf1, "replace_string.buff");
      found = 1;
      if (per || first)
        return;
    }
  }

  if (!(nargs & 1) && !found) {
    /* Default case */
    if (!exact) {
      tbuf1 = replace_string("#$", mstr, args[nargs - 1]);
      sp = tbuf1;
    } else
      sp = args[nargs - 1];
    process_expression(buff, bp, &sp, executor, caller, enactor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    if (!exact)
      mush_free((Malloc_t) tbuf1, "replace_string.buff");
  }
}

FUNCTION(fun_reswitch)
{
  /* this works a bit like the @switch/regexp command */

  int j, per;
  char mstr[BUFFER_LEN], pstr[BUFFER_LEN], *dp;
  char const *sp;
  char *tbuf1;
  int first = 1, found = 0, cs = 1;

  if (strstr(called_as, "ALL"))
    first = 0;

  if (strcmp(called_as, "RESWITCHI") == 0
      || strcmp(called_as, "RESWITCHALLI") == 0)
    cs = 0;

  dp = mstr;
  sp = args[0];
  process_expression(mstr, &dp, &sp, executor, caller, enactor,
                     PE_DEFAULT, PT_DEFAULT, pe_info);
  *dp = '\0';

  /* try matching, return match immediately when found */

  for (j = 1; j < (nargs - 1); j += 2) {
    dp = pstr;
    sp = args[j];
    process_expression(pstr, &dp, &sp, executor, caller, enactor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    *dp = '\0';

    if (quick_regexp_match(pstr, mstr, cs)) {
      /* If there's a #$ in a switch's action-part, replace it with
       * the value of the conditional (mstr) before evaluating it.
       */
      tbuf1 = replace_string("#$", mstr, args[j + 1]);

      sp = tbuf1;

      per = process_expression(buff, bp, &sp,