cmd.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // cmd.c -- Quake script command processing module
  21
  22 #include "quakedef.h"
  23
  24 void Cmd_ForwardToServer (void);
  25
  26 #define MAX_ALIAS_NAME  32
  27
  28 typedef struct cmdalias_s
  29 {
  30         struct cmdalias_s       *next;
  31         char    name[MAX_ALIAS_NAME];
  32         char    *value;
  33 } cmdalias_t;
  34
  35 cmdalias_t      *cmd_alias;
  36
  37 int trashtest;
  38 int *trashspot;
  39
  40 qboolean        cmd_wait;
  41
  42 //=============================================================================
  43
  44 /*
  45 ============
  46 Cmd_Wait_f
  47
  48 Causes execution of the remainder of the command buffer to be delayed until
  49 next frame.  This allows commands like:
  50 bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2"
  51 ============
  52 */
  53 void Cmd_Wait_f (void)
  54 {
  55         cmd_wait = true;
  56 }
  57
  58 /*
  59 =============================================================================
  60
  61                                                 COMMAND BUFFER
  62
  63 =============================================================================
  64 */
  65
  66 sizebuf_t       cmd_text;
  67
  68 /*
  69 ============
  70 Cbuf_Init
  71 ============
  72 */
  73 void Cbuf_Init (void)
  74 {
  75         SZ_Alloc (&cmd_text, 8192);             // space for commands and script files
  76 }
  77
  78
  79 /*
  80 ============
  81 Cbuf_AddText
  82
  83 Adds command text at the end of the buffer
  84 ============
  85 */
  86 void Cbuf_AddText (char *text)
  87 {
  88         int             l;
  89
  90         l = strlen (text);
  91
  92         if (cmd_text.cursize + l >= cmd_text.maxsize)
  93         {
  94                 Con_Printf ("Cbuf_AddText: overflow\n");
  95                 return;
  96         }
  97
  98         SZ_Write (&cmd_text, text, strlen (text));
  99 }
 100
 101
 102 /*
 103 ============
 104 Cbuf_InsertText
 105
 106 Adds command text immediately after the current command
 107 Adds a \n to the text
 108 FIXME: actually change the command buffer to do less copying
 109 ============
 110 */
 111 void Cbuf_InsertText (char *text)
 112 {
 113         char    *temp;
 114         int             templen;
 115
 116 // copy off any commands still remaining in the exec buffer
 117         templen = cmd_text.cursize;
 118         if (templen)
 119         {
 120                 temp = Z_Malloc (templen);
 121                 memcpy (temp, cmd_text.data, templen);
 122                 SZ_Clear (&cmd_text);
 123         }
 124         else
 125                 temp = NULL;    // shut up compiler
 126
 127 // add the entire text of the file
 128         Cbuf_AddText (text);
 129
 130 // add the copied off data
 131         if (templen)
 132         {
 133                 SZ_Write (&cmd_text, temp, templen);
 134                 Z_Free (temp);
 135         }
 136 }
 137
 138 /*
 139 ============
 140 Cbuf_Execute
 141 ============
 142 */
 143 void Cbuf_Execute (void)
 144 {
 145         int             i;
 146         char    *text;
 147         char    line[1024];
 148         int             quotes;
 149
 150         while (cmd_text.cursize)
 151         {
 152 // find a \n or ; line break
 153                 text = (char *)cmd_text.data;
 154
 155                 quotes = 0;
 156                 for (i=0 ; i< cmd_text.cursize ; i++)
 157                 {
 158                         if (text[i] == '"')
 159                                 quotes++;
 160                         if ( !(quotes&1) &&  text[i] == ';')
 161                                 break;  // don't break if inside a quoted string
 162                         if (text[i] == '\n')
 163                                 break;
 164                 }
 165
 166
 167                 memcpy (line, text, i);
 168                 line[i] = 0;
 169
 170 // delete the text from the command buffer and move remaining commands down
 171 // this is necessary because commands (exec, alias) can insert data at the
 172 // beginning of the text buffer
 173
 174                 if (i == cmd_text.cursize)
 175                         cmd_text.cursize = 0;
 176                 else
 177                 {
 178                         i++;
 179                         cmd_text.cursize -= i;
 180                         memcpy (text, text+i, cmd_text.cursize);
 181                 }
 182
 183 // execute the command line
 184                 Cmd_ExecuteString (line, src_command);
 185
 186                 if (cmd_wait)
 187                 {       // skip out while text still remains in buffer, leaving it
 188                         // for next frame
 189                         cmd_wait = false;
 190                         break;
 191                 }
 192         }
 193 }
 194
 195 /*
 196 ==============================================================================
 197
 198                                                 SCRIPT COMMANDS
 199
 200 ==============================================================================
 201 */
 202
 203 /*
 204 ===============
 205 Cmd_StuffCmds_f
 206
 207 Adds command line parameters as script statements
 208 Commands lead with a +, and continue until a - or another +
 209 quake +prog jctest.qp +cmd amlev1
 210 quake -nosound +cmd amlev1
 211 ===============
 212 */
 213 void Cmd_StuffCmds_f (void)
 214 {
 215         int             i, j;
 216         int             s;
 217         char    *text, *build, c;
 218
 219         if (Cmd_Argc () != 1)
 220         {
 221                 Con_Printf ("stuffcmds : execute command line parameters\n");
 222                 return;
 223         }
 224
 225 // build the combined string to parse from
 226         s = 0;
 227         for (i=1 ; i<com_argc ; i++)
 228         {
 229                 if (!com_argv[i])
 230                         continue;               // NEXTSTEP nulls out -NXHost
 231                 s += strlen (com_argv[i]) + 1;
 232         }
 233         if (!s)
 234                 return;
 235
 236         text = Z_Malloc (s+1);
 237         text[0] = 0;
 238         for (i=1 ; i<com_argc ; i++)
 239         {
 240                 if (!com_argv[i])
 241                         continue;               // NEXTSTEP nulls out -NXHost
 242                 strcat (text,com_argv[i]);
 243                 if (i != com_argc-1)
 244                         strcat (text, " ");
 245         }
 246
 247 // pull out the commands
 248         build = Z_Malloc (s+1);
 249         build[0] = 0;
 250
 251         for (i=0 ; i<s-1 ; i++)
 252         {
 253                 if (text[i] == '+')
 254                 {
 255                         i++;
 256
 257                         for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++)
 258                                 ;
 259
 260                         c = text[j];
 261                         text[j] = 0;
 262
 263                         strcat (build, text+i);
 264                         strcat (build, "\n");
 265                         text[j] = c;
 266                         i = j-1;
 267                 }
 268         }
 269
 270         if (build[0])
 271                 Cbuf_InsertText (build);
 272
 273         Z_Free (text);
 274         Z_Free (build);
 275 }
 276
 277
 278 /*
 279 ===============
 280 Cmd_Exec_f
 281 ===============
 282 */
 283 void Cmd_Exec_f (void)
 284 {
 285         char    *f;
 286
 287         if (Cmd_Argc () != 2)
 288         {
 289                 Con_Printf ("exec <filename> : execute a script file\n");
 290                 return;
 291         }
 292
 293         f = (char *)COM_LoadMallocFile (Cmd_Argv(1), false);
 294         if (!f)
 295         {
 296                 Con_Printf ("couldn't exec %s\n",Cmd_Argv(1));
 297                 return;
 298         }
 299         Con_Printf ("execing %s\n",Cmd_Argv(1));
 300
 301         Cbuf_InsertText (f);
 302         qfree(f);
 303 }
 304
 305
 306 /*
 307 ===============
 308 Cmd_Echo_f
 309
 310 Just prints the rest of the line to the console
 311 ===============
 312 */
 313 void Cmd_Echo_f (void)
 314 {
 315         int             i;
 316
 317         for (i=1 ; i<Cmd_Argc() ; i++)
 318                 Con_Printf ("%s ",Cmd_Argv(i));
 319         Con_Printf ("\n");
 320 }
 321
 322 /*
 323 ===============
 324 Cmd_Alias_f
 325
 326 Creates a new command that executes a command string (possibly ; seperated)
 327 ===============
 328 */
 329
 330 char *CopyString (char *in)
 331 {
 332         char    *out;
 333
 334         out = Z_Malloc (strlen(in)+1);
 335         strcpy (out, in);
 336         return out;
 337 }
 338
 339 void Cmd_Alias_f (void)
 340 {
 341         cmdalias_t      *a;
 342         char            cmd[1024];
 343         int                     i, c;
 344         char            *s;
 345
 346         if (Cmd_Argc() == 1)
 347         {
 348                 Con_Printf ("Current alias commands:\n");
 349                 for (a = cmd_alias ; a ; a=a->next)
 350                         Con_Printf ("%s : %s\n", a->name, a->value);
 351                 return;
 352         }
 353
 354         s = Cmd_Argv(1);
 355         if (strlen(s) >= MAX_ALIAS_NAME)
 356         {
 357                 Con_Printf ("Alias name is too long\n");
 358                 return;
 359         }
 360
 361         // if the alias already exists, reuse it
 362         for (a = cmd_alias ; a ; a=a->next)
 363         {
 364                 if (!strcmp(s, a->name))
 365                 {
 366                         Z_Free (a->value);
 367                         break;
 368                 }
 369         }
 370
 371         if (!a)
 372         {
 373                 a = Z_Malloc (sizeof(cmdalias_t));
 374                 a->next = cmd_alias;
 375                 cmd_alias = a;
 376         }
 377         strcpy (a->name, s);
 378
 379 // copy the rest of the command line
 380         cmd[0] = 0;             // start out with a null string
 381         c = Cmd_Argc();
 382         for (i=2 ; i< c ; i++)
 383         {
 384                 strcat (cmd, Cmd_Argv(i));
 385                 if (i != c)
 386                         strcat (cmd, " ");
 387         }
 388         strcat (cmd, "\n");
 389
 390         a->value = CopyString (cmd);
 391 }
 392
 393 /*
 394 =============================================================================
 395
 396                                         COMMAND EXECUTION
 397
 398 =============================================================================
 399 */
 400
 401 typedef struct cmd_function_s
 402 {
 403         struct cmd_function_s   *next;
 404         char                                    *name;
 405         xcommand_t                              function;
 406 } cmd_function_t;
 407
 408
 409 #define MAX_ARGS                80
 410
 411 static  int                     cmd_argc;
 412 static  char            *cmd_argv[MAX_ARGS];
 413 static  char            *cmd_null_string = "";
 414 static  char            *cmd_args = NULL;
 415
 416 cmd_source_t    cmd_source;
 417
 418
 419 static  cmd_function_t  *cmd_functions;         // possible commands to execute
 420
 421 /*
 422 ============
 423 Cmd_Init
 424 ============
 425 */
 426 void Cmd_Init (void)
 427 {
 428 //
 429 // register our commands
 430 //
 431         Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
 432         Cmd_AddCommand ("exec",Cmd_Exec_f);
 433         Cmd_AddCommand ("echo",Cmd_Echo_f);
 434         Cmd_AddCommand ("alias",Cmd_Alias_f);
 435         Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
 436         Cmd_AddCommand ("wait", Cmd_Wait_f);
 437 }
 438
 439 /*
 440 ============
 441 Cmd_Argc
 442 ============
 443 */
 444 int             Cmd_Argc (void)
 445 {
 446         return cmd_argc;
 447 }
 448
 449 /*
 450 ============
 451 Cmd_Argv
 452 ============
 453 */
 454 char    *Cmd_Argv (int arg)
 455 {
 456         if (arg >= cmd_argc )
 457                 return cmd_null_string;
 458         return cmd_argv[arg];
 459 }
 460
 461 /*
 462 ============
 463 Cmd_Args
 464 ============
 465 */
 466 char            *Cmd_Args (void)
 467 {
 468         return cmd_args;
 469 }
 470
 471
 472 /*
 473 ============
 474 Cmd_TokenizeString
 475
 476 Parses the given string into command line tokens.
 477 ============
 478 */
 479 void Cmd_TokenizeString (char *text)
 480 {
 481         int             i;
 482
 483 // clear the args from the last string
 484         for (i=0 ; i<cmd_argc ; i++)
 485                 Z_Free (cmd_argv[i]);
 486
 487         cmd_argc = 0;
 488         cmd_args = NULL;
 489
 490         while (1)
 491         {
 492 // skip whitespace up to a /n
 493                 while (*text && *text <= ' ' && *text != '\n')
 494                 {
 495                         text++;
 496                 }
 497
 498                 if (*text == '\n')
 499                 {       // a newline seperates commands in the buffer
 500                         text++;
 501                         break;
 502                 }
 503
 504                 if (!*text)
 505                         return;
 506
 507                 if (cmd_argc == 1)
 508                          cmd_args = text;
 509
 510                 text = COM_Parse (text);
 511                 if (!text)
 512                         return;
 513
 514                 if (cmd_argc < MAX_ARGS)
 515                 {
 516                         cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1);
 517                         strcpy (cmd_argv[cmd_argc], com_token);
 518                         cmd_argc++;
 519                 }
 520         }
 521
 522 }
 523
 524
 525 /*
 526 ============
 527 Cmd_AddCommand
 528 ============
 529 */
 530 void    Cmd_AddCommand (char *cmd_name, xcommand_t function)
 531 {
 532         cmd_function_t  *cmd;
 533
 534         if (host_initialized)   // because hunk allocation would get stomped
 535                 Sys_Error ("Cmd_AddCommand after host_initialized");
 536
 537 // fail if the command is a variable name
 538         if (Cvar_VariableString(cmd_name)[0])
 539         {
 540                 Con_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
 541                 return;
 542         }
 543
 544 // fail if the command already exists
 545         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 546         {
 547                 if (!strcmp (cmd_name, cmd->name))
 548                 {
 549                         Con_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
 550                         return;
 551                 }
 552         }
 553
 554         cmd = Hunk_AllocName (sizeof(cmd_function_t), "commands");
 555         cmd->name = cmd_name;
 556         cmd->function = function;
 557         cmd->next = cmd_functions;
 558         cmd_functions = cmd;
 559 }
 560
 561 /*
 562 ============
 563 Cmd_Exists
 564 ============
 565 */
 566 qboolean        Cmd_Exists (char *cmd_name)
 567 {
 568         cmd_function_t  *cmd;
 569
 570         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 571         {
 572                 if (!strcmp (cmd_name,cmd->name))
 573                         return true;
 574         }
 575
 576         return false;
 577 }
 578
 579
 580
 581 /*
 582 ============
 583 Cmd_CompleteCommand
 584 ============
 585 */
 586 char *Cmd_CompleteCommand (char *partial)
 587 {
 588         cmd_function_t  *cmd;
 589         int                             len;
 590
 591         len = strlen(partial);
 592
 593         if (!len)
 594                 return NULL;
 595
 596 // check functions
 597         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 598                 if (!strncmp (partial,cmd->name, len))
 599                         return cmd->name;
 600
 601         return NULL;
 602 }
 603
 604 /*
 605 ============
 606 Cmd_ExecuteString
 607
 608 A complete command line has been parsed, so try to execute it
 609 FIXME: lookupnoadd the token to speed search?
 610 ============
 611 */
 612 void    Cmd_ExecuteString (char *text, cmd_source_t src)
 613 {
 614         cmd_function_t  *cmd;
 615         cmdalias_t              *a;
 616
 617         cmd_source = src;
 618         Cmd_TokenizeString (text);
 619
 620 // execute the command line
 621         if (!Cmd_Argc())
 622                 return;         // no tokens
 623
 624 // check functions
 625         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 626         {
 627                 if (!Q_strcasecmp (cmd_argv[0],cmd->name))
 628                 {
 629                         cmd->function ();
 630                         return;
 631                 }
 632         }
 633
 634 // check alias
 635         for (a=cmd_alias ; a ; a=a->next)
 636         {
 637                 if (!Q_strcasecmp (cmd_argv[0], a->name))
 638                 {
 639                         Cbuf_InsertText (a->value);
 640                         return;
 641                 }
 642         }
 643
 644 // check cvars
 645         if (!Cvar_Command ())
 646                 Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
 647
 648 }
 649
 650
 651 /*
 652 ===================
 653 Cmd_ForwardToServer
 654
 655 Sends the entire command line over to the server
 656 ===================
 657 */
 658 void Cmd_ForwardToServer (void)
 659 {
 660         if (cls.state != ca_connected)
 661         {
 662                 Con_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
 663                 return;
 664         }
 665
 666         if (cls.demoplayback)
 667                 return;         // not really connected
 668
 669         MSG_WriteByte (&cls.message, clc_stringcmd);
 670         if (Q_strcasecmp(Cmd_Argv(0), "cmd") != 0)
 671         {
 672                 SZ_Print (&cls.message, Cmd_Argv(0));
 673                 SZ_Print (&cls.message, " ");
 674         }
 675         if (Cmd_Argc() > 1)
 676                 SZ_Print (&cls.message, Cmd_Args());
 677         else
 678                 SZ_Print (&cls.message, "\n");
 679 }
 680
 681
 682 /*
 683 ================
 684 Cmd_CheckParm
 685
 686 Returns the position (1 to argc-1) in the command's argument list
 687 where the given parameter apears, or 0 if not present
 688 ================
 689 */
 690
 691 int Cmd_CheckParm (char *parm)
 692 {
 693         int i;
 694
 695         if (!parm)
 696                 Sys_Error ("Cmd_CheckParm: NULL");
 697
 698         for (i = 1; i < Cmd_Argc (); i++)
 699                 if (!Q_strcasecmp (parm, Cmd_Argv (i)))
 700                         return i;
 701
 702         return 0;
 703 }