root/1.8.3/trunk/src/cmds.c

/**
 * \file cmds.c
 *
 * \brief Definitions of commands.
 * This file is a set of functions that defines commands. The parsing
 * of commands is elsewhere (command.c), as are the implementations
 * of most of the commands (throughout the source.)
 *
 */

#include "copyrite.h"
#include "config.h"

#include <string.h>

#include "conf.h"
#include "externs.h"
#include "dbdefs.h"
#include "mushdb.h"
#include "match.h"
#include "game.h"
#include "attrib.h"
#include "extmail.h"
#include "malias.h"
#include "parse.h"
#include "access.h"
#include "version.h"
#include "lock.h"
#include "function.h"
#include "command.h"
#include "flags.h"
#include "log.h"
#include "confmagic.h"

/* External Stuff */
void do_poor(dbref player, char *arg1);
void do_list_memstats(dbref player);

#define DOL_MAP 1               /**< dolist/map bitflag */
#define DOL_NOTIFY 2            /**< dolist/notify bitflag */
#define DOL_DELIM 4             /**< dolist/delim bitflag */

void do_dolist(dbref player, char *list, char *command,
               dbref cause, unsigned int flags);
void do_list(dbref player, char *arg, int lc);
void do_writelog(dbref player, char *str, int ltype);
void do_readcache(dbref player);
void do_scan(dbref player, char *command, int flag);
void do_uptime(dbref player, int mortal);
extern int config_set(const char *opt, char *val, int source, int restrictions);

/** Is there a right-hand side of the equal sign? From command.c */
extern int rhs_present;

COMMAND(cmd_allhalt)
{
  do_allhalt(player);
}

COMMAND(cmd_allquota)
{
  do_allquota(player, arg_left, SW_ISSET(sw, SWITCH_QUIET));
}

COMMAND(cmd_atrlock)
{
  do_atrlock(player, arg_left, arg_right);
}

COMMAND(cmd_attribute)
{
  if (SW_ISSET(sw, SWITCH_ACCESS))
    do_attribute_access(player, arg_left, arg_right,
                        SW_ISSET(sw, SWITCH_RETROACTIVE));
  else if (SW_ISSET(sw, SWITCH_DELETE))
    do_attribute_delete(player, arg_left);
  else if (SW_ISSET(sw, SWITCH_RENAME))
    do_attribute_rename(player, arg_left, arg_right);
  else
    do_attribute_info(player, arg_left);
}

COMMAND(cmd_atrchown)
{
  do_atrchown(player, arg_left, arg_right);
}

COMMAND(cmd_boot)
{
  if (SW_ISSET(sw, SWITCH_PORT))
    do_boot(player, arg_left, BOOT_DESC);
  else if (SW_ISSET(sw, SWITCH_ME))
    do_boot(player, (char *) NULL, BOOT_SELF);
  else if (SW_ISSET(sw, SWITCH_SILENT))
    do_boot(player, arg_left, BOOT_SILENT);
  else
    do_boot(player, arg_left, BOOT_NAME);
}

COMMAND(cmd_break)
{
  if (parse_boolean(arg_left)) {
    global_eval_context.break_called = 1;
    if (arg_right && *arg_right) {
      char const *sp = arg_right;
      char *bp = global_eval_context.break_replace;
      process_expression(global_eval_context.break_replace, &bp, &sp,
                         player, player, cause,
                         PE_COMMAND_BRACES, PT_DEFAULT, NULL);
      *bp++ = '\0';
    }
  }
}

COMMAND(cmd_assert)
{
  if (!parse_boolean(arg_left)) {
    global_eval_context.break_called = 1;
    if (arg_right && *arg_right) {
      char const *sp = arg_right;
      char *bp = global_eval_context.break_replace;
      process_expression(global_eval_context.break_replace, &bp, &sp,
                         player, player, cause,
                         PE_COMMAND_BRACES, PT_DEFAULT, NULL);
      *bp++ = '\0';
    }
  }
}

COMMAND(cmd_chownall)
{
  do_chownall(player, arg_left, arg_right, SW_ISSET(sw, SWITCH_PRESERVE));
}

COMMAND(cmd_chown)
{
  do_chown(player, arg_left, arg_right, SW_ISSET(sw, SWITCH_PRESERVE));
}

COMMAND(cmd_chzoneall)
{
  do_chzoneall(player, arg_left, arg_right);
}

COMMAND(cmd_chzone)
{
  (void) do_chzone(player, arg_left, arg_right, 1);
}

COMMAND(cmd_config)
{
  int lc;
  lc = SW_ISSET(sw, SWITCH_LOWERCASE);
  if (SW_ISSET(sw, SWITCH_GLOBALS))
    do_config_list(player, NULL, lc);
  else if (SW_ISSET(sw, SWITCH_DEFAULTS))
    do_config_list(player, NULL, lc);
  else if (SW_ISSET(sw, SWITCH_COSTS))
    do_config_list(player, NULL, lc);
  else if (SW_ISSET(sw, SWITCH_FUNCTIONS))
    do_list_functions(player, lc);
  else if (SW_ISSET(sw, SWITCH_COMMANDS))
    do_list_commands(player, lc);
  else if (SW_ISSET(sw, SWITCH_ATTRIBS))
    do_list_attribs(player, lc);
  else if (SW_ISSET(sw, SWITCH_LIST))
    do_config_list(player, arg_left, lc);
  else if (SW_ISSET(sw, SWITCH_FLAGS))
    do_list_flags("FLAG", player, arg_left, lc, T("Flags"));
  else if (SW_ISSET(sw, SWITCH_POWERS))
    do_list_flags("POWER", player, arg_left, lc, T("Powers"));
  else if (SW_ISSET(sw, SWITCH_SET)) {
    if (!Wizard(player)) {
      notify(player, T("You can't remake the world in your image."));
      return;
    }
    if (!arg_left || !*arg_left) {
      notify(player, T("What did you want to set?"));
      return;
    }
    if (!config_set(arg_left, arg_right, 1, 0)
        && !config_set(arg_left, arg_right, 1, 1))
      notify(player, T("Couldn't set that option"));
    else
      notify(player, T("Option set."));
  } else
    do_config_list(player, arg_left, lc);
}

COMMAND(cmd_cpattr)
{
  do_cpattr(player, arg_left, args_right, 0, SW_ISSET(sw, SWITCH_NOFLAGCOPY));
}

COMMAND(cmd_create)
{
  do_create(player, arg_left, parse_integer(arg_right));
}

COMMAND(cmd_clone)
{
  if (SW_ISSET(sw, SWITCH_PRESERVE))
    do_clone(player, arg_left, arg_right, SWITCH_PRESERVE);
  else
    do_clone(player, arg_left, arg_right, SWITCH_NONE);
}

COMMAND(cmd_dbck)
{
  do_dbck(player);
}

COMMAND(cmd_decompile)
{
  char prefix[BUFFER_LEN];
  int sd = SW_ISSET(sw, SWITCH_SKIPDEFAULTS);
  *prefix = '\0';
  if (SW_ISSET(sw, SWITCH_TF)) {
    /* @dec/tf overrides @dec/prefix */
    ATTR *a;
    if (((a = atr_get_noparent(player, "TFPREFIX")) != NULL) &&
        AL_STR(a) && *AL_STR(a)) {
      strcpy(prefix, atr_value(a));
    } else {
      strcpy(prefix, "FugueEdit > ");
    }
  } else if (SW_ISSET(sw, SWITCH_PREFIX)) {
    strcpy(prefix, arg_right);
  }
  if (SW_ISSET(sw, SWITCH_DB) || SW_ISSET(sw, SWITCH_TF))
    do_decompile(player, arg_left, prefix, DEC_DB, sd);
  else if (SW_ISSET(sw, SWITCH_FLAGS))
    do_decompile(player, arg_left, prefix, DEC_FLAG, sd);
  else if (SW_ISSET(sw, SWITCH_ATTRIBS))
    do_decompile(player, arg_left, prefix, DEC_ATTR, sd);
  else
    do_decompile(player, arg_left, prefix, DEC_NORMAL, sd);
}

COMMAND(cmd_teach)
{
  do_teach(player, cause, arg_left);
}

COMMAND(cmd_destroy)
{
  do_destroy(player, arg_left, (SW_ISSET(sw, SWITCH_OVERRIDE)));
}

COMMAND(cmd_dig)
{
  do_dig(player, arg_left, args_right, (SW_ISSET(sw, SWITCH_TELEPORT)));
}

COMMAND(cmd_disable)
{
  do_enable(player, arg_left, 0);
}

COMMAND(cmd_doing)
{
  if (SW_ISSET(sw, SWITCH_HEADER))
    do_poll(player, arg_left, 0);
  else
    do_doing(player, arg_left);
}

COMMAND(cmd_dolist)
{
  unsigned int flags = 0;
  if (SW_ISSET(sw, SWITCH_NOTIFY))
    flags |= DOL_NOTIFY;
  if (SW_ISSET(sw, SWITCH_DELIMIT))
    flags |= DOL_DELIM;
  do_dolist(player, arg_left, arg_right, cause, flags);
}

COMMAND(cmd_dump)
{
  if (SW_ISSET(sw, SWITCH_PARANOID))
    do_dump(player, arg_left, DUMP_PARANOID);
  else if (SW_ISSET(sw, SWITCH_DEBUG))
    do_dump(player, arg_left, DUMP_DEBUG);
  else
    do_dump(player, arg_left, DUMP_NORMAL);
}

COMMAND(cmd_edit)
{
  do_gedit(player, arg_left, args_right,
           SW_ISSET(sw, SWITCH_FIRST) ? EDIT_FIRST : EDIT_ALL,
           SW_ISSET(sw, SWITCH_CHECK) ? 0 : 1);
}

COMMAND(cmd_elock)
{
  do_lock(player, arg_left, arg_right, Enter_Lock);
}

COMMAND(cmd_emit)
{
  int spflags = !strcmp(cmd->name, "@NSEMIT") ? PEMIT_SPOOF : 0;
  SPOOF(player, cause, sw);

  if (SW_ISSET(sw, SWITCH_ROOM))
    do_lemit(player, arg_left,
             (SW_ISSET(sw, SWITCH_SILENT) * PEMIT_SILENT) | spflags);
  else
    do_emit(player, arg_left, spflags);
}

COMMAND(cmd_enable)
{
  do_enable(player, arg_left, 1);
}

COMMAND(cmd_entrances)
{
  if (SW_ISSET(sw, SWITCH_EXITS))
    do_entrances(player, arg_left, args_right, ENT_EXITS);
  else if (SW_ISSET(sw, SWITCH_THINGS))
    do_entrances(player, arg_left, args_right, ENT_THINGS);
  else if (SW_ISSET(sw, SWITCH_PLAYERS))
    do_entrances(player, arg_left, args_right, ENT_PLAYERS);
  else if (SW_ISSET(sw, SWITCH_ROOMS))
    do_entrances(player, arg_left, args_right, ENT_ROOMS);
  else
    do_entrances(player, arg_left, args_right, ENT_ALL);
}

COMMAND(cmd_eunlock)
{
  do_unlock(player, arg_left, Enter_Lock);
}

COMMAND(cmd_find)
{
  do_find(player, arg_left, args_right);
}

COMMAND(cmd_firstexit)
{
  do_firstexit(player, arg_left);
}

COMMAND(cmd_flag)
{
  if (SW_ISSET(sw, SWITCH_LIST))
    do_list_flags("FLAG", player, arg_left, 0, T("Flags"));
  else if (SW_ISSET(sw, SWITCH_ADD))
    do_flag_add("FLAG", player, arg_left, args_right);
  else if (SW_ISSET(sw, SWITCH_DELETE))
    do_flag_delete("FLAG", player, arg_left);
  else if (SW_ISSET(sw, SWITCH_ALIAS))
    do_flag_alias("FLAG", player, arg_left, args_right[1]);
  else if (SW_ISSET(sw, SWITCH_RESTRICT))
    do_flag_restrict("FLAG", player, arg_left, args_right);
  else if (SW_ISSET(sw, SWITCH_DISABLE))
    do_flag_disable("FLAG", player, arg_left);
  else if (SW_ISSET(sw, SWITCH_ENABLE))
    do_flag_enable("FLAG", player, arg_left);
  else if (SW_ISSET(sw, SWITCH_LETTER))
    do_flag_letter("FLAG", player, arg_left, args_right[1]);
  else if (SW_ISSET(sw, SWITCH_TYPE))
    do_flag_type("FLAG", player, arg_left, args_right[1]);
  else
    do_flag_info("FLAG", player, arg_left);
}

COMMAND(cmd_force)
{
  do_force(player, arg_left, arg_right);
}

COMMAND(cmd_function)
{
  if (SW_ISSET(sw, SWITCH_DELETE))
    do_function_delete(player, arg_left);
  else if (SW_ISSET(sw, SWITCH_ENABLE))
    do_function_toggle(player, arg_left, 1);
  else if (SW_ISSET(sw, SWITCH_DISABLE))
    do_function_toggle(player, arg_left, 0);
  else if (SW_ISSET(sw, SWITCH_RESTRICT))
    do_function_restrict(player, arg_left, args_right[1],
                         SW_ISSET(sw, SWITCH_BUILTIN));
  else if (SW_ISSET(sw, SWITCH_RESTORE))
    do_function_restore(player, arg_left);
  else {
    int split;
    char *saved;
    split = 0;
    saved = NULL;
    if (args_right[1] && *args_right[1] && !(args_right[2] && *args_right[2])) {
      split = 1;
      saved = args_right[2];
      if ((args_right[2] = strchr(args_right[1], '/')) == NULL) {
        notify(player, T("#-1 INVALID SECOND ARGUMENT"));
        return;
      }
      *args_right[2]++ = '\0';
    }
    if (args_right[1] && *args_right[1])
      do_function(player, arg_left, args_right, SW_ISSET(sw, SWITCH_PRESERVE));
    else if (arg_left && *arg_left)
      do_function_report(player, arg_left);
    else
      do_function(player, NULL, NULL, 0);
    if (split) {
      if (args_right[2])
        *--args_right[2] = '/';
      args_right[2] = saved;
    }
  }
}


COMMAND(cmd_grep)
{
  do_grep(player, arg_left, arg_right, ((SW_ISSET(sw, SWITCH_IPRINT))
                                        || (SW_ISSET(sw, SWITCH_PRINT))),
          ((SW_ISSET(sw, SWITCH_IPRINT))
           || (SW_ISSET(sw, SWITCH_ILIST))));
}

COMMAND(cmd_halt)
{
  if (SW_ISSET(sw, SWITCH_ALL))
    do_allhalt(player);
  else if (SW_BY_NAME(sw, "PID"))
    do_haltpid(player, arg_left);
  else
    do_halt1(player, arg_left, arg_right);
}

COMMAND(cmd_hide)
{
  hide_player(player, !(SW_ISSET(sw, SWITCH_NO) || SW_ISSET(sw, SWITCH_OFF)));
}

COMMAND(cmd_hook)
{
  enum hook_type flags;

  if (!(Wizard(player) || has_power_by_name(player, "HOOK", NOTYPE))) {
    notify(player, T("You need a fishing license to use that hook."));
    return;
  }

  if (SW_ISSET(sw, SWITCH_AFTER))
    flags = HOOK_AFTER;
  else if (SW_ISSET(sw, SWITCH_BEFORE))
    flags = HOOK_BEFORE;
  else if (SW_ISSET(sw, SWITCH_IGNORE))
    flags = HOOK_IGNORE;
  else if (SW_ISSET(sw, SWITCH_OVERRIDE))
    flags = HOOK_OVERRIDE;
  else if (SW_ISSET(sw, SWITCH_LIST)) {
    do_hook_list(player, arg_left);
    return;
  } else {
    notify(player, T("You must give a switch for @hook"));
    return;
  }
  do_hook(player, arg_left, args_right[1], args_right[2], flags);
}

COMMAND(cmd_huh_command)
{
  notify(player, T("Huh?  (Type \"help\" for help.)"));
}

COMMAND(cmd_home)
{
  if (!Mobile(player))
    return;
  do_move(player, "home", MOVE_NORMAL);
}

COMMAND(cmd_kick)
{
  do_kick(player, arg_left);
}

COMMAND(cmd_lemit)
{
  int spflags = !strcmp(cmd->name, "@NSLEMIT") ? PEMIT_SPOOF : 0;
  SPOOF(player, cause, sw);
  do_lemit(player, arg_left,
           (SW_ISSET(sw, SWITCH_SILENT) * PEMIT_SILENT) | spflags);
}

COMMAND(cmd_link)
{
  do_link(player, arg_left, arg_right, SW_ISSET(sw, SWITCH_PRESERVE));
}

COMMAND(cmd_listmotd)
{
  do_motd(player, MOTD_LIST, "");
}

COMMAND(cmd_list)
{
  int lc;
  lc = SW_ISSET(sw, SWITCH_LOWERCASE);
  if (SW_ISSET(sw, SWITCH_MOTD))
    do_motd(player, MOTD_LIST, "");
  else if (SW_ISSET(sw, SWITCH_FUNCTIONS))
    do_list_functions(player, lc);
  else if (SW_ISSET(sw,