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 #define MAX_ALIAS_NAME  32
  25
  26 typedef struct cmdalias_s
  27 {
  28         struct cmdalias_s *next;
  29         char name[MAX_ALIAS_NAME];
  30         char *value;
  31 } cmdalias_t;
  32
  33 static cmdalias_t *cmd_alias;
  34
  35 static qboolean cmd_wait;
  36
  37 static mempool_t *cmd_mempool;
  38
  39 #define CMD_TOKENIZELENGTH 4096
  40 static char cmd_tokenizebuffer[CMD_TOKENIZELENGTH];
  41 static int cmd_tokenizebufferpos = 0;
  42
  43 //=============================================================================
  44
  45 /*
  46 ============
  47 Cmd_Wait_f
  48
  49 Causes execution of the remainder of the command buffer to be delayed until
  50 next frame.  This allows commands like:
  51 bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2"
  52 ============
  53 */
  54 static void Cmd_Wait_f (void)
  55 {
  56         cmd_wait = true;
  57 }
  58
  59 /*
  60 =============================================================================
  61
  62                                                 COMMAND BUFFER
  63
  64 =============================================================================
  65 */
  66
  67 static sizebuf_t        cmd_text;
  68
  69 /*
  70 ============
  71 Cbuf_Init
  72 ============
  73 */
  74 void Cbuf_Init (void)
  75 {
  76         // LordHavoc: inreased this from 8192 to 32768
  77         SZ_Alloc (&cmd_text, 32768, "command buffer"); // space for commands and script files
  78 }
  79
  80
  81 /*
  82 ============
  83 Cbuf_AddText
  84
  85 Adds command text at the end of the buffer
  86 ============
  87 */
  88 void Cbuf_AddText (const char *text)
  89 {
  90         int             l;
  91
  92         l = strlen (text);
  93
  94         if (cmd_text.cursize + l >= cmd_text.maxsize)
  95         {
  96                 Con_Print("Cbuf_AddText: overflow\n");
  97                 return;
  98         }
  99
 100         SZ_Write (&cmd_text, text, strlen (text));
 101 }
 102
 103
 104 /*
 105 ============
 106 Cbuf_InsertText
 107
 108 Adds command text immediately after the current command
 109 Adds a \n to the text
 110 FIXME: actually change the command buffer to do less copying
 111 ============
 112 */
 113 void Cbuf_InsertText (const char *text)
 114 {
 115         char    *temp;
 116         int             templen;
 117
 118         // copy off any commands still remaining in the exec buffer
 119         templen = cmd_text.cursize;
 120         if (templen)
 121         {
 122                 temp = Mem_Alloc (tempmempool, templen);
 123                 memcpy (temp, cmd_text.data, templen);
 124                 SZ_Clear (&cmd_text);
 125         }
 126         else
 127                 temp = NULL;
 128
 129         // add the entire text of the file
 130         Cbuf_AddText (text);
 131
 132         // add the copied off data
 133         if (temp != NULL)
 134         {
 135                 SZ_Write (&cmd_text, temp, templen);
 136                 Mem_Free (temp);
 137         }
 138 }
 139
 140 /*
 141 ============
 142 Cbuf_Execute
 143 ============
 144 */
 145 void Cbuf_Execute (void)
 146 {
 147         int i;
 148         char *text;
 149         char line[1024];
 150         int quotes;
 151
 152         // LordHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
 153         cmd_tokenizebufferpos = 0;
 154
 155         while (cmd_text.cursize)
 156         {
 157 // find a \n or ; line break
 158                 text = (char *)cmd_text.data;
 159
 160                 quotes = 0;
 161                 for (i=0 ; i< cmd_text.cursize ; i++)
 162                 {
 163                         if (text[i] == '"')
 164                                 quotes++;
 165                         if ( !(quotes&1) &&  text[i] == ';')
 166                                 break;  // don't break if inside a quoted string
 167                         if (text[i] == '\r' || text[i] == '\n')
 168                                 break;
 169                 }
 170
 171                 memcpy (line, text, i);
 172                 line[i] = 0;
 173
 174 // delete the text from the command buffer and move remaining commands down
 175 // this is necessary because commands (exec, alias) can insert data at the
 176 // beginning of the text buffer
 177
 178                 if (i == cmd_text.cursize)
 179                         cmd_text.cursize = 0;
 180                 else
 181                 {
 182                         i++;
 183                         cmd_text.cursize -= i;
 184                         memcpy (cmd_text.data, text+i, cmd_text.cursize);
 185                 }
 186
 187 // execute the command line
 188                 Cmd_ExecuteString (line, src_command);
 189
 190                 if (cmd_wait)
 191                 {       // skip out while text still remains in buffer, leaving it
 192                         // for next frame
 193                         cmd_wait = false;
 194                         break;
 195                 }
 196         }
 197 }
 198
 199 /*
 200 ==============================================================================
 201
 202                                                 SCRIPT COMMANDS
 203
 204 ==============================================================================
 205 */
 206
 207 /*
 208 ===============
 209 Cmd_StuffCmds_f
 210
 211 Adds command line parameters as script statements
 212 Commands lead with a +, and continue until a - or another +
 213 quake +prog jctest.qp +cmd amlev1
 214 quake -nosound +cmd amlev1
 215 ===============
 216 */
 217 void Cmd_StuffCmds_f (void)
 218 {
 219         int             i, j, l;
 220         // this is per command, and bounds checked (no buffer overflows)
 221         char    build[2048];
 222
 223         if (Cmd_Argc () != 1)
 224         {
 225                 Con_Print("stuffcmds : execute command line parameters\n");
 226                 return;
 227         }
 228
 229         for (i = 0;i < com_argc;i++)
 230         {
 231                 if (com_argv[i] && com_argv[i][0] == '+' && (com_argv[i][1] < '0' || com_argv[i][1] > '9'))
 232                 {
 233                         l = 0;
 234                         j = 1;
 235                         while (com_argv[i][j])
 236                                 build[l++] = com_argv[i][j++];
 237                         i++;
 238                         for (;i < com_argc;i++)
 239                         {
 240                                 if (!com_argv[i])
 241                                         continue;
 242                                 if ((com_argv[i][0] == '+' || com_argv[i][0] == '-') && (com_argv[i][1] < '0' || com_argv[i][1] > '9'))
 243                                         break;
 244                                 if (l + strlen(com_argv[i]) + 5 > sizeof(build))
 245                                         break;
 246                                 build[l++] = ' ';
 247                                 build[l++] = '\"';
 248                                 for (j = 0;com_argv[i][j];j++)
 249                                         build[l++] = com_argv[i][j];
 250                                 build[l++] = '\"';
 251                         }
 252                         build[l++] = '\n';
 253                         build[l++] = 0;
 254                         Cbuf_InsertText (build);
 255                         i--;
 256                 }
 257         }
 258 }
 259
 260
 261 /*
 262 ===============
 263 Cmd_Exec_f
 264 ===============
 265 */
 266 static void Cmd_Exec_f (void)
 267 {
 268         char *f;
 269
 270         if (Cmd_Argc () != 2)
 271         {
 272                 Con_Print("exec <filename> : execute a script file\n");
 273                 return;
 274         }
 275
 276         f = (char *)FS_LoadFile (Cmd_Argv(1), tempmempool, false);
 277         if (!f)
 278         {
 279                 Con_Printf("couldn't exec %s\n",Cmd_Argv(1));
 280                 return;
 281         }
 282         Con_DPrintf("execing %s\n",Cmd_Argv(1));
 283
 284         Cbuf_InsertText (f);
 285         Mem_Free(f);
 286 }
 287
 288
 289 /*
 290 ===============
 291 Cmd_Echo_f
 292
 293 Just prints the rest of the line to the console
 294 ===============
 295 */
 296 static void Cmd_Echo_f (void)
 297 {
 298         int             i;
 299
 300         for (i=1 ; i<Cmd_Argc() ; i++)
 301                 Con_Printf("%s ",Cmd_Argv(i));
 302         Con_Print("\n");
 303 }
 304
 305 /*
 306 ===============
 307 Cmd_Alias_f
 308
 309 Creates a new command that executes a command string (possibly ; seperated)
 310 ===============
 311 */
 312 static void Cmd_Alias_f (void)
 313 {
 314         cmdalias_t      *a;
 315         char            cmd[1024];
 316         int                     i, c;
 317         const char              *s;
 318
 319         if (Cmd_Argc() == 1)
 320         {
 321                 Con_Print("Current alias commands:\n");
 322                 for (a = cmd_alias ; a ; a=a->next)
 323                         Con_Printf("%s : %s\n", a->name, a->value);
 324                 return;
 325         }
 326
 327         s = Cmd_Argv(1);
 328         if (strlen(s) >= MAX_ALIAS_NAME)
 329         {
 330                 Con_Print("Alias name is too long\n");
 331                 return;
 332         }
 333
 334         // if the alias already exists, reuse it
 335         for (a = cmd_alias ; a ; a=a->next)
 336         {
 337                 if (!strcmp(s, a->name))
 338                 {
 339                         Z_Free (a->value);
 340                         break;
 341                 }
 342         }
 343
 344         if (!a)
 345         {
 346                 a = Z_Malloc (sizeof(cmdalias_t));
 347                 a->next = cmd_alias;
 348                 cmd_alias = a;
 349         }
 350         strlcpy (a->name, s, sizeof (a->name));
 351
 352 // copy the rest of the command line
 353         cmd[0] = 0;             // start out with a null string
 354         c = Cmd_Argc();
 355         for (i=2 ; i< c ; i++)
 356         {
 357                 strlcat (cmd, Cmd_Argv(i), sizeof (cmd));
 358                 if (i != c)
 359                         strlcat (cmd, " ", sizeof (cmd));
 360         }
 361         strlcat (cmd, "\n", sizeof (cmd));
 362
 363         a->value = Z_Malloc (strlen (cmd) + 1);
 364         strcpy (a->value, cmd);
 365 }
 366
 367 /*
 368 =============================================================================
 369
 370                                         COMMAND EXECUTION
 371
 372 =============================================================================
 373 */
 374
 375 typedef struct cmd_function_s
 376 {
 377         struct cmd_function_s *next;
 378         const char *name;
 379         xcommand_t function;
 380 } cmd_function_t;
 381
 382
 383 #define MAX_ARGS                80
 384
 385 static int cmd_argc;
 386 static const char *cmd_argv[MAX_ARGS];
 387 static const char *cmd_null_string = "";
 388 static const char *cmd_args = NULL;
 389
 390 cmd_source_t cmd_source;
 391
 392
 393 static cmd_function_t *cmd_functions;           // possible commands to execute
 394
 395 /*
 396 ========
 397 Cmd_List
 398
 399         CmdList Added by EvilTypeGuy eviltypeguy@qeradiant.com
 400         Thanks to Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
 401
 402 ========
 403 */
 404 static void Cmd_List_f (void)
 405 {
 406         cmd_function_t *cmd;
 407         const char *partial;
 408         int len, count;
 409
 410         if (Cmd_Argc() > 1)
 411         {
 412                 partial = Cmd_Argv (1);
 413                 len = strlen(partial);
 414         }
 415         else
 416         {
 417                 partial = NULL;
 418                 len = 0;
 419         }
 420
 421         count = 0;
 422         for (cmd = cmd_functions; cmd; cmd = cmd->next)
 423         {
 424                 if (partial && strncmp(partial, cmd->name, len))
 425                         continue;
 426                 Con_Printf("%s\n", cmd->name);
 427                 count++;
 428         }
 429
 430         Con_Printf("%i Command%s", count, (count > 1) ? "s" : "");
 431         if (partial)
 432                 Con_Printf(" beginning with \"%s\"", partial);
 433
 434         Con_Print("\n\n");
 435 }
 436
 437 /*
 438 ============
 439 Cmd_Init
 440 ============
 441 */
 442 void Cmd_Init (void)
 443 {
 444         cmd_mempool = Mem_AllocPool("commands", 0, NULL);
 445
 446 //
 447 // register our commands
 448 //
 449         Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
 450         Cmd_AddCommand ("exec",Cmd_Exec_f);
 451         Cmd_AddCommand ("echo",Cmd_Echo_f);
 452         Cmd_AddCommand ("alias",Cmd_Alias_f);
 453         Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
 454         Cmd_AddCommand ("wait", Cmd_Wait_f);
 455         Cmd_AddCommand ("cmdlist", Cmd_List_f);         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
 456         Cmd_AddCommand ("cvarlist", Cvar_List_f);       // 2000-01-09 CmdList, CvarList commands
 457                                                                                                 // By Matthias "Maddes" Buecher
 458         Cmd_AddCommand ("set", Cvar_Set_f);
 459         Cmd_AddCommand ("seta", Cvar_SetA_f);
 460 }
 461
 462 /*
 463 ============
 464 Cmd_Shutdown
 465 ============
 466 */
 467 void Cmd_Shutdown(void)
 468 {
 469         Mem_FreePool(&cmd_mempool);
 470 }
 471
 472 /*
 473 ============
 474 Cmd_Argc
 475 ============
 476 */
 477 int             Cmd_Argc (void)
 478 {
 479         return cmd_argc;
 480 }
 481
 482 /*
 483 ============
 484 Cmd_Argv
 485 ============
 486 */
 487 const char *Cmd_Argv (int arg)
 488 {
 489         if (arg >= cmd_argc )
 490                 return cmd_null_string;
 491         return cmd_argv[arg];
 492 }
 493
 494 /*
 495 ============
 496 Cmd_Args
 497 ============
 498 */
 499 const char *Cmd_Args (void)
 500 {
 501         return cmd_args;
 502 }
 503
 504
 505 /*
 506 ============
 507 Cmd_TokenizeString
 508
 509 Parses the given string into command line tokens.
 510 ============
 511 */
 512 static void Cmd_TokenizeString (const char *text)
 513 {
 514         int l;
 515
 516         cmd_argc = 0;
 517         cmd_args = NULL;
 518
 519         while (1)
 520         {
 521                 // skip whitespace up to a /n
 522                 while (*text && *text <= ' ' && *text != '\n')
 523                         text++;
 524
 525                 if (*text == '\n')
 526                 {
 527                         // a newline seperates commands in the buffer
 528                         text++;
 529                         break;
 530                 }
 531
 532                 if (!*text)
 533                         return;
 534
 535                 if (cmd_argc == 1)
 536                          cmd_args = text;
 537
 538                 if (!COM_ParseTokenConsole(&text))
 539                         return;
 540
 541                 if (cmd_argc < MAX_ARGS)
 542                 {
 543                         l = strlen(com_token) + 1;
 544                         if (cmd_tokenizebufferpos + l > CMD_TOKENIZELENGTH)
 545                                 Sys_Error("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
 546                         strcpy (cmd_tokenizebuffer + cmd_tokenizebufferpos, com_token);
 547                         cmd_argv[cmd_argc] = cmd_tokenizebuffer + cmd_tokenizebufferpos;
 548                         cmd_tokenizebufferpos += l;
 549                         cmd_argc++;
 550                 }
 551         }
 552
 553 }
 554
 555
 556 /*
 557 ============
 558 Cmd_AddCommand
 559 ============
 560 */
 561 void Cmd_AddCommand (const char *cmd_name, xcommand_t function)
 562 {
 563         cmd_function_t *cmd;
 564
 565 // fail if the command is a variable name
 566         if (Cvar_VariableString(cmd_name)[0])
 567         {
 568                 Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
 569                 return;
 570         }
 571
 572 // fail if the command already exists
 573         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 574         {
 575                 if (!strcmp (cmd_name, cmd->name))
 576                 {
 577                         Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
 578                         return;
 579                 }
 580         }
 581
 582         cmd = Mem_Alloc(cmd_mempool, sizeof(cmd_function_t));
 583         cmd->name = cmd_name;
 584         cmd->function = function;
 585         cmd->next = cmd_functions;
 586         cmd_functions = cmd;
 587 }
 588
 589 /*
 590 ============
 591 Cmd_Exists
 592 ============
 593 */
 594 qboolean Cmd_Exists (const char *cmd_name)
 595 {
 596         cmd_function_t  *cmd;
 597
 598         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 599                 if (!strcmp (cmd_name,cmd->name))
 600                         return true;
 601
 602         return false;
 603 }
 604
 605
 606 /*
 607 ============
 608 Cmd_CompleteCommand
 609 ============
 610 */
 611 const char *Cmd_CompleteCommand (const char *partial)
 612 {
 613         cmd_function_t *cmd;
 614         int len;
 615
 616         len = strlen(partial);
 617
 618         if (!len)
 619                 return NULL;
 620
 621 // check functions
 622         for (cmd = cmd_functions; cmd; cmd = cmd->next)
 623                 if (!strncmp(partial, cmd->name, len))
 624                         return cmd->name;
 625
 626         return NULL;
 627 }
 628
 629 /*
 630         Cmd_CompleteCountPossible
 631
 632         New function for tab-completion system
 633         Added by EvilTypeGuy
 634         Thanks to Fett erich@heintz.com
 635         Thanks to taniwha
 636
 637 */
 638 int Cmd_CompleteCountPossible (const char *partial)
 639 {
 640         cmd_function_t *cmd;
 641         int len, h;
 642
 643         h = 0;
 644         len = strlen(partial);
 645
 646         if (!len)
 647                 return 0;
 648
 649         // Loop through the command list and count all partial matches
 650         for (cmd = cmd_functions; cmd; cmd = cmd->next)
 651                 if (!strncasecmp(partial, cmd->name, len))
 652                         h++;
 653
 654         return h;
 655 }
 656
 657 /*
 658         Cmd_CompleteBuildList
 659
 660         New function for tab-completion system
 661         Added by EvilTypeGuy
 662         Thanks to Fett erich@heintz.com
 663         Thanks to taniwha
 664
 665 */
 666 const char **Cmd_CompleteBuildList (const char *partial)
 667 {
 668         cmd_function_t *cmd;
 669         int len = 0;
 670         int bpos = 0;
 671         int sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (const char *);
 672         const char **buf;
 673
 674         len = strlen(partial);
 675         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
 676         // Loop through the alias list and print all matches
 677         for (cmd = cmd_functions; cmd; cmd = cmd->next)
 678                 if (!strncasecmp(partial, cmd->name, len))
 679                         buf[bpos++] = cmd->name;
 680
 681         buf[bpos] = NULL;
 682         return buf;
 683 }
 684
 685 /*
 686         Cmd_CompleteAlias
 687
 688         New function for tab-completion system
 689         Added by EvilTypeGuy
 690         Thanks to Fett erich@heintz.com
 691         Thanks to taniwha
 692
 693 */
 694 const char *Cmd_CompleteAlias (const char *partial)
 695 {
 696         cmdalias_t *alias;
 697         int len;
 698
 699         len = strlen(partial);
 700
 701         if (!len)
 702                 return NULL;
 703
 704         // Check functions
 705         for (alias = cmd_alias; alias; alias = alias->next)
 706                 if (!strncasecmp(partial, alias->name, len))
 707                         return alias->name;
 708
 709         return NULL;
 710 }
 711
 712 /*
 713         Cmd_CompleteAliasCountPossible
 714
 715         New function for tab-completion system
 716         Added by EvilTypeGuy
 717         Thanks to Fett erich@heintz.com
 718         Thanks to taniwha
 719
 720 */
 721 int Cmd_CompleteAliasCountPossible (const char *partial)
 722 {
 723         cmdalias_t      *alias;
 724         int                     len;
 725         int                     h;
 726
 727         h = 0;
 728
 729         len = strlen(partial);
 730
 731         if (!len)
 732                 return 0;
 733
 734         // Loop through the command list and count all partial matches
 735         for (alias = cmd_alias; alias; alias = alias->next)
 736                 if (!strncasecmp(partial, alias->name, len))
 737                         h++;
 738
 739         return h;
 740 }
 741
 742 /*
 743         Cmd_CompleteAliasBuildList
 744
 745         New function for tab-completion system
 746         Added by EvilTypeGuy
 747         Thanks to Fett erich@heintz.com
 748         Thanks to taniwha
 749
 750 */
 751 const char **Cmd_CompleteAliasBuildList (const char *partial)
 752 {
 753         cmdalias_t *alias;
 754         int len = 0;
 755         int bpos = 0;
 756         int sizeofbuf = (Cmd_CompleteAliasCountPossible (partial) + 1) * sizeof (const char *);
 757         const char **buf;
 758
 759         len = strlen(partial);
 760         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
 761         // Loop through the alias list and print all matches
 762         for (alias = cmd_alias; alias; alias = alias->next)
 763                 if (!strncasecmp(partial, alias->name, len))
 764                         buf[bpos++] = alias->name;
 765
 766         buf[bpos] = NULL;
 767         return buf;
 768 }
 769
 770 /*
 771 ============
 772 Cmd_ExecuteString
 773
 774 A complete command line has been parsed, so try to execute it
 775 FIXME: lookupnoadd the token to speed search?
 776 ============
 777 */
 778 void Cmd_ExecuteString (const char *text, cmd_source_t src)
 779 {
 780         int oldpos;
 781         cmd_function_t *cmd;
 782         cmdalias_t *a;
 783
 784         oldpos = cmd_tokenizebufferpos;
 785         cmd_source = src;
 786         Cmd_TokenizeString (text);
 787
 788 // execute the command line
 789         if (!Cmd_Argc())
 790         {
 791                 cmd_tokenizebufferpos = oldpos;
 792                 return;         // no tokens
 793         }
 794
 795 // check functions (only after host_initialized)
 796         if (host_initialized || !strcasecmp(cmd_argv[0], "exec") || !strcasecmp(cmd_argv[0], "set") || !strcasecmp(cmd_argv[0], "seta"))
 797         {
 798                 for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
 799                 {
 800                         if (!strcasecmp (cmd_argv[0],cmd->name))
 801                         {
 802                                 cmd->function ();
 803                                 cmd_tokenizebufferpos = oldpos;
 804                                 return;
 805                         }
 806                 }
 807         }
 808
 809 // check alias (only after host_initialized)
 810         if (host_initialized)
 811         {
 812                 for (a=cmd_alias ; a ; a=a->next)
 813                 {
 814                         if (!strcasecmp (cmd_argv[0], a->name))
 815                         {
 816                                 Cbuf_InsertText (a->value);
 817                                 cmd_tokenizebufferpos = oldpos;
 818                                 return;
 819                         }
 820                 }
 821         }
 822
 823 // check cvars (always)
 824         if (!Cvar_Command () && host_initialized)
 825                 Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0));
 826
 827         cmd_tokenizebufferpos = oldpos;
 828 }
 829
 830
 831 /*
 832 ===================
 833 Cmd_ForwardStringToServer
 834
 835 Sends an entire command string over to the server, unprocessed
 836 ===================
 837 */
 838 void Cmd_ForwardStringToServer (const char *s)
 839 {
 840         if (cls.state != ca_connected)
 841         {
 842                 Con_Printf("Can't \"%s\", not connected\n", s);
 843                 return;
 844         }
 845
 846         if (cls.demoplayback)
 847                 return;         // not really connected
 848
 849         // LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
 850         // attention, it has been eradicated from here, its only (former) use in
 851         // all of darkplaces.
 852         MSG_WriteByte(&cls.message, clc_stringcmd);
 853         SZ_Write(&cls.message, s, strlen(s) + 1);
 854 }
 855
 856 /*
 857 ===================
 858 Cmd_ForwardToServer
 859
 860 Sends the entire command line over to the server
 861 ===================
 862 */
 863 void Cmd_ForwardToServer (void)
 864 {
 865         const char *s;
 866         if (strcasecmp(Cmd_Argv(0), "cmd"))
 867                 s = va("%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : "");
 868         else
 869                 s = Cmd_Argc() > 1 ? Cmd_Args() : "";
 870         Cmd_ForwardStringToServer(s);
 871 }
 872
 873
 874 /*
 875 ================
 876 Cmd_CheckParm
 877
 878 Returns the position (1 to argc-1) in the command's argument list
 879 where the given parameter apears, or 0 if not present
 880 ================
 881 */
 882
 883 int Cmd_CheckParm (const char *parm)
 884 {
 885         int i;
 886
 887         if (!parm)
 888                 Sys_Error ("Cmd_CheckParm: NULL");
 889
 890         for (i = 1; i < Cmd_Argc (); i++)
 891                 if (!strcasecmp (parm, Cmd_Argv (i)))
 892                         return i;
 893
 894         return 0;
 895 }
 896