/*****************************************************************************
 ** Project    : pDirt (AberMUD IV/Dirt/Dyrt MUD daemon)
 ** Module     : parse.c
 ** Author     : Peter Eussen (Marty) 
 ** Version    : 1.02
 ** Date       : 20 October 1996
 ** Description: A Parser based on the old parser and hash parser. This
 **              Time I decided to stick with the 'normal' table parser.
 **              It searches the list from front to end for a match. If
 **              one is found, it will try to execute it. Should this
 **              not be possible because of a seurity mask, it will try
 **              to find an second option. (That is if you have specified
 **              FIND_SECOND in config.h)
 **              The word breakup reoutines are the same as the old one.
 **
 ** [Marty/20/10/96]
 **     Fixed small bug, which caused some error messages that shouldn't
 **     be there.
 **     Fixing idle times.
 ***************************************************************************/
 
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include "kernel.h"
#include "mudtypes.h"
#include "verbs.h"
#include "special.h"
#include "cmd_handlers.h"
#include "mobile.h"
#include "global.h"
#include "bprintf.h"
#include "levels.h"
#include "lflags.h"
#include "sendsys.h"
#include "mail.h"
#include "timing.h"
#include "log.h"
#include "uaf.h"
#ifdef INTERMUD
#include "InterMud/intermud.h"
#endif
#ifdef ABERCHAT
#include "AberChat/client.h"
#endif

/* Prototype for a command function
 */
typedef void (*Cmd_Func)(void);

/* Type definition for the table structure.
 * Every entry of the table follows this structure
 */
typedef struct a_commandh {
   char     verb[16];		/* The verb (string) */
   int      verbnum;		/* The verb number (needed for specials) */
   Cmd_Func func;		/* The command handler/function */
   int      mode;		/* Mode for this command */
}  Command_Handler;

/* DEFINITIONS
 */
static Command_Handler **Command_Table;		/* The verb table */
static int Command_Table_Size = 0;		/* Size of the table */
static int second_best = 0;			/* Second best try */
static char cmd_buf[16];			/* Storage for the verb */

/* Prepositions.. verbs that arent important when trying to interpret a 
 * command from the user
 */
static char *Prep_Table[] =
{  NULL,   "at",    "on",   "to",  "in",  "with",  "into",   "from",   "out",
   TABLE_END
};

/* Macros to be able to quickly get to the record entries in the command
 * table.
 */
#define COMMAND_FUNC(x)		Command_Table[(x)]->func
#define COMMAND_VERB(x)		Command_Table[(x)]->verb
#define COMMAND_NUM(x)		Command_Table[(x)]->verbnum
#define COMMAND_MODE(x)		Command_Table[(x)]->mode

/* All modes available for commands 
 */
#define M_ALL			0	/* Command is available to everyone */
#define M_NOTFORCED		1	/* Command cant be forced */
#define M_NOTINMAIL		2	/* Command cant be run from within the mailer */
#define M_NOTALIASED		4	/* Command not while aliased */
#define M_WIZONLY		8	/* Wiz+ only command */
#define M_AWIZONLY		16	/* Awiz+ only command */
#define M_DGODONLY		32	/* Demi+ God only command */
#define M_GODONLY		64	/* God+ only command */
#define LEVEL_MASK		120

/* Some command definition for commands that are handled in this file, or which
 * require parameters and thus do not fit the table model
 */
A_COMMAND(quit_game);
A_COMMAND(versioncom);
A_COMMAND(creditscom);
A_COMMAND(clscom);
A_COMMAND(set_travel_messages);
A_COMMAND(instart);
A_COMMAND(gotostart);
A_COMMAND(couplescom);
A_COMMAND(do_reset);
A_COMMAND(shutdownstart);
A_COMMAND(backupcom);

#ifdef ABERCHAT
#endif

/* Function prototypes 
 */
int  Interpret_Command(char *command, Boolean savecom);
int  Read_Verbs(FILE *fp);
void placecommand(int verbnum, Cmd_Func f,int mode);
void Set_Commands(void);
int  Get_Verbnum(char *str);
int  Game_Com(char *str,Boolean savecom);
void erreval(void);
int  brkword(void);
int  findplayer();
int  findprep (char *t);
void Execute_Command(int index);
static  char *markpos (void);
static  void parse_1 (char *itemb, int *pl, int *ob, int *pre);
Boolean parse_2 (int vb);

/* Bootstrap */
int Read_Verbs(FILE *fp)
{   int nverb,i=0;
    Command_Handler *h;
    
    fscanf(fp,"%d\n",&nverb);
    Command_Table = (Command_Handler **)malloc(nverb*sizeof(Command_Handler*));
    
    while (!feof(fp) && i != nverb)
    {   h = NEW(Command_Handler,1);
        fscanf(fp,"%s %d\n",h->verb,&h->verbnum);
        Command_Table[i] = h;
        i++;
    }
    Command_Table_Size = i;
    Set_Commands();
    return (sizeof(Command_Handler) * i) + sizeof(Command_Table);
}

/* Bootstrap */
void placecommand(int verbnum, Cmd_Func f,int mode)
{   int i=0;
    
    /* We'll have to work the whole list, cause there are multiple references
     * to the same command.
     */
    while (i < Command_Table_Size)    
    {    if (COMMAND_NUM(i) == verbnum)
         {   COMMAND_FUNC(i) = f;
             COMMAND_MODE(i) = mode;
         }
         i++;
    }
}

/* Bootstrap */
void Set_Commands(void)
{   int i;

    for (i=0;i < Command_Table_Size;i++)
       COMMAND_FUNC(i) = NULL;
       
    placecommand(VERB_DROP,dropcom,M_ALL);
    placecommand(VERB_EAST,dodirn,M_ALL);
    placecommand(VERB_GO,dogocom,M_ALL);
    placecommand(VERB_NORTH,dodirn,M_ALL);
    placecommand(VERB_WEST,dodirn,M_ALL);
    placecommand(VERB_SOUTH,dodirn,M_ALL);
    placecommand(VERB_UP,dodirn,M_ALL);
    placecommand(VERB_DOWN,dodirn,M_ALL);
    placecommand(VERB_NORTHEAST,dodirn,M_ALL);
    placecommand(VERB_NORTHWEST,dodirn,M_ALL);
    placecommand(VERB_SOUTHEAST,dodirn,M_ALL);
    placecommand(VERB_SOUTHWEST,dodirn,M_ALL);
    placecommand(VERB_TRANCE,trancecom,M_ALL);
    placecommand(VERB_SLEEP,sleepcom,M_ALL);
    placecommand(VERB_SIT,sitcom,M_ALL);
    placecommand(VERB_STAND,standstart,M_ALL);
    placecommand(VERB_GET,(void *)getcom,M_ALL);
    placecommand(VERB_SAY,saycom,M_ALL);
    placecommand(VERB_SHOUT,shoutcom,M_ALL);
    placecommand(VERB_INVENTORY,inventory,M_ALL);
    placecommand(VERB_WAKE,standstart,M_ALL);
    placecommand(VERB_WHO,whocom,M_ALL);
    placecommand(VERB_SAVE,saveme,M_ALL);
    placecommand(VERB_EAT,eatcom,M_ALL);
    placecommand(VERB_CLOSE,closecom,M_ALL);
    placecommand(VERB_OPEN,opencom,M_ALL);
    placecommand(VERB_LOCK,lockcom,M_ALL);
    placecommand(VERB_UNLOCK,unlockcom,M_ALL);
    placecommand(VERB_QUIT,quit_game,M_NOTFORCED|M_NOTINMAIL);
    placecommand(VERB_QUESTS,questcom,M_ALL);
    placecommand(VERB_QDONE,qdonecom,M_ALL);
    placecommand(VERB_SCORE,scorecom,M_ALL);
    placecommand(VERB_VALUE,valuecom,M_ALL);
    placecommand(VERB_INFO,infocom,M_ALL|M_NOTALIASED);
    placecommand(VERB_QINFO,qinfocom,M_ALL|M_NOTALIASED);
    placecommand(VERB_PINFO,powerinfocom,M_AWIZONLY);
    placecommand(VERB_LOOK,lookcom,M_ALL);
    placecommand(VERB_COMPARE,comparecom,M_ALL);
    placecommand(VERB_DIAGNOSE,diagnosecom,M_ALL);
    placecommand(VERB_STEAL,stealcom,M_ALL);
    placecommand(VERB_MAIL,mailcom,M_NOTFORCED|M_NOTINMAIL);
    placecommand(VERB_PROMPT,promptcom,M_ALL);
    placecommand(VERB_SCOREPROMPT,scorepromptcom,M_ALL);
    placecommand(VERB_HELP,helpcom,M_ALL);
    placecommand(VERB_CHAT,chatcom,M_ALL);
    placecommand(VERB_CEMOTE,cemotecom,M_ALL);
    placecommand(VERB_GOSSIP,gossipcom,M_ALL);
    placecommand(VERB_WIZ,wizcom,M_WIZONLY);
    placecommand(VERB_AWIZ,awizcom,M_AWIZONLY);
    placecommand(VERB_DGOD,demigodcom,M_DGODONLY);
    placecommand(VERB_GOD,godcom,M_GODONLY);
    placecommand(VERB_CRASH,shutdownstart,M_AWIZONLY|M_NOTFORCED);
    placecommand(VERB_SHUTDOWN,shutdownstart,M_AWIZONLY|M_NOTFORCED);
    placecommand(VERB_NORUN,noruncom,M_WIZONLY);
    placecommand(VERB_EXAMINE,examcom,M_ALL);
    placecommand(VERB_WIELD,wieldcom,M_ALL);
    placecommand(VERB_KILL,killcom,M_NOTINMAIL);
    placecommand(VERB_WEAR,wearcom,M_ALL);
    placecommand(VERB_WEARALL,wearall,M_ALL);
    placecommand(VERB_REMOVE,removecom,M_ALL);
    placecommand(VERB_PUT,putcom,M_ALL);
    placecommand(VERB_LIGHT,lightcom,M_ALL);
    placecommand(VERB_GIVE,givecom,M_ALL);
    placecommand(VERB_EQUIPMENT,equipcom,M_ALL);

    placecommand(VERB_SHOCK,spellcom,M_ALL);
    placecommand(VERB_SCAN,scancom,M_ALL);
    placecommand(VERB_FIREBALL,spellcom,M_ALL);
    placecommand(VERB_MISSILE,spellcom,M_ALL);
    placecommand(VERB_FROST,spellcom,M_ALL);
    placecommand(VERB_BLOW,blowcom,M_ALL);
    placecommand(VERB_PUSH,pushcom,M_ALL);
    placecommand(VERB_EXITS,exitcom,M_ALL);
    placecommand(VERB_DIG,digcom,M_ALL);
    placecommand(VERB_MELT,meltcom,M_ALL);
    placecommand(VERB_CLEAN,cleancom,M_ALL);
    placecommand(VERB_UNTIE,untiecom,M_ALL);
    placecommand(VERB_TIE,tiecom,M_ALL);
    placecommand(VERB_WHERE,wherecom,M_ALL);
    placecommand(VERB_FLEE,fleecom,M_ALL);
    placecommand(VERB_NOCHAT,notalklinecom,M_ALL);
    placecommand(VERB_NOGOSSIP,notalklinecom,M_ALL);
    placecommand(VERB_NOWIZ,notalklinecom,M_WIZONLY);
    placecommand(VERB_NOAWIZ,notalklinecom,M_AWIZONLY);
    placecommand(VERB_NODGOD,notalklinecom,M_DGODONLY);
    placecommand(VERB_NOGOD,notalklinecom,M_GODONLY);
    placecommand(VERB_FLOWERS,flowercom,M_ALL);
    placecommand(VERB_KOOSH,kooshcom,M_ALL);
    placecommand(VERB_PET,petcom,M_ALL);
    placecommand(VERB_PLAY,playcom,M_ALL);
    placecommand(VERB_POSE,posecom,M_ALL);
    placecommand(VERB_RING,ringcom,M_ALL);
    placecommand(VERB_ROSE,rosecom,M_ALL);
    placecommand(VERB_TICKLE,ticklecom,M_ALL);
    placecommand(VERB_WAVE,wavecom,M_ALL);
/*    placecommand(VERB_KISS,kisscom,M_ALL);*/
    placecommand(VERB_CUT,cutcom,M_ALL);
    placecommand(VERB_NOD,nodcom,M_ALL);
    placecommand(VERB_QUIET,quietcom,M_WIZONLY);
    placecommand(VERB_NOSHOUT,noshoutcom,M_WIZONLY);
    placecommand(VERB_NOCOMM,nocommcom,M_WIZONLY);
    placecommand(VERB_NOSLAIN,noslaincom,M_WIZONLY);
    placecommand(VERB_NOBEEP,nobeepcom,M_ALL);
    placecommand(VERB_NOBATTLE,nobattlecom,M_WIZONLY);
    placecommand(VERB_ALOOF,aloofcom,M_WIZONLY);
    placecommand(VERB_AWAY,awaycom,M_ALL);
    placecommand(VERB_CODE,codecom,M_ALL);
    placecommand(VERB_NOPUFF,nopuffcom,M_ALL);
    placecommand(VERB_COLOR,colorcom,M_ALL);
    placecommand(VERB_NOBLINK,noblinkcom,M_ALL);
    placecommand(VERB_BUSY,busycom,M_ALL);
    placecommand(VERB_COMPACT,compactcom,M_ALL);
    placecommand(VERB_NOINVENTORY,noinvencom,M_ALL);
    placecommand(VERB_AUTOEXIT,autoexitcom,M_ALL);
    placecommand(VERB_SAYBACK,saybackcom,M_ALL);
    placecommand(VERB_STATS,showplayer,M_WIZONLY);
#ifdef REBOOT
    placecommand(VERB_REBOOT,rebootcom,M_AWIZONLY);
    placecommand(VERB_DELAY,delaycom,M_AWIZONLY);
    placecommand(VERB_UPDATE,updatecom,M_AWIZONLY);
#else
    placecommand(VERB_REBOOT,erreval,M_ALL);
    placecommand(VERB_DELAY,erreval,M_ALL);
    placecommand(VERB_UPDATE,erreval,M_ALL);
#endif
    placecommand(VERB_RELOADACT,reboot_actions,M_AWIZONLY);
    placecommand(VERB_SYSLOG,syslogcom,M_ALL);
    placecommand(VERB_BUGLOG,buglogcom,M_ALL);
    placecommand(VERB_SUGGESTLOG,suggestlogcom,M_ALL);
    placecommand(VERB_ATSTAT,showATscom,M_WIZONLY);
#ifdef GROUP
    placecommand(VERB_PLEADER,pleader,M_ALL);
    placecommand(VERB_PSHARE,pshare,M_ALL);
    placecommand(VERB_PFOLLOW,pfollow,M_ALL);
    placecommand(VERB_PNAME,partyname,M_ALL);
    placecommand(VERB_PADD,padd,M_ALL);
    placecommand(VERB_PREMOVE,premove,M_ALL);
    placecommand(VERB_PARTIES,partiescom,M_WIZONLY);
    placecommand(VERB_PLEAVE,pleave,M_ALL);
    placecommand(VERB_PCREATE,pcreate,M_ALL);
    placecommand(VERB_PSTATUS,pstatus,M_ALL);
    placecommand(VERB_PSAY,psay,M_ALL);
#endif
    placecommand(VERB_TELL,tellcom,M_ALL);
    placecommand(VERB_LS,lscom,M_ALL);
    placecommand(VERB_KLOCK,klockstart,M_ALL);
    placecommand(VERB_DEBUG,debugstart,M_ALL);
    placecommand(VERB_TRACE,tracecom,M_WIZONLY);
    placecommand(VERB_CONFIG,config,M_ALL);
    placecommand(VERB_SIGNAL,signalcom,M_ALL);
    placecommand(VERB_UPTIME,uptimecom,M_ALL);
    placecommand(VERB_WLOAD,workloadcom,M_ALL);
    placecommand(VERB_HATES,hatecom,M_ALL);
    placecommand(VERB_JAIL,jailcom,M_NOTFORCED);
    placecommand(VERB_MEDITATE,meditatecom,M_ALL);
    placecommand(VERB_VERSION,versioncom,M_ALL);
    placecommand(VERB_PRIVS,pflagscom,M_ALL);
    placecommand(VERB_PFLAGS,pflagscom,M_ALL);
    placecommand(VERB_LFLAGS,lflagscom,M_WIZONLY);
    placecommand(VERB_ALIAS,aliascom,M_WIZONLY|M_NOTINMAIL|M_NOTALIASED);
    placecommand(VERB_ASMORTAL,asmortalcom,M_ALL|M_NOTINMAIL|M_NOTALIASED);
    placecommand(VERB_TRANSLOCATE,sumcom,M_ALL);
    placecommand(VERB_BANG,bangcom,M_ALL);
    placecommand(VERB_UNVEIL,unveilstart,M_ALL);
    placecommand(VERB_MOBILES,mobilecom,M_ALL);
    placecommand(VERB_EVENTS,eventscom,M_DGODONLY);
    placecommand(VERB_STOP,stopcom,M_WIZONLY);
    placecommand(VERB_START,startcom,M_WIZONLY);
    placecommand(VERB_WISH,wishcom,M_ALL);
    placecommand(VERB_ECHOTO,eehandler,M_ALL);
    placecommand(VERB_ECHOALL,eehandler,M_ALL);
    placecommand(VERB_ECHO,eehandler,M_ALL);
    placecommand(VERB_CLS,clscom,M_ALL);
    placecommand(VERB_LOSE,losecom,M_ALL);
    placecommand(VERB_FOLLOW,followcom,M_ALL);
    placecommand(VERB_BAN,bancom,M_AWIZONLY);
    placecommand(VERB_UNBAN,unbancom,M_AWIZONLY);
    placecommand(VERB_WIZLOCK,wizlock,M_ALL);
    placecommand(VERB_SHOW,showitem,M_WIZONLY);
    placecommand(VERB_PEACE,peacecom,M_WIZONLY);
    placecommand(VERB_WAR,warcom,M_WIZONLY);
    placecommand(VERB_TREASURES,treasurecom,M_WIZONLY);
    placecommand(VERB_TIME,timecom,M_ALL);
    placecommand(VERB_EMPTY,emptycom,M_ALL);
    placecommand(VERB_EMOTEALL,eehandler,M_ALL);
    placecommand(VERB_EMOTETO,eehandler,M_ALL);
    placecommand(VERB_EMOTE,eehandler,M_ALL);
    placecommand(VERB_WIMPY,change_wimpy,M_ALL);
    placecommand(VERB_EMERIFROB,emerifrobcom,M_AWIZONLY|M_NOTFORCED);
    placecommand(VERB_GODFROB,godfrobcom,M_NOTFORCED);
    placecommand(VERB_DGODFROB,dgodfrobcom,M_NOTFORCED);
    placecommand(VERB_AWIZFROB,awizfrobcom,M_NOTFORCED);
    placecommand(VERB_WIZFROB,wizfrobcom,M_NOTFORCED);
    placecommand(VERB_FROB,frobstart,M_WIZONLY);
    placecommand(VERB_MFLAGS,mflagscom,M_WIZONLY);
    placecommand(VERB_PFLAGRESET,pflagresetcom,M_WIZONLY);
    placecommand(VERB_MASK,maskcom,M_ALL);
    placecommand(VERB_BLIND,blindcom,M_ALL);
    placecommand(VERB_ACTIONS,lisextern,M_ALL);
    placecommand(VERB_PN,pncom,M_ALL);
    placecommand(VERB_LOG,logcom,M_WIZONLY|M_NOTFORCED);
    placecommand(VERB_TYPO,typocom,M_NOTFORCED);
    placecommand(VERB_BUG,bugcom,M_NOTFORCED);
    placecommand(VERB_SUGGEST,suggestcom,M_ALL);
    placecommand(VERB_BRIEF,briefcom,M_ALL);
    placecommand(VERB_CREDITS,creditscom,M_ALL);
    placecommand(VERB_THROW,throwcom,M_ALL);
    placecommand(VERB_ROLL,rollcom,M_ALL);
    placecommand(VERB_CFR,cfrcom,M_WIZONLY);
    placecommand(VERB_NRAW,namerawcom,M_ALL);
    placecommand(VERB_RAW,rawcom,M_ALL);
    placecommand(VERB_SNOOP,snoopcom,M_ALL);
    placecommand(VERB_BECOME,startbecom,M_NOTINMAIL|M_NOTFORCED);
    placecommand(VERB_LOCATIONS,zonescom,M_WIZONLY);
    placecommand(VERB_ZONES,zonescom,M_WIZONLY);
    placecommand(VERB_ZONEINFO,zoneinfocom,M_ALL);
    placecommand(VERB_CALENDAR,calendarcom,M_WIZONLY);
    placecommand(VERB_SETSTART,setstart,M_WIZONLY);
    placecommand(VERB_SETTRROOM,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETTRVICT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETTRENTER,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETSTAND,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETTRANCE,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETSLEEP,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETSIT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETQOUT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETQIN,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETVOUT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETVIN,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETMOUT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETMIN,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETOUT,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETIN,set_travel_messages,M_WIZONLY);
    placecommand(VERB_SETAWAY,set_travel_messages,M_WIZONLY);
    placecommand(VERB_TITLE,change_title,M_ALL);
    placecommand(VERB_RESURRECT,resurcom,M_WIZONLY);
    placecommand(VERB_DEAFEN,deafcom,M_ALL);
    placecommand(VERB_VISIBLE,viscom,M_ALL);
    placecommand(VERB_INVISIBLE,inviscom,M_WIZONLY);
    placecommand(VERB_AT,instart,M_WIZONLY);
    placecommand(VERB_IN,instart,M_WIZONLY);
    placecommand(VERB_OBJECTS,objectscom,M_WIZONLY);
    placecommand(VERB_CHANGE,changecom,M_ALL|M_NOTALIASED|M_NOTINMAIL);
    placecommand(VERB_MUTE,dumbcom,M_ALL);
    placecommand(VERB_HEALALL,healallcom,M_WIZONLY);
    placecommand(VERB_HEAL,healcom,M_WIZONLY);
    placecommand(VERB_CURE,curecom,M_ALL);
    placecommand(VERB_CRIPPLE,cripplecom,M_ALL);
    placecommand(VERB_EXTINGUISH,extinguishcom,M_ALL);
    placecommand(VERB_FORCE,forcecom,M_NOTFORCED);
    placecommand(VERB_GOTO,gotostart,M_ALL);
    placecommand(VERB_TIPTOE,gotostart,M_ALL); 
    placecommand(VERB_PRAY,praycom,M_ALL);
    placecommand(VERB_SET,setcom,M_WIZONLY);
    placecommand(VERB_CONVERSE,conversecom,M_ALL|M_NOTINMAIL);
    placecommand(VERB_OPENGAME,opengamecom,M_AWIZONLY|M_NOTFORCED);
    placecommand(VERB_ACCT,acctcom,M_WIZONLY);
    placecommand(VERB_DELETE,deletecom,M_ALL);
    placecommand(VERB_TOURNAMENT,tournamentcom,M_AWIZONLY);
    placecommand(VERB_KILLSOC,killsocket,M_AWIZONLY);
    placecommand(VERB_SOCINFO,socinfo,M_ALL);
    placecommand(VERB_DISCONNECT,disconnectcom,M_ALL);
    placecommand(VERB_TIMEOUT,timeoutcom,M_ALL);
    placecommand(VERB_GLOBAL,globalcom,M_WIZONLY);
    placecommand(VERB_STORE,storecom,M_ALL);
    placecommand(VERB_LOAD,loadcom,M_ALL);
    placecommand(VERB_CLONE,clonestart,M_ALL);
    placecommand(VERB_LINK,linkcom,M_WIZONLY);
    placecommand(VERB_MAXSTATE,maxstatecom,M_WIZONLY);
    placecommand(VERB_LOCTITLE,loctitlecom,M_WIZONLY);
    placecommand(VERB_WRITE,write_board,M_ALL);
    placecommand(VERB_ERASE,do_erase,M_ALL);
    placecommand(VERB_MESSAGE,do_read,M_ALL);
    placecommand(VERB_DESTRUCT,destructstart,M_ALL);
    placecommand(VERB_DESCRIPTION,change_desc,M_ALL);
    placecommand(VERB_RULERS,rulerscom,M_ALL);
    placecommand(VERB_POWERS,powerscom,M_ALL);
    placecommand(VERB_COUPLES,couplescom,M_ALL);
    placecommand(VERB_LEVELS,levelscom,M_ALL);
    placecommand(VERB_BULLETIN,bulletincom,M_ALL);
    placecommand(VERB_WIZLIST,wizlistcom,M_ALL);
    placecommand(VERB_SUMMON,sumcom,M_ALL);
    placecommand(VERB_EXORCISE,exorcom,M_ALL);
    placecommand(VERB_PUNT,puntcom,M_ALL);
    placecommand(VERB_REVIEW,reviewcom,M_WIZONLY);
    placecommand(VERB_PUNTZAP,puntzapcom,M_AWIZONLY|M_NOTFORCED);
    placecommand(VERB_WARNZAP,warnzapcom,M_WIZONLY|M_NOTFORCED);
    placecommand(VERB_ZAP,zapcom,M_NOTFORCED);
    placecommand(VERB_SAVESET,saveset,M_WIZONLY);
    placecommand(VERB_SAVEALL,saveallcom,M_WIZONLY);
    placecommand(VERB_RESET,do_reset,M_ALL);
    placecommand(VERB_MSTAT,mstatcom,M_WIZONLY);
    placecommand(VERB_MLEFT,mleftcom,M_WIZONLY);
    placecommand(VERB_USERS,usercom,M_ALL);
    placecommand(VERB_JUMP,jumpcom,M_ALL); 
    placecommand(VERB_LASTON,lastoncom,M_ALL);
    placecommand(VERB_SETPAGER,setpager,M_ALL);
    placecommand(VERB_SHORTEXIT,shortexitcom,M_ALL);
    placecommand(VERB_EMAIL,showemail,M_ALL);
    placecommand(VERB_HOME,homecom,M_WIZONLY);
    placecommand(VERB_BEEP,beepcom,M_ALL);
    placecommand(VERB_OLDLOGIN,oldlogincom,M_ALL);
    placecommand(VERB_NOWEATHER,noweathercom,M_ALL);
    placecommand(VERB_NOFINGER,nofingercom,M_ALL); 
#ifdef INTERMUD
    placecommand(VERB_IBOOT,imBoot,M_GODONLY|M_NOTFORCED);
    placecommand(VERB_ITELL,imTell,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_IGOSSIP,imGossip,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_IMUDLIST,imMudlist,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_IWHO,imWho,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_IFINGER,imFinger,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_ILOCATE,imLocate,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_ISHUTDOWN,imShutdownWrap,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_IMINVIS,imInvis,M_NOTFORCED|M_WIZONLY);
    placecommand(VERB_INOGOSSIP,imNogos,M_NOTFORCED|M_WIZONLY);
#endif
#ifdef ABERCHAT
    placecommand(VERB_NOACHAT, cmd_noachat,M_ALL);
    placecommand(VERB_NOACODE, cmd_noacode,M_ALL);
    placecommand(VERB_NOAGOD, cmd_noagod,M_ALL);
    placecommand(VERB_NOAINFO, cmd_noainfo,M_ALL);
    placecommand(VERB_NOATELL, cmd_noatell,M_ALL);
    placecommand(VERB_ABOOT, cmd_aboot,M_ALL);
    placecommand(VERB_ASHUTDOWN, cmd_ashutdown,M_ALL);
    placecommand(VERB_AWHO, cmd_awho,M_ALL);
    placecommand(VERB_NOABERCHAT, cmd_noaberchat,M_ALL);
    placecommand(VERB_AKICK, cmd_akick,M_ALL);
    placecommand(VERB_AAUTOCON, cmd_aautocon,M_ALL);
    placecommand(VERB_AMUDLIST, cmd_amudlist,M_ALL);
    placecommand(VERB_AVERSION, cmd_aversion,M_ALL);
    placecommand(VERB_AMASSLIST, cmd_amasslist,M_ALL);
    placecommand(VERB_APOLICY, cmd_apolicy,M_ALL);
    placecommand(VERB_ACOPYRIGHT, cmd_acopyright,M_ALL);
    placecommand(VERB_ATELL, cmd_atell,M_ALL);
    placecommand(VERB_AINFO, cmd_ainfo,M_ALL);
    placecommand(VERB_ACHAT, cmd_achat,M_ALL);
    placecommand(VERB_ACODE,cmd_acode,M_ALL);
    placecommand(VERB_AGOD, cmd_agod,M_ALL);
    placecommand(VERB_AREPLY, cmd_areply,M_ALL);
    placecommand(VERB_ACOMMSTATS, cmd_acommstats,M_ALL);
    placecommand(VERB_ABERCHATLOG, aberchatlogcom,M_AWIZONLY);
#endif
    placecommand(VERB_AUTOEAT,autoeatcom,M_ALL);
    placecommand(VERB_UAFBACKUP,make_backup,M_GODONLY);
    placecommand(VERB_TESTRUN,testruncom,M_ALL);
}

/* RunTime lookup of verb */
int Get_Verbnum(char *str)
{   int i=0,a=-1;

    while (i < Command_Table_Size && 
          (a = strncasecmp(COMMAND_VERB(i),str,strlen(str))) != 0)
        i++;
        
    if (a == 0)
       return i;
    else 
       return -1;
}

/* Runtime parsing of input part 1*/
int Game_Com(char *str,Boolean savecom)
{   int x;

    if (str != NULL && *str != '\0' && *str != '\n')
    {  cur_player->last_cmd = time(0);  
       x = Interpret_Command(str,savecom);
    }
    else
       x = 0;

    special_events(mynum);
    return x;
}

#ifdef FIND_SECOND
int Find_Second_Option(int start,int mode,char *input_cmd)
{   int i,a;

    for (i = (start+1); i < Command_Table_Size; i++)
    {  if ((a = strncasecmp(COMMAND_VERB(i),input_cmd,strlen(input_cmd))) == 0)
       {   if (mode >= COMMAND_MODE(i))
           {  second_best = i;
              return i;
           }
       }
    }
    second_best = -1;
    return -1;
}
#endif

/* runtime execution of command */
void Execute_Command(int index)
{   int level,mask;

    if (!parse_2(COMMAND_NUM(index)))
        return;

    mask  = COMMAND_MODE(index) & LEVEL_MASK;
    level = 0;

    if (cur_player->isforce)
    {   if ((COMMAND_MODE(index) & M_NOTFORCED) != 0)
        {  bprintf("You can\'t be force to do that.\n");
           return;
        }
    }
    
    if (cur_player->inmailer)
    {   if ((COMMAND_MODE(index) & M_NOTINMAIL) != 0)
        {  bprintf("Not while in the mailer.\n");
           return;
        }
    }
   
    if (cur_player->aliased || cur_player->polymorphed >= 0)
    {   if ((COMMAND_MODE(index) & M_NOTALIASED) != 0)
        {  bprintf("Not while aliased.\n");
           return;
        }
    }
 
    if (mask != 0)
    {  switch (mask) {
       case M_WIZONLY : level = LVL_APPREN; break;
       case M_AWIZONLY: level = LVL_ARCHWIZARD; break;
       case M_DGODONLY: level = LVL_DEMI; break;
       case M_GODONLY : level = LVL_GOD; break;
       default: level = 0; 
       }
    }
  
    if (level <= plev(mynum) || cur_player->aliased || cur_player->polymorphed != -1)
    {  verbnumber = COMMAND_NUM(index);
        
       if (COMMAND_FUNC(index) == NULL)
       {  mudlog("PARSE: No handler for command %d",COMMAND_NUM(index));
          bprintf("You can't do that now.\n");
       }
       else
          COMMAND_FUNC(index)(); 
    }
#ifdef FIND_SECOND
    else if (second_best != -1)
       erreval();
    else
    {  /* The previous command failed, because the Mode was too big (ie
        * only allowed for higher level players). So Let's make a second
        * guess to see if there are more commands that listen to the 
        * same abbreviation, and if so: try that one.
        */
       int mode;
       
       if (level < LVL_APPREN)
          mode = M_ALL;
       else if (level < LVL_ARCHWIZARD)
          mode = M_WIZONLY;
       else if (level < LVL_DEMI)
          mode = M_AWIZONLY;
       else if (level < LVL_GOD)
          mode = M_DGODONLY;
       else
          mode = M_GODONLY;

       if (Find_Second_Option(index,mode,cmd_buf) >= 0)
            Execute_Command(second_best);
       else 
          erreval();
    }
#else
    else
      erreval();
#endif
}

/* Interpretation of command and shortcuts */
int Interpret_Command(char *command, Boolean savecom)
{   static int a;

    if (*command == '!')
    {    return Game_Com(cur_player->prev_com,False);
    }
    else
    {   if (savecom)
           strcpy(cur_player->prev_com,command);
        
        stp = 0;
        second_best = -1;
        cur_player->last_command = time(0);

        if (cur_player->converse.active)
        {  if (cur_player->converse.talking_to != -1)
           {   if (!is_in_game(cur_player->converse.talking_to)) 
               {  bprintf("The other party has left the game. connection broken\n");
                  cur_player->converse.active = False;
                  strcpy(cur_player->prompt,cur_player->converse.old_prompt);
                  return 0;
               }
           }
           if (command[0] == '*')
           {   if (command[1] == '*')
               {   cur_player->converse.active = False;
                   strcpy(cur_player->prompt,cur_player->converse.old_prompt);
                   return 0;
               }
               else
                  strcpy(strbuf,command+1);
           }
           else if (cur_player->converse.talking_to == -1)
                sprintf(strbuf,"say %s",command);
           else
                sprintf(strbuf,"tell %s %s",pname(cur_player->converse.talking_to),
                        command);
           strncpy(command,strbuf,MAX_COM_LEN);
        }    

        /* Command is not a real command, but a shortcut (non alpha char) */
        if (!isalpha(*command))
        {   switch (command[0]) {
            case '\"':
            case '\'': strcpy(strbuf,"say "); strcat(strbuf, command+1); break;
            case '0' :
            case '[' : strcpy(strbuf,"chat "); strcat(strbuf, command+1); break;
            case ']' : strcpy(strbuf,"gossip "); strcat(strbuf, command+1); break;
            case ':' : strcpy(strbuf,"emote "); strcat(strbuf,command+1); break;
            case '1' : strcpy(strbuf,"wiz "); strcat(strbuf,command+1); break;
            case '2' : strcpy(strbuf,"awiz "); strcat(strbuf,command+1); break;
            case '3' : strcpy(strbuf,"dgod "); strcat(strbuf,command+1); break;
            case '4' : strcpy(strbuf,"god "); strcat(strbuf,command+1); break;
            default:
               strcpy(strbuf,command);
            }
        }   
        else 
           strcpy(strbuf,command);
        
        if (brkword() == -1)
        {   erreval();
            return -1;
        }

        if ((a = Get_Verbnum(wordbuf)) != -1)
        {   verbnumber = COMMAND_NUM(a);
            strcpy(cmd_buf,wordbuf);
            Execute_Command(a);
            return 0;
        }

        if (mob_fun(mynum) != NULL)
        {   param_s.plx = mynum;
            param_s.pl  = -1;
            param_s.ob  = -1;
            param_s.buf = wordbuf;
            param_s.ret = 1;
            mob_fun(mynum)(E_USER);
            if (param_s.ret != 1)
               return param_s.plx;
        }
        
        if (fextern(wordbuf) >= 0)
        {   stp = 0;
            return 0;
        }

        stp = 0;
        (void)brkword();

        if (fpbn(wordbuf) >= 0)
        {  stp = 0;
           a = Get_Verbnum("tell");
           Execute_Command(a);
           return 0;
        }

#ifdef INTERMUD
        if (strchr(wordbuf,'@')) 
        {   stp = 0;
            a = Get_Verbnum("tell");
            Execute_Command(a);
            return 0;
        }
#endif
        erreval();
    }
    return -1;
}

void Print_CmdTable(void)
{   int i;
    FILE *fp;
    char fn[80];

    sprintf(fn,"%s/verbs.%s",TEMP_DIR,pname(mynum));
    fp = fopen(fn,"w");
    if (fp == NULL)
    {   fwerror(fn);
        return;
    }
    
    fprintf(fp,"&+wCommand Verb      Num   Pointer   Mode\n&+w%s\n&*",DASHLINE);
   
    for (i=0; i < Command_Table_Size; i++)
    {    fprintf(fp,"%-16.16s   %.3d   %p   %d\n",COMMAND_VERB(i), COMMAND_NUM(i),
                 COMMAND_FUNC(i), COMMAND_MODE(i));
    }
    fclose(fp);
    read_file(fn,NULL,True,NULL);
    unlink(fn);
}

void erreval(void)
{   bprintf("I beg your pardon?\n");
}

int brkword(void)
{  
#define NOISE(x)	((x) == ' ' || (x) == ',' || (x) == '.')

   static int neword = 0;
   int worp;
   
   if (stp == 0)
      neword = 0;
      
   if (neword)
   {  neword = 0;
      return 0;
   }
   
   for (;;)
   {   while (NOISE(strbuf[stp]))
          stp++;
       
       for (worp = 0; strbuf[stp] != '\0' && !NOISE(strbuf[stp]);)
           wordbuf[worp++] = tolower(strbuf[stp++]);
           
       wordbuf[worp] = '\0';
       
       /* We've collected carbage, find more. */
       if (EQ(wordbuf,"the") || EQ(wordbuf,"a") || EQ(wordbuf,"an") ||
           EQ(wordbuf,"of")  || EQ(wordbuf,"with"))
         continue;
         
       if (EQ (wordbuf, "it"))
       {   /* Make sure no NULL pointer in here */
	  if(cur_player->wd_it)
            strcpy (wordbuf, cur_player->wd_it);
       }
      
       if (EQ (wordbuf, "him"))
       {   /* Make sure no NULL pointer in here */
	  if(cur_player->wd_him)
	  strcpy (wordbuf, cur_player->wd_him);
       }
      
       if (EQ (wordbuf, "her"))
       {   /* Make sure no NULL pointer in here */
	  if(cur_player->wd_her)
	  strcpy (wordbuf, cur_player->wd_her);
       }
      
       if (EQ (wordbuf, "them"))
       {   /* Make sure no NULL pointer in here */
	  if(cur_player->wd_them)
	  strcpy (wordbuf, cur_player->wd_them);
       }
      
       if (EQ (wordbuf, "me"))
         strcpy (wordbuf, pname (mynum));
      
       break;
   }
  
   return (worp ? 0 : -1);
}
         
Boolean parse_2 (int vb)
{
  int savestp = stp;
  int ob, pl, pre;
  
  *item1 = *item2 = '\0';
  
  if (vb == -1)
    return False;
  ob1 = pl1 = ob2 = pl2 = -1;
  prep = 0;
  txt1 = markpos ();
  txt2 = NULL;
  parse_1 (item1, &pl, &ob, &pre);
#if 0
  bprintf ("vb = %d, item1 = %s, pl = %d, ob = %d, pre = %d\n",
	   vb, item1, pl, ob, pre);
#endif
  if (pre == 0)
    {
      ob1 = ob;
      pl1 = pl;
      txt2 = markpos ();
      parse_1 (item2, &pl, &ob, &pre);
    }
  if (pre != 0)
    {
      prep = pre;
      parse_1 (item2, &pl, &ob, &pre);
    }
#if 0
  if (pre != 0)
    {
      bprintf ("Huh?\n");
      return False;
    }
  else
    {
      pl2 = pl;
      ob2 = ob;
    }
#else
  pl2 = pl;
  ob2 = ob;
#endif
  stp = savestp;
  return True;
}

static void parse_1 (char *itemb, int *pl, int *ob, int *pre)
{
  int o, p;
  
  *pl = *ob = -1;
  *pre = 0;

  if (brkword () != -1)
  {   strcpy (itemb, wordbuf);
      if ((p = findprep (itemb)) != -1)
	  *pre = p;
      else
      {   /* It's not a preposition. */
	  if ((p = *pl = fpbn (itemb)) != -1)
          {   if (psex (p))
	      {
		  cur_player->wd_them = strcpy (cur_player->wd_her, pname (p));
	      }
	      else
	      {
		  cur_player->wd_them = strcpy (cur_player->wd_him, pname (p));
	      }
          }
	  
	  if ((o = *ob = fobnc (itemb)) != -1 || (o = *ob = fobna (itemb)) != -1)
	  {
	      cur_player->wd_it = oname (o);
	  }
      }
  }
}

static char *markpos (void)
{
  register int c;
  
  while ((c = strbuf[stp]) == ',' || isspace (c))
    ++stp;
  return strbuf + stp;
}

int findprep (char *t)
{
  return xlookup (t, Prep_Table);
}

int findplayer()
{   int r = brkword();
    
    if (r!=-1)
    {  r = fpbns(wordbuf);
       if (r>= max_players)
          r = -2;
    }
    return r;
}

A_COMMAND(quit_game)
{ 
  STATIC char *goodbye="&-B&+w\t May the gods be with you on your journey. ";
  
  /* Would be an easy chicken way out of a fight */
  if (pfighting (mynum) >= 0)
  {  bprintf ("Not in the middle of a fight!\n");
     return;
  }

  /* Make sure the quit goes okay, by checking all special cases */
  if (cur_player->aliased)
  {
      unalias (real_mynum);
      return;
  }
  
  if (cur_player->polymorphed >= 0)
  {  bprintf ("A mysterious force won't let you quit.\n");
     return;
  }
  
  if (ltstflg(ploc(mynum),LFL_NO_QUIT) )
  {  bprintf("Somehow you it seems impossible to quit from here.\n");
     return;
  }

  bprintf ("Ok");
  send_msg (DEST_ALL, MODE_QUIET | MODE_BRACKET, Max(pvis (mynum), LVL_APPREN),
	    LVL_MAX, mynum, NOBODY, "Quitting Game: %s", pname (mynum));
  send_msg (ploc(mynum),MODE_QUIET,pvis(mynum),LVL_APPREN,mynum,NOBODY,
            "%s\n",build_setin(mynum,globalbuf,cur_player->setqout,pname(mynum),NULL)); 
  crapup (goodbye, CRAP_SAVE);
}

A_COMMAND(creditscom)
{  read_file(CREDITS,NULL,True,NULL);
}

A_COMMAND(couplescom)
{  read_file(COUPLES,NULL,True,NULL);
}

A_COMMAND(do_reset)
{   resetcom(RES_TEST);
}

A_COMMAND(clscom)
{  pcls(NULL,NULL);
}

A_COMMAND(instart)
{  if (verbnumber == VERB_IN)
      incom(True);
   else
      incom(False);
}

A_COMMAND(set_travel_messages)
{   switch(verbnumber) {
    case VERB_SETIN     : set_msg(cur_player->setin,False); break;
    case VERB_SETOUT    : set_msg(cur_player->setout,True); break;
    case VERB_SETMIN    : set_msg(cur_player->setmin,False); break;
    case VERB_SETMOUT   : set_msg(cur_player->setmout,False); break;
    case VERB_SETVIN    : set_msg(cur_player->setvin,False); break;
    case VERB_SETVOUT   : set_msg(cur_player->setvout,False); break;
    case VERB_SETQIN    : set_msg(cur_player->setqin,False); break;
    case VERB_SETQOUT   : set_msg(cur_player->setqout,False); break;
    case VERB_SETSIT    : set_msg(cur_player->setsit,False); break;
    case VERB_SETSLEEP  : set_msg(cur_player->setsleep,False); break;
    case VERB_SETTRANCE : set_msg(cur_player->settrance,False); break;
    case VERB_SETSTAND  : set_msg(cur_player->setstand,False); break;
    case VERB_SETTRROOM : set_msg(cur_player->settrroom,False); break;
    case VERB_SETTRENTER: set_msg(cur_player->settrenter,False); break;
    case VERB_SETTRVICT : set_msg(cur_player->settrvict,False); break;
    case VERB_SETAWAY   : set_msg(cur_player->setaway, False); break; 
    default: bprintf("Maybe in your next life.\n"); break;
    }
}

A_COMMAND(gotostart)
{  if (verbnumber == VERB_TIPTOE)
      gotocom(True);
   else
      gotocom(False);
}

A_COMMAND(shutdownstart)
{  if (verbnumber == VERB_CRASH)
      shutdowncom(True);
   else
      shutdowncom(False);
}

char *getreinput (char *b)
{ char buffer[MAX_COM_LEN];
  
  while (strbuf[stp] == ' ')
    stp++;
  
  strcpy (buffer, &rawbuf[stp]);
  strcpy (rawbuf, buffer);
  
  return b != NULL ? strcpy (b, &strbuf[stp]) : &strbuf[stp];
}

int Match(char *x, char *y)
{  if (strncasecmp(x,y,strlen(x)) == 0)
      return 10000;
   else return 0;
}

int chklist(char *word, char *lista[], int listb[])
{  int a,b,c;
   int d = -1;

   b = c =0;
   for  (a = 0;lista[a]; a++)
     if ((b = Match (word, lista[a])) > c)
     {  c = b;
        d = listb[a];
     }

   return (c < 5 ? -1 : d);
}