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 #include "thread.h"
  24
  25 cmd_state_t cmd_client;
  26 cmd_state_t cmd_server;
  27 cmd_state_t cmd_serverfromclient;
  28
  29 cmd_userdefined_t cmd_userdefined_all;
  30 cmd_userdefined_t cmd_userdefined_null;
  31
  32 typedef struct cmd_iter_s {
  33         cmd_state_t *cmd;
  34 }
  35 cmd_iter_t;
  36
  37 static cmd_iter_t cmd_iter_all[] = {
  38         {&cmd_client},
  39         {&cmd_server},
  40         {&cmd_serverfromclient},
  41         {NULL},
  42 };
  43
  44 mempool_t *cbuf_mempool;
  45
  46 // we only run the +whatever commandline arguments once
  47 qbool host_stuffcmdsrun = false;
  48
  49 //=============================================================================
  50
  51 void Cbuf_Lock(cmd_buf_t *cbuf)
  52 {
  53         Thread_LockMutex(cbuf->lock);
  54 }
  55
  56 void Cbuf_Unlock(cmd_buf_t *cbuf)
  57 {
  58         Thread_UnlockMutex(cbuf->lock);
  59 }
  60
  61
  62 /*
  63 ============
  64 Cmd_Wait_f
  65
  66 Causes execution of the remainder of the command buffer to be delayed until
  67 next frame.  This allows commands like:
  68 bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2"
  69 ============
  70 */
  71 static void Cmd_Wait_f (cmd_state_t *cmd)
  72 {
  73         cmd->cbuf->wait = true;
  74 }
  75
  76 /*
  77 ============
  78 Cmd_Defer_f
  79
  80 Cause a command to be executed after a delay.
  81 ============
  82 */
  83 static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing);
  84 static void Cmd_Defer_f (cmd_state_t *cmd)
  85 {
  86         cmd_input_t *current;
  87         cmd_buf_t *cbuf = cmd->cbuf;
  88
  89         if(Cmd_Argc(cmd) == 1)
  90         {
  91                 if(List_IsEmpty(&cbuf->deferred))
  92                         Con_Printf("No commands are pending.\n");
  93                 else
  94                 {
  95                         llist_t *pos;
  96                 List_ForEach(pos, &cbuf->deferred)
  97                 {
  98                                 current = List_Container(*pos, cmd_input_t, list);
  99                                 Con_Printf("-> In %9.2f: %s\n", current->delay, current->text);
 100                         }
 101                 }
 102         }
 103         else if(Cmd_Argc(cmd) == 2 && !strcasecmp("clear", Cmd_Argv(cmd, 1)))
 104         {
 105                 while(!List_IsEmpty(&cbuf->deferred))
 106                         List_Move_Tail(cbuf->deferred.next, &cbuf->free);
 107         }
 108         else if(Cmd_Argc(cmd) == 3)
 109         {
 110                 const char *text = Cmd_Argv(cmd, 2);
 111                 current = Cbuf_LinkGet(cbuf, NULL);
 112                 current->length = strlen(text);
 113                 current->source = cmd;
 114                 current->delay = atof(Cmd_Argv(cmd, 1));
 115
 116                 if(current->size < current->length)
 117                 {
 118                         current->text = (char *)Mem_Realloc(cbuf_mempool, current->text, current->length + 1);
 119                         current->size = current->length;
 120                 }
 121
 122                 strlcpy(current->text, text, current->length + 1);
 123
 124                 List_Move_Tail(&current->list, &cbuf->deferred);
 125         }
 126         else
 127         {
 128                 Con_Printf("usage: defer <seconds> <command>\n"
 129                            "       defer clear\n");
 130                 return;
 131         }
 132 }
 133
 134 /*
 135 ============
 136 Cmd_Centerprint_f
 137
 138 Print something to the center of the screen using SCR_Centerprint
 139 ============
 140 */
 141 static void Cmd_Centerprint_f (cmd_state_t *cmd)
 142 {
 143         char msg[MAX_INPUTLINE];
 144         unsigned int i, c, p;
 145         c = Cmd_Argc(cmd);
 146         if(c >= 2)
 147         {
 148                 strlcpy(msg, Cmd_Argv(cmd,1), sizeof(msg));
 149                 for(i = 2; i < c; ++i)
 150                 {
 151                         strlcat(msg, " ", sizeof(msg));
 152                         strlcat(msg, Cmd_Argv(cmd, i), sizeof(msg));
 153                 }
 154                 c = (unsigned int)strlen(msg);
 155                 for(p = 0, i = 0; i < c; ++i)
 156                 {
 157                         if(msg[i] == '\\')
 158                         {
 159                                 if(msg[i+1] == 'n')
 160                                         msg[p++] = '\n';
 161                                 else if(msg[i+1] == '\\')
 162                                         msg[p++] = '\\';
 163                                 else {
 164                                         msg[p++] = '\\';
 165                                         msg[p++] = msg[i+1];
 166                                 }
 167                                 ++i;
 168                         } else {
 169                                 msg[p++] = msg[i];
 170                         }
 171                 }
 172                 msg[p] = '\0';
 173                 SCR_CenterPrint(msg);
 174         }
 175 }
 176
 177 /*
 178 =============================================================================
 179
 180                                                 COMMAND BUFFER
 181
 182 =============================================================================
 183 */
 184
 185 static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing)
 186 {
 187         cmd_input_t *ret = NULL;
 188         if(existing && existing->pending)
 189                 ret = existing;
 190         else if(!List_IsEmpty(&cbuf->free))
 191         {
 192                 ret = List_Container(*cbuf->free.next, cmd_input_t, list);
 193                 ret->length = 0;
 194                 ret->pending = false;
 195         }
 196         return ret;
 197 }
 198
 199 static cmd_input_t *Cmd_AllocInputNode(void)
 200 {
 201         cmd_input_t *node = (cmd_input_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_input_t));
 202         node->list.prev = node->list.next = &node->list;
 203         node->size = node->length = node->pending = 0;
 204         return node;
 205 }
 206
 207 static size_t Cmd_ParseInput (cmd_input_t **output, char **input)
 208 {
 209         size_t pos, cmdsize = 0, start = 0;
 210         qbool command = false, lookahead = false;
 211         qbool quotes = false, comment = false;
 212         qbool escaped = false;
 213
 214         /*
 215          * The Quake command-line is super basic. It can be entered in the console
 216          * or in config files. A semicolon is used to terminate a command and chain
 217          * them together. Otherwise, a newline delineates command input.
 218          *
 219          * In most engines, the Quake command-line is a simple linear text buffer that
 220          * is parsed when it executes. In Darkplaces, we use a linked list of command
 221          * input and parse the input on the spot.
 222          *
 223          * This was done because Darkplaces allows multiple command interpreters on the
 224          * same thread. Previously, each interpreter maintained its own buffer and this
 225          * caused problems related to execution order, and maintaining a single simple
 226          * buffer for all interpreters makes it non-trivial to keep track of which
 227          * command should execute on which interpreter.
 228          */
 229
 230         // Run until command and lookahead are both true, or until we run out of input.
 231         for (pos = 0; (*input)[pos]; pos++)
 232         {
 233                 // Look for newlines and semicolons. Ignore semicolons in quotes.
 234                 switch((*input)[pos])
 235                 {
 236                 case '\r':
 237                 case '\n':
 238                         command = false;
 239                         comment = false;
 240                         break;
 241                 default:
 242                         if(!comment) // Not a newline so far. Still not a valid command yet.
 243                         {
 244                                 if(!quotes && (*input)[pos] == ';') // Ignore semicolons in quotes.
 245                                         command = false;
 246                                 else if (ISCOMMENT((*input), pos)) // Comments
 247                                 {
 248                                         comment = true;
 249                                         command = false;
 250                                 }
 251                                 else
 252                                 {
 253                                         command = true;
 254                                         if(!lookahead)
 255                                         {
 256                                                 if(!cmdsize)
 257                                                         start = pos;
 258                                                 cmdsize++;
 259                                         }
 260
 261                                         switch((*input)[pos])
 262                                         {
 263                                         case '"':
 264                                                 if (!escaped)
 265                                                         quotes = !quotes;
 266                                                 else
 267                                                         escaped = false;
 268                                                 break;
 269                                         case '\\':
 270                                                 if (!escaped && quotes)
 271                                                         escaped = true;
 272                                                 else if (escaped)
 273                                                         escaped = false;
 274                                                 break;
 275                                         }
 276                                 }
 277                         }
 278                 }
 279                 if(cmdsize && !command)
 280                         lookahead = true;
 281
 282                 if(command && lookahead)
 283                         break;
 284         }
 285
 286         if(cmdsize)
 287         {
 288                 size_t offset = 0;
 289
 290                 if(!*output)
 291                         *output = Cmd_AllocInputNode();
 292
 293                 if((*output)->pending)
 294                         offset = (*output)->length;
 295
 296                 (*output)->length += cmdsize;
 297
 298                 if((*output)->size < (*output)->length)
 299                 {
 300                         (*output)->text = (char *)Mem_Realloc(cbuf_mempool, (*output)->text, (*output)->length + 1);
 301                         (*output)->size = (*output)->length;
 302                 }
 303
 304                 strlcpy(&(*output)->text[offset], &(*input)[start], cmdsize + 1);
 305                 (*output)->pending = !lookahead;
 306         }
 307
 308         // Set input to its new position. Can be NULL.
 309         *input = &(*input)[pos];
 310
 311         return cmdsize;
 312 }
 313
 314 // Cloudwalk: Not happy with this, but it works.
 315 static void Cbuf_LinkCreate(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text)
 316 {
 317         char *in = (char *)&text[0];
 318         cmd_buf_t *cbuf = cmd->cbuf;
 319         size_t totalsize = 0, newsize = 0;
 320         cmd_input_t *current = NULL;
 321
 322         // Slide the pointer down until we reach the end
 323         while(*in)
 324         {
 325                 current = Cbuf_LinkGet(cbuf, existing);
 326                 newsize = Cmd_ParseInput(&current, &in);
 327
 328                 // Valid command
 329                 if(newsize)
 330                 {
 331                         if(current != existing)
 332                         {
 333                                 current->source = cmd;
 334                                 List_Move_Tail(&current->list, head);
 335                         }
 336
 337                         totalsize += newsize;
 338                 }
 339                 else if (current == existing && !totalsize)
 340                         current->pending = false;
 341                 current = NULL;
 342         }
 343
 344         cbuf->size += totalsize;
 345 }
 346
 347 /*
 348 ============
 349 Cbuf_AddText
 350
 351 Adds command text at the end of the buffer
 352 ============
 353 */
 354 void Cbuf_AddText (cmd_state_t *cmd, const char *text)
 355 {
 356         size_t l = strlen(text);
 357         cmd_buf_t *cbuf = cmd->cbuf;
 358         llist_t llist = {&llist, &llist};
 359
 360         Cbuf_Lock(cbuf);
 361
 362         if (cbuf->maxsize - cbuf->size <= l)
 363                 Con_Print("Cbuf_AddText: overflow\n");
 364         else
 365         {
 366                 Cbuf_LinkCreate(cmd, &llist, (List_IsEmpty(&cbuf->start) ? NULL : List_Container(*cbuf->start.prev, cmd_input_t, list)), text);
 367                 if(!List_IsEmpty(&llist))
 368                         List_Splice_Tail(&llist, &cbuf->start);
 369         }
 370         Cbuf_Unlock(cbuf);
 371 }
 372
 373 /*
 374 ============
 375 Cbuf_InsertText
 376
 377 Adds command text immediately after the current command
 378 FIXME: actually change the command buffer to do less copying
 379 ============
 380 */
 381 void Cbuf_InsertText (cmd_state_t *cmd, const char *text)
 382 {
 383         cmd_buf_t *cbuf = cmd->cbuf;
 384         llist_t llist = {&llist, &llist};
 385         size_t l = strlen(text);
 386
 387         Cbuf_Lock(cbuf);
 388
 389         // we need to memmove the existing text and stuff this in before it...
 390         if (cbuf->size + l >= cbuf->maxsize)
 391                 Con_Print("Cbuf_InsertText: overflow\n");
 392         else
 393         {
 394                 Cbuf_LinkCreate(cmd, &llist, List_Container(*cbuf->start.next, cmd_input_t, list), text);
 395                 if(!List_IsEmpty(&llist))
 396                         List_Splice(&llist, &cbuf->start);
 397         }
 398
 399         Cbuf_Unlock(cbuf);
 400 }
 401
 402 /*
 403 ============
 404 Cbuf_Execute_Deferred --blub
 405 ============
 406 */
 407 static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf)
 408 {
 409         llist_t *pos;
 410         cmd_input_t *current;
 411         double eat;
 412
 413         if (host.realtime - cbuf->deferred_oldtime < 0 || host.realtime - cbuf->deferred_oldtime > 1800)
 414                 cbuf->deferred_oldtime = host.realtime;
 415         eat = host.realtime - cbuf->deferred_oldtime;
 416         if (eat < (1.0 / 120.0))
 417                 return;
 418         cbuf->deferred_oldtime = host.realtime;
 419
 420     List_ForEach(pos, &cbuf->deferred)
 421         {
 422                 current = List_Container(*pos, cmd_input_t, list);
 423                 current->delay -= eat;
 424                 if(current->delay <= 0)
 425                 {
 426                         cbuf->size += current->length;
 427                         List_Move(pos, &cbuf->start);
 428                         // We must return and come back next frame or the engine will freeze. Fragile... like glass :3
 429                         return;
 430                 }
 431         }
 432 }
 433
 434 /*
 435 ============
 436 Cbuf_Execute
 437 ============
 438 */
 439 static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias );
 440 void Cbuf_Execute (cmd_buf_t *cbuf)
 441 {
 442         cmd_input_t *current;
 443         char preprocessed[MAX_INPUTLINE];
 444         char *firstchar;
 445
 446         // LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
 447         cbuf->tokenizebufferpos = 0;
 448
 449         while (!List_IsEmpty(&cbuf->start))
 450         {
 451                 /*
 452                  * Delete the text from the command buffer and move remaining
 453                  * commands down. This is necessary because commands (exec, alias)
 454                  * can insert data at the beginning of the text buffer
 455                  */
 456                 current = List_Container(*cbuf->start.next, cmd_input_t, list);
 457
 458                 // Recycle memory so using WASD doesn't cause a malloc and free
 459                 List_Move_Tail(&current->list, &cbuf->free);
 460
 461                 /*
 462                  * Assume we're rolling with the current command-line and
 463                  * always set this false because alias expansion or cbuf insertion
 464                  * without a newline may set this true, and cause weirdness.
 465                  */
 466                 current->pending = false;
 467
 468                 cbuf->size -= current->length;
 469
 470                 firstchar = current->text;
 471                 while(*firstchar && ISWHITESPACE(*firstchar))
 472                         ++firstchar;
 473                 if((strncmp(firstchar, "alias", 5)   || !ISWHITESPACE(firstchar[5])) &&
 474                    (strncmp(firstchar, "bind", 4)    || !ISWHITESPACE(firstchar[4])) &&
 475                    (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7])))
 476                 {
 477                         if(Cmd_PreprocessString(current->source, current->text, preprocessed, sizeof(preprocessed), NULL ))
 478                                 Cmd_ExecuteString(current->source, preprocessed, src_local, false);
 479                 }
 480                 else
 481                 {
 482                         Cmd_ExecuteString (current->source, current->text, src_local, false);
 483                 }
 484
 485                 current = NULL;
 486
 487                 if (cbuf->wait)
 488                 {
 489                         /*
 490                          * Skip out while text still remains in
 491                          * buffer, leaving it for next frame
 492                          */
 493                         cbuf->wait = false;
 494                         break;
 495                 }
 496         }
 497 }
 498
 499 void Cbuf_Frame(cmd_buf_t *cbuf)
 500 {
 501         Cbuf_Execute_Deferred(cbuf);
 502         if (cbuf->size)
 503         {
 504                 SV_LockThreadMutex();
 505                 Cbuf_Execute(cbuf);
 506                 SV_UnlockThreadMutex();
 507         }
 508 }
 509
 510 /*
 511 ==============================================================================
 512
 513                                                 SCRIPT COMMANDS
 514
 515 ==============================================================================
 516 */
 517
 518 /*
 519 ===============
 520 Cmd_StuffCmds_f
 521
 522 Adds command line parameters as script statements
 523 Commands lead with a +, and continue until a - or another +
 524 quake +prog jctest.qp +cmd amlev1
 525 quake -nosound +cmd amlev1
 526 ===============
 527 */
 528 static void Cmd_StuffCmds_f (cmd_state_t *cmd)
 529 {
 530         int             i, j, l;
 531         // this is for all commandline options combined (and is bounds checked)
 532         char    build[MAX_INPUTLINE];
 533
 534         if (Cmd_Argc (cmd) != 1)
 535         {
 536                 Con_Print("stuffcmds : execute command line parameters\n");
 537                 return;
 538         }
 539
 540         // no reason to run the commandline arguments twice
 541         if (host_stuffcmdsrun)
 542                 return;
 543
 544         host_stuffcmdsrun = true;
 545         build[0] = 0;
 546         l = 0;
 547         for (i = 0;i < sys.argc;i++)
 548         {
 549                 if (sys.argv[i] && sys.argv[i][0] == '+' && (sys.argv[i][1] < '0' || sys.argv[i][1] > '9') && l + strlen(sys.argv[i]) - 1 <= sizeof(build) - 1)
 550                 {
 551                         j = 1;
 552                         while (sys.argv[i][j])
 553                                 build[l++] = sys.argv[i][j++];
 554                         i++;
 555                         for (;i < sys.argc;i++)
 556                         {
 557                                 if (!sys.argv[i])
 558                                         continue;
 559                                 if ((sys.argv[i][0] == '+' || sys.argv[i][0] == '-') && (sys.argv[i][1] < '0' || sys.argv[i][1] > '9'))
 560                                         break;
 561                                 if (l + strlen(sys.argv[i]) + 4 > sizeof(build) - 1)
 562                                         break;
 563                                 build[l++] = ' ';
 564                                 if (strchr(sys.argv[i], ' '))
 565                                         build[l++] = '\"';
 566                                 for (j = 0;sys.argv[i][j];j++)
 567                                         build[l++] = sys.argv[i][j];
 568                                 if (strchr(sys.argv[i], ' '))
 569                                         build[l++] = '\"';
 570                         }
 571                         build[l++] = '\n';
 572                         i--;
 573                 }
 574         }
 575         // now terminate the combined string and prepend it to the command buffer
 576         // we already reserved space for the terminator
 577         build[l++] = 0;
 578         Cbuf_InsertText (cmd, build);
 579 }
 580
 581 static void Cmd_Exec(cmd_state_t *cmd, const char *filename)
 582 {
 583         char *f;
 584         size_t filenameLen = strlen(filename);
 585         qbool isdefaultcfg =
 586                 !strcmp(filename, "default.cfg") ||
 587                 (filenameLen >= 12 && !strcmp(filename + filenameLen - 12, "/default.cfg"));
 588
 589         if (!strcmp(filename, "config.cfg"))
 590         {
 591                 filename = CONFIGFILENAME;
 592                 if (Sys_CheckParm("-noconfig"))
 593                         return; // don't execute config.cfg
 594         }
 595
 596         f = (char *)FS_LoadFile (filename, tempmempool, false, NULL);
 597         if (!f)
 598         {
 599                 Con_Printf("couldn't exec %s\n",filename);
 600                 return;
 601         }
 602         Con_Printf("execing %s\n",filename);
 603
 604         // if executing default.cfg for the first time, lock the cvar defaults
 605         // it may seem backwards to insert this text BEFORE the default.cfg
 606         // but Cbuf_InsertText inserts before, so this actually ends up after it.
 607         if (isdefaultcfg)
 608                 Cbuf_InsertText(cmd, "\ncvar_lockdefaults\n");
 609
 610         Cbuf_InsertText (cmd, f);
 611         Mem_Free(f);
 612
 613         if (isdefaultcfg)
 614         {
 615                 // special defaults for specific games go here, these execute before default.cfg
 616                 // Nehahra pushable crates malfunction in some levels if this is on
 617                 // Nehahra NPC AI is confused by blowupfallenzombies
 618                 switch(gamemode)
 619                 {
 620                 case GAME_NORMAL:
 621                         Cbuf_InsertText(cmd, "\n"
 622 "sv_gameplayfix_blowupfallenzombies 0\n"
 623 "sv_gameplayfix_findradiusdistancetobox 0\n"
 624 "sv_gameplayfix_grenadebouncedownslopes 0\n"
 625 "sv_gameplayfix_slidemoveprojectiles 0\n"
 626 "sv_gameplayfix_upwardvelocityclearsongroundflag 0\n"
 627 "sv_gameplayfix_setmodelrealbox 0\n"
 628 "sv_gameplayfix_droptofloorstartsolid 0\n"
 629 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n"
 630 "sv_gameplayfix_noairborncorpse 0\n"
 631 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n"
 632 "sv_gameplayfix_easierwaterjump 0\n"
 633 "sv_gameplayfix_delayprojectiles 0\n"
 634 "sv_gameplayfix_multiplethinksperframe 0\n"
 635 "sv_gameplayfix_fixedcheckwatertransition 0\n"
 636 "sv_gameplayfix_q1bsptracelinereportstexture 0\n"
 637 "sv_gameplayfix_swiminbmodels 0\n"
 638 "sv_gameplayfix_downtracesupportsongroundflag 0\n"
 639 "sys_ticrate 0.01388889\n"
 640 "r_shadow_gloss 1\n"
 641 "r_shadow_bumpscale_basetexture 0\n"
 642 "csqc_polygons_defaultmaterial_nocullface 0\n"
 643                                 );
 644                         break;
 645                 case GAME_NEHAHRA:
 646                         Cbuf_InsertText(cmd, "\n"
 647 "sv_gameplayfix_blowupfallenzombies 0\n"
 648 "sv_gameplayfix_findradiusdistancetobox 0\n"
 649 "sv_gameplayfix_grenadebouncedownslopes 0\n"
 650 "sv_gameplayfix_slidemoveprojectiles 0\n"
 651 "sv_gameplayfix_upwardvelocityclearsongroundflag 0\n"
 652 "sv_gameplayfix_setmodelrealbox 0\n"
 653 "sv_gameplayfix_droptofloorstartsolid 0\n"
 654 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n"
 655 "sv_gameplayfix_noairborncorpse 0\n"
 656 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n"
 657 "sv_gameplayfix_easierwaterjump 0\n"
 658 "sv_gameplayfix_delayprojectiles 0\n"
 659 "sv_gameplayfix_multiplethinksperframe 0\n"
 660 "sv_gameplayfix_fixedcheckwatertransition 0\n"
 661 "sv_gameplayfix_q1bsptracelinereportstexture 0\n"
 662 "sv_gameplayfix_swiminbmodels 0\n"
 663 "sv_gameplayfix_downtracesupportsongroundflag 0\n"
 664 "sys_ticrate 0.01388889\n"
 665 "r_shadow_gloss 1\n"
 666 "r_shadow_bumpscale_basetexture 0\n"
 667 "csqc_polygons_defaultmaterial_nocullface 0\n"
 668                                 );
 669                         break;
 670                 // hipnotic mission pack has issues in their 'friendly monster' ai, which seem to attempt to attack themselves for some reason when findradius() returns non-solid entities.
 671                 // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue
 672                 // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off.
 673                 case GAME_HIPNOTIC:
 674                 case GAME_QUOTH:
 675                         Cbuf_InsertText(cmd, "\n"
 676 "sv_gameplayfix_blowupfallenzombies 0\n"
 677 "sv_gameplayfix_findradiusdistancetobox 0\n"
 678 "sv_gameplayfix_grenadebouncedownslopes 0\n"
 679 "sv_gameplayfix_slidemoveprojectiles 0\n"
 680 "sv_gameplayfix_upwardvelocityclearsongroundflag 0\n"
 681 "sv_gameplayfix_setmodelrealbox 0\n"
 682 "sv_gameplayfix_droptofloorstartsolid 0\n"
 683 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n"
 684 "sv_gameplayfix_noairborncorpse 0\n"
 685 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n"
 686 "sv_gameplayfix_easierwaterjump 0\n"
 687 "sv_gameplayfix_delayprojectiles 0\n"
 688 "sv_gameplayfix_multiplethinksperframe 0\n"
 689 "sv_gameplayfix_fixedcheckwatertransition 0\n"
 690 "sv_gameplayfix_q1bsptracelinereportstexture 0\n"
 691 "sv_gameplayfix_swiminbmodels 0\n"
 692 "sv_gameplayfix_downtracesupportsongroundflag 0\n"
 693 "sys_ticrate 0.02\n"
 694 "r_shadow_gloss 1\n"
 695 "r_shadow_bumpscale_basetexture 0\n"
 696 "csqc_polygons_defaultmaterial_nocullface 0\n"
 697                                 );
 698                         break;
 699                 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
 700                 case GAME_ROGUE:
 701                         Cbuf_InsertText(cmd, "\n"
 702 "sv_gameplayfix_blowupfallenzombies 0\n"
 703 "sv_gameplayfix_findradiusdistancetobox 0\n"
 704 "sv_gameplayfix_grenadebouncedownslopes 0\n"
 705 "sv_gameplayfix_slidemoveprojectiles 0\n"
 706 "sv_gameplayfix_upwardvelocityclearsongroundflag 0\n"
 707 "sv_gameplayfix_setmodelrealbox 0\n"
 708 "sv_gameplayfix_droptofloorstartsolid 0\n"
 709 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n"
 710 "sv_gameplayfix_noairborncorpse 0\n"
 711 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n"
 712 "sv_gameplayfix_easierwaterjump 0\n"
 713 "sv_gameplayfix_delayprojectiles 0\n"
 714 "sv_gameplayfix_multiplethinksperframe 0\n"
 715 "sv_gameplayfix_fixedcheckwatertransition 0\n"
 716 "sv_gameplayfix_q1bsptracelinereportstexture 0\n"
 717 "sv_gameplayfix_swiminbmodels 0\n"
 718 "sv_gameplayfix_downtracesupportsongroundflag 0\n"
 719 "sys_ticrate 0.01388889\n"
 720 "r_shadow_gloss 1\n"
 721 "r_shadow_bumpscale_basetexture 0\n"
 722 "csqc_polygons_defaultmaterial_nocullface 0\n"
 723                                 );
 724                         break;
 725                 case GAME_TENEBRAE:
 726                         Cbuf_InsertText(cmd, "\n"
 727 "sv_gameplayfix_blowupfallenzombies 0\n"
 728 "sv_gameplayfix_findradiusdistancetobox 0\n"
 729 "sv_gameplayfix_grenadebouncedownslopes 0\n"
 730 "sv_gameplayfix_slidemoveprojectiles 0\n"
 731 "sv_gameplayfix_upwardvelocityclearsongroundflag 0\n"
 732 "sv_gameplayfix_setmodelrealbox 0\n"
 733 "sv_gameplayfix_droptofloorstartsolid 0\n"
 734 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n"
 735 "sv_gameplayfix_noairborncorpse 0\n"
 736 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n"
 737 "sv_gameplayfix_easierwaterjump 0\n"
 738 "sv_gameplayfix_delayprojectiles 0\n"
 739 "sv_gameplayfix_multiplethinksperframe 0\n"
 740 "sv_gameplayfix_fixedcheckwatertransition 0\n"
 741 "sv_gameplayfix_q1bsptracelinereportstexture 0\n"
 742 "sv_gameplayfix_swiminbmodels 0\n"
 743 "sv_gameplayfix_downtracesupportsongroundflag 0\n"
 744 "sys_ticrate 0.01388889\n"
 745 "r_shadow_gloss 2\n"
 746 "r_shadow_bumpscale_basetexture 4\n"
 747 "csqc_polygons_defaultmaterial_nocullface 0\n"
 748                                 );
 749                         break;
 750                 case GAME_NEXUIZ:
 751                         Cbuf_InsertText(cmd, "\n"
 752 "sv_gameplayfix_blowupfallenzombies 1\n"
 753 "sv_gameplayfix_findradiusdistancetobox 1\n"
 754 "sv_gameplayfix_grenadebouncedownslopes 1\n"
 755 "sv_gameplayfix_slidemoveprojectiles 1\n"
 756 "sv_gameplayfix_upwardvelocityclearsongroundflag 1\n"
 757 "sv_gameplayfix_setmodelrealbox 1\n"
 758 "sv_gameplayfix_droptofloorstartsolid 1\n"
 759 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n"
 760 "sv_gameplayfix_noairborncorpse 1\n"
 761 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n"
 762 "sv_gameplayfix_easierwaterjump 1\n"
 763 "sv_gameplayfix_delayprojectiles 1\n"
 764 "sv_gameplayfix_multiplethinksperframe 1\n"
 765 "sv_gameplayfix_fixedcheckwatertransition 1\n"
 766 "sv_gameplayfix_q1bsptracelinereportstexture 1\n"
 767 "sv_gameplayfix_swiminbmodels 1\n"
 768 "sv_gameplayfix_downtracesupportsongroundflag 1\n"
 769 "sys_ticrate 0.01388889\n"
 770 "sv_gameplayfix_q2airaccelerate 1\n"
 771 "sv_gameplayfix_stepmultipletimes 1\n"
 772 "csqc_polygons_defaultmaterial_nocullface 1\n"
 773 "con_chatsound_team_mask 13\n"
 774                                 );
 775                         break;
 776                 case GAME_XONOTIC:
 777                 case GAME_VORETOURNAMENT:
 778                         // compatibility for versions prior to 2020-05-25, this can be overridden in newer versions to get the default behavior and be consistent with FTEQW engine
 779                         Cbuf_InsertText(cmd, "\n"
 780 "csqc_polygons_defaultmaterial_nocullface 1\n"
 781 "con_chatsound_team_mask 13\n"
 782 "sv_gameplayfix_customstats 1\n"
 783                                 );
 784                         break;
 785                 // Steel Storm: Burning Retribution csqc misinterprets CSQC_InputEvent if type is a value other than 0 or 1
 786                 case GAME_STEELSTORM:
 787                         Cbuf_InsertText(cmd, "\n"
 788 "sv_gameplayfix_blowupfallenzombies 1\n"
 789 "sv_gameplayfix_findradiusdistancetobox 1\n"
 790 "sv_gameplayfix_grenadebouncedownslopes 1\n"
 791 "sv_gameplayfix_slidemoveprojectiles 1\n"
 792 "sv_gameplayfix_upwardvelocityclearsongroundflag 1\n"
 793 "sv_gameplayfix_setmodelrealbox 1\n"
 794 "sv_gameplayfix_droptofloorstartsolid 1\n"
 795 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n"
 796 "sv_gameplayfix_noairborncorpse 1\n"
 797 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n"
 798 "sv_gameplayfix_easierwaterjump 1\n"
 799 "sv_gameplayfix_delayprojectiles 1\n"
 800 "sv_gameplayfix_multiplethinksperframe 1\n"
 801 "sv_gameplayfix_fixedcheckwatertransition 1\n"
 802 "sv_gameplayfix_q1bsptracelinereportstexture 1\n"
 803 "sv_gameplayfix_swiminbmodels 1\n"
 804 "sv_gameplayfix_downtracesupportsongroundflag 1\n"
 805 "sys_ticrate 0.01388889\n"
 806 "cl_csqc_generatemousemoveevents 0\n"
 807 "csqc_polygons_defaultmaterial_nocullface 1\n"
 808                                 );
 809                         break;
 810                 default:
 811                         Cbuf_InsertText(cmd, "\n"
 812 "sv_gameplayfix_blowupfallenzombies 1\n"
 813 "sv_gameplayfix_findradiusdistancetobox 1\n"
 814 "sv_gameplayfix_grenadebouncedownslopes 1\n"
 815 "sv_gameplayfix_slidemoveprojectiles 1\n"
 816 "sv_gameplayfix_upwardvelocityclearsongroundflag 1\n"
 817 "sv_gameplayfix_setmodelrealbox 1\n"
 818 "sv_gameplayfix_droptofloorstartsolid 1\n"
 819 "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n"
 820 "sv_gameplayfix_noairborncorpse 1\n"
 821 "sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n"
 822 "sv_gameplayfix_easierwaterjump 1\n"
 823 "sv_gameplayfix_delayprojectiles 1\n"
 824 "sv_gameplayfix_multiplethinksperframe 1\n"
 825 "sv_gameplayfix_fixedcheckwatertransition 1\n"
 826 "sv_gameplayfix_q1bsptracelinereportstexture 1\n"
 827 "sv_gameplayfix_swiminbmodels 1\n"
 828 "sv_gameplayfix_downtracesupportsongroundflag 1\n"
 829 "sys_ticrate 0.01388889\n"
 830 "csqc_polygons_defaultmaterial_nocullface 0\n"
 831                                 );
 832                         break;
 833                 }
 834         }
 835 }
 836
 837 /*
 838 ===============
 839 Cmd_Exec_f
 840 ===============
 841 */
 842 static void Cmd_Exec_f (cmd_state_t *cmd)
 843 {
 844         fssearch_t *s;
 845         int i;
 846
 847         if (Cmd_Argc(cmd) != 2)
 848         {
 849                 Con_Print("exec <filename> : execute a script file\n");
 850                 return;
 851         }
 852
 853         s = FS_Search(Cmd_Argv(cmd, 1), true, true, NULL);
 854         if(!s || !s->numfilenames)
 855         {
 856                 Con_Printf("couldn't exec %s\n",Cmd_Argv(cmd, 1));
 857                 return;
 858         }
 859
 860         for(i = 0; i < s->numfilenames; ++i)
 861                 Cmd_Exec(cmd, s->filenames[i]);
 862
 863         FS_FreeSearch(s);
 864 }
 865
 866
 867 /*
 868 ===============
 869 Cmd_Echo_f
 870
 871 Just prints the rest of the line to the console
 872 ===============
 873 */
 874 static void Cmd_Echo_f (cmd_state_t *cmd)
 875 {
 876         int             i;
 877
 878         for (i=1 ; i<Cmd_Argc(cmd) ; i++)
 879                 Con_Printf("%s ",Cmd_Argv(cmd, i));
 880         Con_Print("\n");
 881 }
 882
 883 // DRESK - 5/14/06
 884 // Support Doom3-style Toggle Console Command
 885 /*
 886 ===============
 887 Cmd_Toggle_f
 888
 889 Toggles a specified console variable amongst the values specified (default is 0 and 1)
 890 ===============
 891 */
 892 static void Cmd_Toggle_f(cmd_state_t *cmd)
 893 {
 894         // Acquire Number of Arguments
 895         int nNumArgs = Cmd_Argc(cmd);
 896
 897         if(nNumArgs == 1)
 898                 // No Arguments Specified; Print Usage
 899                 Con_Print("Toggle Console Variable - Usage\n  toggle <variable> - toggles between 0 and 1\n  toggle <variable> <value> - toggles between 0 and <value>\n  toggle <variable> [string 1] [string 2]...[string n] - cycles through all strings\n");
 900         else
 901         { // Correct Arguments Specified
 902                 // Acquire Potential CVar
 903                 cvar_t* cvCVar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask);
 904
 905                 if(cvCVar != NULL)
 906                 { // Valid CVar
 907                         if(nNumArgs == 2)
 908                         { // Default Usage
 909                                 if(cvCVar->integer)
 910                                         Cvar_SetValueQuick(cvCVar, 0);
 911                                 else
 912                                         Cvar_SetValueQuick(cvCVar, 1);
 913                         }
 914                         else
 915                         if(nNumArgs == 3)
 916                         { // 0 and Specified Usage
 917                                 if(cvCVar->integer == atoi(Cmd_Argv(cmd, 2) ) )
 918                                         // CVar is Specified Value; // Reset to 0
 919                                         Cvar_SetValueQuick(cvCVar, 0);
 920                                 else
 921                                 if(cvCVar->integer == 0)
 922                                         // CVar is 0; Specify Value
 923                                         Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) );
 924                                 else
 925                                         // CVar does not match; Reset to 0
 926                                         Cvar_SetValueQuick(cvCVar, 0);
 927                         }
 928                         else
 929                         { // Variable Values Specified
 930                                 int nCnt;
 931                                 int bFound = 0;
 932
 933                                 for(nCnt = 2; nCnt < nNumArgs; nCnt++)
 934                                 { // Cycle through Values
 935                                         if( strcmp(cvCVar->string, Cmd_Argv(cmd, nCnt) ) == 0)
 936                                         { // Current Value Located; Increment to Next
 937                                                 if( (nCnt + 1) == nNumArgs)
 938                                                         // Max Value Reached; Reset
 939                                                         Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) );
 940                                                 else
 941                                                         // Next Value
 942                                                         Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, nCnt + 1) );
 943
 944                                                 // End Loop
 945                                                 nCnt = nNumArgs;
 946                                                 // Assign Found
 947                                                 bFound = 1;
 948                                         }
 949                                 }
 950                                 if(!bFound)
 951                                         // Value not Found; Reset to Original
 952                                         Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) );
 953                         }
 954
 955                 }
 956                 else
 957                 { // Invalid CVar
 958                         Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(cmd, 1) );
 959                 }
 960         }
 961 }
 962
 963 /*
 964 ===============
 965 Cmd_Alias_f
 966
 967 Creates a new command that executes a command string (possibly ; seperated)
 968 ===============
 969 */
 970 static void Cmd_Alias_f (cmd_state_t *cmd)
 971 {
 972         cmd_alias_t     *a;
 973         char            line[MAX_INPUTLINE];
 974         int                     i, c;
 975         const char              *s;
 976         size_t          alloclen;
 977
 978         if (Cmd_Argc(cmd) == 1)
 979         {
 980                 Con_Print("Current alias commands:\n");
 981                 for (a = cmd->userdefined->alias ; a ; a=a->next)
 982                         Con_Printf("%s : %s", a->name, a->value);
 983                 return;
 984         }
 985
 986         s = Cmd_Argv(cmd, 1);
 987         if (strlen(s) >= MAX_ALIAS_NAME)
 988         {
 989                 Con_Print("Alias name is too long\n");
 990                 return;
 991         }
 992
 993         // if the alias already exists, reuse it
 994         for (a = cmd->userdefined->alias ; a ; a=a->next)
 995         {
 996                 if (!strcmp(s, a->name))
 997                 {
 998                         Z_Free (a->value);
 999                         break;
1000                 }
1001         }
1002
1003         if (!a)
1004         {
1005                 cmd_alias_t *prev, *current;
1006
1007                 a = (cmd_alias_t *)Z_Malloc (sizeof(cmd_alias_t));
1008                 strlcpy (a->name, s, sizeof (a->name));
1009                 // insert it at the right alphanumeric position
1010                 for( prev = NULL, current = cmd->userdefined->alias ; current && strcmp( current->name, a->name ) < 0 ; prev = current, current = current->next )
1011                         ;
1012                 if( prev ) {
1013                         prev->next = a;
1014                 } else {
1015                         cmd->userdefined->alias = a;
1016                 }
1017                 a->next = current;
1018         }
1019
1020
1021 // copy the rest of the command line
1022         line[0] = 0;            // start out with a null string
1023         c = Cmd_Argc(cmd);
1024         for (i=2 ; i < c ; i++)
1025         {
1026                 if (i != 2)
1027                         strlcat (line, " ", sizeof (line));
1028                 strlcat (line, Cmd_Argv(cmd, i), sizeof (line));
1029         }
1030         strlcat (line, "\n", sizeof (line));
1031
1032         alloclen = strlen (line) + 1;
1033         if(alloclen >= 2)
1034                 line[alloclen - 2] = '\n'; // to make sure a newline is appended even if too long
1035         a->value = (char *)Z_Malloc (alloclen);
1036         memcpy (a->value, line, alloclen);
1037 }
1038
1039 /*
1040 ===============
1041 Cmd_UnAlias_f
1042
1043 Remove existing aliases.
1044 ===============
1045 */
1046 static void Cmd_UnAlias_f (cmd_state_t *cmd)
1047 {
1048         cmd_alias_t     *a, *p;
1049         int i;
1050         const char *s;
1051
1052         if(Cmd_Argc(cmd) == 1)
1053         {
1054                 Con_Print("unalias: Usage: unalias alias1 [alias2 ...]\n");
1055                 return;
1056         }
1057
1058         for(i = 1; i < Cmd_Argc(cmd); ++i)
1059         {
1060                 s = Cmd_Argv(cmd, i);
1061                 p = NULL;
1062                 for(a = cmd->userdefined->alias; a; p = a, a = a->next)
1063                 {
1064                         if(!strcmp(s, a->name))
1065                         {
1066                                 if (a->initstate) // we can not remove init aliases
1067                                         continue;
1068                                 if(a == cmd->userdefined->alias)
1069                                         cmd->userdefined->alias = a->next;
1070                                 if(p)
1071                                         p->next = a->next;
1072                                 Z_Free(a->value);
1073                                 Z_Free(a);
1074                                 break;
1075                         }
1076                 }
1077                 if(!a)
1078                         Con_Printf("unalias: %s alias not found\n", s);
1079         }
1080 }
1081
1082 /*
1083 =============================================================================
1084
1085                                         COMMAND EXECUTION
1086
1087 =============================================================================
1088 */
1089
1090 static const char *Cmd_GetDirectCvarValue(cmd_state_t *cmd, const char *varname, cmd_alias_t *alias, qbool *is_multiple)
1091 {
1092         cvar_t *cvar;
1093         long argno;
1094         char *endptr;
1095         static char vabuf[1024]; // cmd_mutex
1096
1097         if(is_multiple)
1098                 *is_multiple = false;
1099
1100         if(!varname || !*varname)
1101                 return NULL;
1102
1103         if(alias)
1104         {
1105                 if(!strcmp(varname, "*"))
1106                 {
1107                         if(is_multiple)
1108                                 *is_multiple = true;
1109                         return Cmd_Args(cmd);
1110                 }
1111                 else if(!strcmp(varname, "#"))
1112                 {
1113                         return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc(cmd));
1114                 }
1115                 else if(varname[strlen(varname) - 1] == '-')
1116                 {
1117                         argno = strtol(varname, &endptr, 10);
1118                         if(endptr == varname + strlen(varname) - 1)
1119                         {
1120                                 // whole string is a number, apart from the -
1121                                 const char *p = Cmd_Args(cmd);
1122                                 for(; argno > 1; --argno)
1123                                         if(!COM_ParseToken_Console(&p))
1124                                                 break;
1125                                 if(p)
1126                                 {
1127                                         if(is_multiple)
1128                                                 *is_multiple = true;
1129
1130                                         // kill pre-argument whitespace
1131                                         for (;*p && ISWHITESPACE(*p);p++)
1132                                                 ;
1133
1134                                         return p;
1135                                 }
1136                         }
1137                 }
1138                 else
1139                 {
1140                         argno = strtol(varname, &endptr, 10);
1141                         if(*endptr == 0)
1142                         {
1143                                 // whole string is a number
1144                                 // NOTE: we already made sure we don't have an empty cvar name!
1145                                 if(argno >= 0 && argno < Cmd_Argc(cmd))
1146                                         return Cmd_Argv(cmd, argno);
1147                         }
1148                 }
1149         }
1150
1151         if((cvar = Cvar_FindVar(cmd->cvars, varname, cmd->cvars_flagsmask)) && !(cvar->flags & CF_PRIVATE))
1152                 return cvar->string;
1153
1154         return NULL;
1155 }
1156
1157 qbool Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qbool putquotes)
1158 {
1159         qbool quote_quot = !!strchr(quoteset, '"');
1160         qbool quote_backslash = !!strchr(quoteset, '\\');
1161         qbool quote_dollar = !!strchr(quoteset, '$');
1162
1163         if(putquotes)
1164         {
1165                 if(outlen <= 2)
1166                 {
1167                         *out++ = 0;
1168                         return false;
1169                 }
1170                 *out++ = '"'; --outlen;
1171                 --outlen;
1172         }
1173
1174         while(*in)
1175         {
1176                 if(*in == '"' && quote_quot)
1177                 {
1178                         if(outlen <= 2)
1179                                 goto fail;
1180                         *out++ = '\\'; --outlen;
1181                         *out++ = '"'; --outlen;
1182                 }
1183                 else if(*in == '\\' && quote_backslash)
1184                 {
1185                         if(outlen <= 2)
1186                                 goto fail;
1187                         *out++ = '\\'; --outlen;
1188                         *out++ = '\\'; --outlen;
1189                 }
1190                 else if(*in == '$' && quote_dollar)
1191                 {
1192                         if(outlen <= 2)
1193                                 goto fail;
1194                         *out++ = '$'; --outlen;
1195                         *out++ = '$'; --outlen;
1196                 }
1197                 else
1198                 {
1199                         if(outlen <= 1)
1200                                 goto fail;
1201                         *out++ = *in; --outlen;
1202                 }
1203                 ++in;
1204         }
1205         if(putquotes)
1206                 *out++ = '"';
1207         *out++ = 0;
1208         return true;
1209 fail:
1210         if(putquotes)
1211                 *out++ = '"';
1212         *out++ = 0;
1213         return false;
1214 }
1215
1216 static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t varlen, cmd_alias_t *alias)
1217 {
1218         static char varname[MAX_INPUTLINE]; // cmd_mutex
1219         static char varval[MAX_INPUTLINE]; // cmd_mutex
1220         const char *varstr = NULL;
1221         char *varfunc;
1222         qbool required = false;
1223         qbool optional = false;
1224         static char asis[] = "asis"; // just to suppress const char warnings
1225
1226         if(varlen >= MAX_INPUTLINE)
1227                 varlen = MAX_INPUTLINE - 1;
1228         memcpy(varname, var, varlen);
1229         varname[varlen] = 0;
1230         varfunc = strchr(varname, ' ');
1231
1232         if(varfunc)
1233         {
1234                 *varfunc = 0;
1235                 ++varfunc;
1236         }
1237
1238         if(*var == 0)
1239         {
1240                 // empty cvar name?
1241                 if(alias)
1242                         Con_Printf(CON_WARN "Warning: Could not expand $ in alias %s\n", alias->name);
1243                 else
1244                         Con_Printf(CON_WARN "Warning: Could not expand $\n");
1245                 return "$";
1246         }
1247
1248         if(varfunc)
1249         {
1250                 char *p;
1251                 // ? means optional
1252                 while((p = strchr(varfunc, '?')))
1253                 {
1254                         optional = true;
1255                         memmove(p, p+1, strlen(p)); // with final NUL
1256                 }
1257                 // ! means required
1258                 while((p = strchr(varfunc, '!')))
1259                 {
1260                         required = true;
1261                         memmove(p, p+1, strlen(p)); // with final NUL
1262                 }
1263                 // kill spaces
1264                 while((p = strchr(varfunc, ' ')))
1265                 {
1266                         memmove(p, p+1, strlen(p)); // with final NUL
1267                 }
1268                 // if no function is left, NULL it
1269                 if(!*varfunc)
1270                         varfunc = NULL;
1271         }
1272
1273         if(varname[0] == '$')
1274                 varstr = Cmd_GetDirectCvarValue(cmd, Cmd_GetDirectCvarValue(cmd, varname + 1, alias, NULL), alias, NULL);
1275         else
1276         {
1277                 qbool is_multiple = false;
1278                 // Exception: $* and $n- don't use the quoted form by default
1279                 varstr = Cmd_GetDirectCvarValue(cmd, varname, alias, &is_multiple);
1280                 if(is_multiple)
1281                         if(!varfunc)
1282                                 varfunc = asis;
1283         }
1284
1285         if(!varstr)
1286         {
1287                 if(required)
1288                 {
1289                         if(alias)
1290                                 Con_Printf(CON_ERROR "Error: Could not expand $%s in alias %s\n", varname, alias->name);
1291                         else
1292                                 Con_Printf(CON_ERROR "Error: Could not expand $%s\n", varname);
1293                         return NULL;
1294                 }
1295                 else if(optional)
1296                 {
1297                         return "";
1298                 }
1299                 else
1300                 {
1301                         if(alias)
1302                                 Con_Printf(CON_WARN "Warning: Could not expand $%s in alias %s\n", varname, alias->name);
1303                         else
1304                                 Con_Printf(CON_WARN "Warning: Could not expand $%s\n", varname);
1305                         dpsnprintf(varval, sizeof(varval), "$%s", varname);
1306                         return varval;
1307                 }
1308         }
1309
1310         if(!varfunc || !strcmp(varfunc, "q")) // note: quoted form is default, use "asis" to override!
1311         {
1312                 // quote it so it can be used inside double quotes
1313                 // we just need to replace " by \", and of course, double backslashes
1314                 Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\", false);
1315                 return varval;
1316         }
1317         else if(!strcmp(varfunc, "asis"))
1318         {
1319                 return varstr;
1320         }
1321         else
1322                 Con_Printf("Unknown variable function %s\n", varfunc);
1323
1324         return varstr;
1325 }
1326
1327 /*
1328 Cmd_PreprocessString
1329
1330 Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments.
1331 */
1332 static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ) {
1333         const char *in;
1334         size_t eat, varlen;
1335         unsigned outlen;
1336         const char *val;
1337
1338         // don't crash if there's no room in the outtext buffer
1339         if( maxoutlen == 0 ) {
1340                 return false;
1341         }
1342         maxoutlen--; // because of \0
1343
1344         in = intext;
1345         outlen = 0;
1346
1347         while( *in && outlen < maxoutlen ) {
1348                 if( *in == '$' ) {
1349                         // this is some kind of expansion, see what comes after the $
1350                         in++;
1351
1352                         // The console does the following preprocessing:
1353                         //
1354                         // - $$ is transformed to a single dollar sign.
1355                         // - $var or ${var} are expanded to the contents of the named cvar,
1356                         //   with quotation marks and backslashes quoted so it can safely
1357                         //   be used inside quotation marks (and it should always be used
1358                         //   that way)
1359                         // - ${var asis} inserts the cvar value as is, without doing this
1360                         //   quoting
1361                         // - ${var ?} silently expands to the empty string if
1362                         //   $var does not exist
1363                         // - ${var !} fails expansion and executes nothing if
1364                         //   $var does not exist
1365                         // - prefix the cvar name with a dollar sign to do indirection;
1366                         //   for example, if $x has the value timelimit, ${$x} will return
1367                         //   the value of $timelimit
1368                         // - when expanding an alias, the special variable name $* refers
1369                         //   to all alias parameters, and a number refers to that numbered
1370                         //   alias parameter, where the name of the alias is $0, the first
1371                         //   parameter is $1 and so on; as a special case, $* inserts all
1372                         //   parameters, without extra quoting, so one can use $* to just
1373                         //   pass all parameters around. All parameters starting from $n
1374                         //   can be referred to as $n- (so $* is equivalent to $1-).
1375                         // - ${* q} and ${n- q} force quoting anyway
1376                         //
1377                         // Note: when expanding an alias, cvar expansion is done in the SAME step
1378                         // as alias expansion so that alias parameters or cvar values containing
1379                         // dollar signs have no unwanted bad side effects. However, this needs to
1380                         // be accounted for when writing complex aliases. For example,
1381                         //   alias foo "set x NEW; echo $x"
1382                         // actually expands to
1383                         //   "set x NEW; echo OLD"
1384                         // and will print OLD! To work around this, use a second alias:
1385                         //   alias foo "set x NEW; foo2"
1386                         //   alias foo2 "echo $x"
1387                         //
1388                         // Also note: lines starting with alias are exempt from cvar expansion.
1389                         // If you want cvar expansion, write "alias" instead:
1390                         //
1391                         //   set x 1
1392                         //   alias foo "echo $x"
1393                         //   "alias" bar "echo $x"
1394                         //   set x 2
1395                         //
1396                         // foo will print 2, because the variable $x will be expanded when the alias
1397                         // gets expanded. bar will print 1, because the variable $x was expanded
1398                         // at definition time. foo can be equivalently defined as
1399                         //
1400                         //   "alias" foo "echo $$x"
1401                         //
1402                         // because at definition time, $$ will get replaced to a single $.
1403
1404                         if( *in == '$' ) {
1405                                 val = "$";
1406                                 eat = 1;
1407                         } else if(*in == '{') {
1408                                 varlen = strcspn(in + 1, "}");
1409                                 if(in[varlen + 1] == '}')
1410                                 {
1411                                         val = Cmd_GetCvarValue(cmd, in + 1, varlen, alias);
1412                                         if(!val)
1413                                                 return false;
1414                                         eat = varlen + 2;
1415                                 }
1416                                 else
1417                                 {
1418                                         // ran out of data?
1419                                         val = NULL;
1420                                         eat = varlen + 1;
1421                                 }
1422                         } else {
1423                                 varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-");
1424                                 val = Cmd_GetCvarValue(cmd, in, varlen, alias);
1425                                 if(!val)
1426                                         return false;
1427                                 eat = varlen;
1428                         }
1429                         if(val)
1430                         {
1431                                 // insert the cvar value
1432                                 while(*val && outlen < maxoutlen)
1433                                         outtext[outlen++] = *val++;
1434                                 in += eat;
1435                         }
1436                         else
1437                         {
1438                                 // copy the unexpanded text
1439                                 outtext[outlen++] = '$';
1440                                 while(eat && outlen < maxoutlen)
1441                                 {
1442                                         outtext[outlen++] = *in++;
1443                                         --eat;
1444                                 }
1445                         }
1446                 }
1447                 else
1448                         outtext[outlen++] = *in++;
1449         }
1450         outtext[outlen] = 0;
1451         return true;
1452 }
1453
1454 /*
1455 ============
1456 Cmd_ExecuteAlias
1457
1458 Called for aliases and fills in the alias into the cbuffer
1459 ============
1460 */
1461 static void Cmd_ExecuteAlias (cmd_state_t *cmd, cmd_alias_t *alias)
1462 {
1463         static char buffer[ MAX_INPUTLINE ]; // cmd_mutex
1464         static char buffer2[ MAX_INPUTLINE ]; // cmd_mutex
1465         qbool ret = Cmd_PreprocessString( cmd, alias->value, buffer, sizeof(buffer) - 2, alias );
1466         if(!ret)
1467                 return;
1468         // insert at start of command buffer, so that aliases execute in order
1469         // (fixes bug introduced by Black on 20050705)
1470
1471         // Note: Cbuf_PreprocessString will be called on this string AGAIN! So we
1472         // have to make sure that no second variable expansion takes place, otherwise
1473         // alias parameters containing dollar signs can have bad effects.
1474         Cmd_QuoteString(buffer2, sizeof(buffer2), buffer, "$", false);
1475         Cbuf_InsertText(cmd, buffer2);
1476 }
1477
1478 /*
1479 ========
1480 Cmd_List
1481
1482         CmdList Added by EvilTypeGuy eviltypeguy@qeradiant.com
1483         Thanks to Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
1484
1485 ========
1486 */
1487 static void Cmd_List_f (cmd_state_t *cmd)
1488 {
1489         cmd_function_t *func;
1490         const char *partial;
1491         size_t len;
1492         int count;
1493         qbool ispattern;
1494
1495         if (Cmd_Argc(cmd) > 1)
1496         {
1497                 partial = Cmd_Argv(cmd, 1);
1498                 len = strlen(partial);
1499                 ispattern = (strchr(partial, '*') || strchr(partial, '?'));
1500         }
1501         else
1502         {
1503                 partial = NULL;
1504                 len = 0;
1505                 ispattern = false;
1506         }
1507
1508         count = 0;
1509         for (func = cmd->userdefined->qc_functions; func; func = func->next)
1510         {
1511                 if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len)))
1512                         continue;
1513                 Con_Printf("%s : %s\n", func->name, func->description);
1514                 count++;
1515         }
1516         for (func = cmd->engine_functions; func; func = func->next)
1517         {
1518                 if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len)))
1519                         continue;
1520                 Con_Printf("%s : %s\n", func->name, func->description);
1521                 count++;
1522         }
1523
1524         if (len)
1525         {
1526                 if(ispattern)
1527                         Con_Printf("%i Command%s matching \"%s\"\n\n", count, (count > 1) ? "s" : "", partial);
1528                 else
1529                         Con_Printf("%i Command%s beginning with \"%s\"\n\n", count, (count > 1) ? "s" : "", partial);
1530         }
1531         else
1532                 Con_Printf("%i Command%s\n\n", count, (count > 1) ? "s" : "");
1533 }
1534
1535 static void Cmd_Apropos_f(cmd_state_t *cmd)
1536 {
1537         cmd_function_t *func;
1538         cvar_t *cvar;
1539         cmd_alias_t *alias;
1540         const char *partial;
1541         int count;
1542         qbool ispattern;
1543         char vabuf[1024];
1544
1545         if (Cmd_Argc(cmd) > 1)
1546                 partial = Cmd_Args(cmd);
1547         else
1548         {
1549                 Con_Printf("usage: %s <string>\n",Cmd_Argv(cmd, 0));
1550                 return;
1551         }
1552
1553         ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
1554         if(!ispattern)
1555                 partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
1556
1557         count = 0;
1558         for (cvar = cmd->cvars->vars; cvar; cvar = cvar->next)
1559         {
1560                 if (matchpattern_with_separator(cvar->name, partial, true, "", false) ||
1561                     matchpattern_with_separator(cvar->description, partial, true, "", false))
1562                 {
1563                         Con_Printf ("cvar ");
1564                         Cvar_PrintHelp(cvar, cvar->name, true);
1565                         count++;
1566                 }
1567                 for (int i = 0; i < cvar->aliasindex; i++)
1568                 {
1569                         if (matchpattern_with_separator(cvar->aliases[i], partial, true, "", false))
1570                         {
1571                                 Con_Printf ("cvar ");
1572                                 Cvar_PrintHelp(cvar, cvar->aliases[i], true);
1573                                 count++;
1574                         }
1575                 }
1576         }
1577         for (func = cmd->userdefined->qc_functions; func; func = func->next)
1578         {
1579                 if (!matchpattern_with_separator(func->name, partial, true, "", false))
1580                         if (!matchpattern_with_separator(func->description, partial, true, "", false))
1581                                 continue;
1582                 Con_Printf("command ^2%s^7: %s\n", func->name, func->description);
1583                 count++;
1584         }
1585         for (func = cmd->engine_functions; func; func = func->next)
1586         {
1587                 if (!matchpattern_with_separator(func->name, partial, true, "", false))
1588                 if (!matchpattern_with_separator(func->description, partial, true, "", false))
1589                         continue;
1590                 Con_Printf("command ^2%s^7: %s\n", func->name, func->description);
1591                 count++;
1592         }
1593         for (alias = cmd->userdefined->alias; alias; alias = alias->next)
1594         {
1595                 // procede here a bit differently as an alias value always got a final \n
1596                 if (!matchpattern_with_separator(alias->name, partial, true, "", false))
1597                 if (!matchpattern_with_separator(alias->value, partial, true, "\n", false)) // when \n is as separator wildcards don't match it
1598                         continue;
1599                 Con_Printf("alias ^5%s^7: %s", alias->name, alias->value); // do not print an extra \n
1600                 count++;
1601         }
1602         Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : "");
1603 }
1604
1605 /*
1606 ============
1607 Cmd_Init
1608 ============
1609 */
1610 void Cmd_Init(void)
1611 {
1612         cmd_iter_t *cmd_iter;
1613         cmd_buf_t *cbuf;
1614         cbuf_mempool = Mem_AllocPool("Command buffer", 0, NULL);
1615         cbuf = (cmd_buf_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_buf_t));
1616         cbuf->maxsize = 655360;
1617         cbuf->lock = Thread_CreateMutex();
1618         cbuf->wait = false;
1619         host.cbuf = cbuf;
1620
1621         cbuf->start.prev = cbuf->start.next = &(cbuf->start);
1622         cbuf->deferred.prev = cbuf->deferred.next = &(cbuf->deferred);
1623         cbuf->free.prev = cbuf->free.next = &(cbuf->free);
1624
1625         for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++)
1626         {
1627                 cmd_state_t *cmd = cmd_iter->cmd;
1628                 cmd->mempool = Mem_AllocPool("commands", 0, NULL);
1629                 // space for commands and script files
1630                 cmd->cbuf = cbuf;
1631                 cmd->null_string = "";
1632         }
1633         // client console can see server cvars because the user may start a server
1634         cmd_client.cvars = &cvars_all;
1635         cmd_client.cvars_flagsmask = CF_CLIENT | CF_SERVER;
1636         cmd_client.cmd_flags = CF_CLIENT | CF_CLIENT_FROM_SERVER;
1637         cmd_client.auto_flags = CF_SERVER_FROM_CLIENT;
1638         cmd_client.auto_function = CL_ForwardToServer_f; // FIXME: Move this to the client.
1639         cmd_client.userdefined = &cmd_userdefined_all;
1640         // dedicated server console can only see server cvars, there is no client
1641         cmd_server.cvars = &cvars_all;
1642         cmd_server.cvars_flagsmask = CF_SERVER;
1643         cmd_server.cmd_flags = CF_SERVER;
1644         cmd_server.auto_flags = 0;
1645         cmd_server.auto_function = NULL;
1646         cmd_server.userdefined = &cmd_userdefined_all;
1647         // server commands received from clients have no reason to access cvars, cvar expansion seems perilous.
1648         cmd_serverfromclient.cvars = &cvars_null;
1649         cmd_serverfromclient.cvars_flagsmask = 0;
1650         cmd_serverfromclient.cmd_flags = CF_SERVER_FROM_CLIENT | CF_USERINFO;
1651         cmd_serverfromclient.auto_flags = 0;
1652         cmd_serverfromclient.auto_function = NULL;
1653         cmd_serverfromclient.userdefined = &cmd_userdefined_null;
1654
1655 //
1656 // register our commands
1657 //
1658         // client-only commands
1659         Cmd_AddCommand(CF_SHARED, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame");
1660         Cmd_AddCommand(CF_CLIENT, "cprint", Cmd_Centerprint_f, "print something at the screen center");
1661
1662         // maintenance commands used for upkeep of cvars and saved configs
1663         Cmd_AddCommand(CF_SHARED, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)");
1664         Cmd_AddCommand(CF_SHARED, "cvar_lockdefaults", Cvar_LockDefaults_f, "stores the current values of all cvars into their default values, only used once during startup after parsing default.cfg");
1665         Cmd_AddCommand(CF_SHARED, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values");
1666         Cmd_AddCommand(CF_SHARED, "cvar_resettodefaults_nosaveonly", Cvar_ResetToDefaults_NoSaveOnly_f, "sets all non-saved cvars to their locked default values (variables that will not be saved to config.cfg)");
1667         Cmd_AddCommand(CF_SHARED, "cvar_resettodefaults_saveonly", Cvar_ResetToDefaults_SaveOnly_f, "sets all saved cvars to their locked default values (variables that will be saved to config.cfg)");
1668
1669         // general console commands used in multiple environments
1670         Cmd_AddCommand(CF_SHARED, "exec", Cmd_Exec_f, "execute a script file");
1671         Cmd_AddCommand(CF_SHARED, "echo",Cmd_Echo_f, "print a message to the console (useful in scripts)");
1672         Cmd_AddCommand(CF_SHARED, "alias",Cmd_Alias_f, "create a script function (parameters are passed in as $X (being X a number), $* for all parameters, $X- for all parameters starting from $X). Without arguments show the list of all alias");
1673         Cmd_AddCommand(CF_SHARED, "unalias",Cmd_UnAlias_f, "remove an alias");
1674         Cmd_AddCommand(CF_SHARED, "set", Cvar_Set_f, "create or change the value of a console variable");
1675         Cmd_AddCommand(CF_SHARED, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg");
1676         Cmd_AddCommand(CF_SHARED, "unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)");
1677
1678 #ifdef FILLALLCVARSWITHRUBBISH
1679         Cmd_AddCommand(CF_SHARED, "fillallcvarswithrubbish", Cvar_FillAll_f, "fill all cvars with a specified number of characters to provoke buffer overruns");
1680 #endif /* FILLALLCVARSWITHRUBBISH */
1681
1682         // 2000-01-09 CmdList, CvarList commands By Matthias "Maddes" Buecher
1683         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
1684         Cmd_AddCommand(CF_SHARED, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern");
1685         Cmd_AddCommand(CF_SHARED, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern");
1686         Cmd_AddCommand(CF_SHARED, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description");
1687         Cmd_AddCommand(CF_SHARED, "find", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description");
1688
1689         Cmd_AddCommand(CF_SHARED, "defer", Cmd_Defer_f, "execute a command in the future");
1690
1691         // DRESK - 5/14/06
1692         // Support Doom3-style Toggle Command
1693         Cmd_AddCommand(CF_SHARED | CF_CLIENT_FROM_SERVER, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)");
1694 }
1695
1696 /*
1697 ============
1698 Cmd_Shutdown
1699 ============
1700 */
1701 void Cmd_Shutdown(void)
1702 {
1703         cmd_iter_t *cmd_iter;
1704         for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++)
1705         {
1706                 cmd_state_t *cmd = cmd_iter->cmd;
1707
1708                 if (cmd->cbuf->lock)
1709                 {
1710                         // we usually have this locked when we get here from Host_Quit_f
1711                         Cbuf_Unlock(cmd->cbuf);
1712                 }
1713
1714                 Mem_FreePool(&cmd->mempool);
1715         }
1716 }
1717
1718 /*
1719 ============
1720 Cmd_Argc
1721 ============
1722 */
1723 int             Cmd_Argc (cmd_state_t *cmd)
1724 {
1725         return cmd->argc;
1726 }
1727
1728 /*
1729 ============
1730 Cmd_Argv
1731 ============
1732 */
1733 const char *Cmd_Argv(cmd_state_t *cmd, int arg)
1734 {
1735         if (arg >= cmd->argc )
1736                 return cmd->null_string;
1737         return cmd->argv[arg];
1738 }
1739
1740 /*
1741 ============
1742 Cmd_Args
1743 ============
1744 */
1745 const char *Cmd_Args (cmd_state_t *cmd)
1746 {
1747         return cmd->args;
1748 }
1749
1750 /*
1751 ============
1752 Cmd_TokenizeString
1753
1754 Parses the given string into command line tokens.
1755 ============
1756 */
1757 // AK: This function should only be called from ExcuteString because the current design is a bit of an hack
1758 static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text)
1759 {
1760         int l;
1761
1762         cmd->argc = 0;
1763         cmd->args = NULL;
1764
1765         while (1)
1766         {
1767                 // skip whitespace up to a /n
1768                 while (*text && ISWHITESPACE(*text) && *text != '\r' && *text != '\n')
1769                         text++;
1770
1771                 // line endings:
1772                 // UNIX: \n
1773                 // Mac: \r
1774                 // Windows: \r\n
1775                 if (*text == '\n' || *text == '\r')
1776                 {
1777                         // a newline separates commands in the buffer
1778                         if (*text == '\r' && text[1] == '\n')
1779                                 text++;
1780                         text++;
1781                         break;
1782                 }
1783
1784                 if (!*text)
1785                         return;
1786
1787                 if (cmd->argc == 1)
1788                         cmd->args = text;
1789
1790                 if (!COM_ParseToken_Console(&text))
1791                         return;
1792
1793                 if (cmd->argc < MAX_ARGS)
1794                 {
1795                         l = (int)strlen(com_token) + 1;
1796                         if (cmd->cbuf->tokenizebufferpos + l > CMD_TOKENIZELENGTH)
1797                         {
1798                                 Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguments\n", CMD_TOKENIZELENGTH);
1799                                 break;
1800                         }
1801                         memcpy (cmd->cbuf->tokenizebuffer + cmd->cbuf->tokenizebufferpos, com_token, l);
1802                         cmd->argv[cmd->argc] = cmd->cbuf->tokenizebuffer + cmd->cbuf->tokenizebufferpos;
1803                         cmd->cbuf->tokenizebufferpos += l;
1804                         cmd->argc++;
1805                 }
1806         }
1807 }
1808
1809
1810 /*
1811 ============
1812 Cmd_AddCommand
1813 ============
1814 */
1815 void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const char *description)
1816 {
1817         cmd_function_t *func;
1818         cmd_function_t *prev, *current;
1819         cmd_state_t *cmd;
1820         xcommand_t save = NULL;
1821         qbool auto_add = false;
1822         int i;
1823
1824         for (i = 0; i < 3; i++)
1825         {
1826                 cmd = cmd_iter_all[i].cmd;
1827                 if ((flags & cmd->cmd_flags) || (flags & cmd->auto_flags))
1828                 {
1829                         if((flags & cmd->auto_flags) && cmd->auto_function)
1830                         {
1831                                 save = function;
1832                                 function = cmd->auto_function;
1833                                 auto_add = true;
1834                         }
1835
1836                         // fail if the command is a variable name
1837                         if (Cvar_FindVar(cmd->cvars, cmd_name, ~0))
1838                         {
1839                                 Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
1840                                 return;
1841                         }
1842
1843                         if (function)
1844                         {
1845                                 // fail if the command already exists in this interpreter
1846                                 for (func = cmd->engine_functions; func; func = func->next)
1847                                 {
1848                                         if (!strcmp(cmd_name, func->name))
1849                                         {
1850                                                 if(func->autofunc && !auto_add)
1851                                                         break;
1852                                                 Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
1853                                                 goto next;
1854                                         }
1855                                 }
1856
1857                                 func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t));
1858                                 func->flags = flags;
1859                                 func->name = cmd_name;
1860                                 func->function = function;
1861                                 func->description = description;
1862                                 func->next = cmd->engine_functions;
1863                                 func->autofunc = auto_add;
1864
1865                                 // insert it at the right alphanumeric position
1866                                 for (prev = NULL, current = cmd->engine_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next)
1867                                         ;
1868                                 if (prev) {
1869                                         prev->next = func;
1870                                 }
1871                                 else {
1872                                         cmd->engine_functions = func;
1873                                 }
1874                                 func->next = current;
1875                         }
1876                         else
1877                         {
1878                                 // mark qcfunc if the function already exists in the qc_functions list
1879                                 for (func = cmd->userdefined->qc_functions; func; func = func->next)
1880                                 {
1881                                         if (!strcmp(cmd_name, func->name))
1882                                         {
1883                                                 func->qcfunc = true; //[515]: csqc
1884                                                 continue;
1885                                         }
1886                                 }
1887
1888
1889                                 func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t));
1890                                 func->flags = flags;
1891                                 func->name = cmd_name;
1892                                 func->function = function;
1893                                 func->description = description;
1894                                 func->qcfunc = true; //[515]: csqc
1895                                 func->next = cmd->userdefined->qc_functions;
1896                                 func->autofunc = false;
1897
1898                                 // insert it at the right alphanumeric position
1899                                 for (prev = NULL, current = cmd->userdefined->qc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next)
1900                                         ;
1901                                 if (prev) {
1902                                         prev->next = func;
1903                                 }
1904                                 else {
1905                                         cmd->userdefined->qc_functions = func;
1906                                 }
1907                                 func->next = current;
1908                         }
1909                         if (save)
1910                                 function = save;
1911                 }
1912 next:
1913                 auto_add = false;
1914                 continue;
1915         }
1916 }
1917
1918 /*
1919 ============
1920 Cmd_Exists
1921 ============
1922 */
1923 qbool Cmd_Exists (cmd_state_t *cmd, const char *cmd_name)
1924 {
1925         cmd_function_t  *func;
1926
1927         for (func = cmd->userdefined->qc_functions; func; func = func->next)
1928                 if (!strcmp(cmd_name, func->name))
1929                         return true;
1930
1931         for (func=cmd->engine_functions ; func ; func=func->next)
1932                 if (!strcmp (cmd_name,func->name))
1933                         return true;
1934
1935         return false;
1936 }
1937
1938
1939 /*
1940 ============
1941 Cmd_CompleteCommand
1942 ============
1943 */
1944 const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial)
1945 {
1946         cmd_function_t *func;
1947         size_t len;
1948
1949         len = strlen(partial);
1950
1951         if (!len)
1952                 return NULL;
1953
1954 // check functions
1955         for (func = cmd->userdefined->qc_functions; func; func = func->next)
1956                 if (!strncasecmp(partial, func->name, len))
1957                         return func->name;
1958
1959         for (func = cmd->engine_functions; func; func = func->next)
1960                 if (!strncasecmp(partial, func->name, len))
1961                         return func->name;
1962
1963         return NULL;
1964 }
1965
1966 /*
1967         Cmd_CompleteCountPossible
1968
1969         New function for tab-completion system
1970         Added by EvilTypeGuy
1971         Thanks to Fett erich@heintz.com
1972         Thanks to taniwha
1973
1974 */
1975 int Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial)
1976 {
1977         cmd_function_t *func;
1978         size_t len;
1979         int h;
1980
1981         h = 0;
1982         len = strlen(partial);
1983
1984         if (!len)
1985                 return 0;
1986
1987         // Loop through the command list and count all partial matches
1988         for (func = cmd->userdefined->qc_functions; func; func = func->next)
1989                 if (!strncasecmp(partial, func->name, len))
1990                         h++;
1991
1992         for (func = cmd->engine_functions; func; func = func->next)
1993                 if (!strncasecmp(partial, func->name, len))
1994                         h++;
1995
1996         return h;
1997 }
1998
1999 /*
2000         Cmd_CompleteBuildList
2001
2002         New function for tab-completion system
2003         Added by EvilTypeGuy
2004         Thanks to Fett erich@heintz.com
2005         Thanks to taniwha
2006
2007 */
2008 const char **Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial)
2009 {
2010         cmd_function_t *func;
2011         size_t len = 0;
2012         size_t bpos = 0;
2013         size_t sizeofbuf = (Cmd_CompleteCountPossible (cmd, partial) + 1) * sizeof (const char *);
2014         const char **buf;
2015
2016         len = strlen(partial);
2017         buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
2018         // Loop through the functions lists and print all matches
2019         for (func = cmd->userdefined->qc_functions; func; func = func->next)
2020                 if (!strncasecmp(partial, func->name, len))
2021                         buf[bpos++] = func->name;
2022         for (func = cmd->engine_functions; func; func = func->next)
2023                 if (!strncasecmp(partial, func->name, len))
2024                         buf[bpos++] = func->name;
2025
2026         buf[bpos] = NULL;
2027         return buf;
2028 }
2029
2030 // written by LadyHavoc
2031 void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial)
2032 {
2033         cmd_function_t *func;
2034         size_t len = strlen(partial);
2035         // Loop through the command list and print all matches
2036         for (func = cmd->userdefined->qc_functions; func; func = func->next)
2037                 if (!strncasecmp(partial, func->name, len))
2038                         Con_Printf("^2%s^7: %s\n", func->name, func->description);
2039         for (func = cmd->engine_functions; func; func = func->next)
2040                 if (!strncasecmp(partial, func->name, len))
2041                         Con_Printf("^2%s^7: %s\n", func->name, func->description);
2042 }
2043
2044 /*
2045         Cmd_CompleteAlias
2046
2047         New function for tab-completion system
2048         Added by EvilTypeGuy
2049         Thanks to Fett erich@heintz.com
2050         Thanks to taniwha
2051
2052 */
2053 const char *Cmd_CompleteAlias (cmd_state_t *cmd, const char *partial)
2054 {
2055         cmd_alias_t *alias;
2056         size_t len;
2057
2058         len = strlen(partial);
2059
2060         if (!len)
2061                 return NULL;
2062
2063         // Check functions
2064         for (alias = cmd->userdefined->alias; alias; alias = alias->next)
2065                 if (!strncasecmp(partial, alias->name, len))
2066                         return alias->name;
2067
2068         return NULL;
2069 }
2070
2071 // written by LadyHavoc
2072 void Cmd_CompleteAliasPrint (cmd_state_t *cmd, const char *partial)
2073 {
2074         cmd_alias_t *alias;
2075         size_t len = strlen(partial);
2076         // Loop through the alias list and print all matches
2077         for (alias = cmd->userdefined->alias; alias; alias = alias->next)
2078                 if (!strncasecmp(partial, alias->name, len))
2079                         Con_Printf("^5%s^7: %s", alias->name, alias->value);
2080 }
2081
2082
2083 /*
2084         Cmd_CompleteAliasCountPossible
2085
2086         New function for tab-completion system
2087         Added by EvilTypeGuy
2088         Thanks to Fett erich@heintz.com
2089         Thanks to taniwha
2090
2091 */
2092 int Cmd_CompleteAliasCountPossible (cmd_state_t *cmd, const char *partial)
2093 {
2094         cmd_alias_t     *alias;
2095         size_t          len;
2096         int                     h;
2097
2098         h = 0;
2099
2100         len = strlen(partial);
2101
2102         if (!len)
2103                 return 0;
2104
2105         // Loop through the command list and count all partial matches
2106         for (alias = cmd->userdefined->alias; alias; alias = alias->next)
2107                 if (!strncasecmp(partial, alias->name, len))
2108                         h++;
2109
2110         return h;
2111 }
2112
2113 /*
2114         Cmd_CompleteAliasBuildList
2115
2116         New function for tab-completion system
2117         Added by EvilTypeGuy
2118         Thanks to Fett erich@heintz.com
2119         Thanks to taniwha
2120
2121 */
2122 const char **Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial)
2123 {
2124         cmd_alias_t *alias;
2125         size_t len = 0;
2126         size_t bpos = 0;
2127         size_t sizeofbuf = (Cmd_CompleteAliasCountPossible (cmd, partial) + 1) * sizeof (const char *);
2128         const char **buf;
2129
2130         len = strlen(partial);
2131         buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
2132         // Loop through the alias list and print all matches
2133         for (alias = cmd->userdefined->alias; alias; alias = alias->next)
2134                 if (!strncasecmp(partial, alias->name, len))
2135                         buf[bpos++] = alias->name;
2136
2137         buf[bpos] = NULL;
2138         return buf;
2139 }
2140
2141 // TODO: Make this more generic?
2142 void Cmd_ClearCSQCCommands (cmd_state_t *cmd)
2143 {
2144         cmd_function_t *func;
2145         cmd_function_t **next = &cmd->userdefined->qc_functions;
2146
2147         while(*next)
2148         {
2149                 func = *next;
2150                 *next = func->next;
2151                 Z_Free(func);
2152         }
2153 }
2154
2155 extern cvar_t sv_cheats;
2156
2157 /*
2158 ============
2159 Cmd_ExecuteString
2160
2161 A complete command line has been parsed, so try to execute it
2162 FIXME: lookupnoadd the token to speed search?
2163 ============
2164 */
2165 void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qbool lockmutex)
2166 {
2167         int oldpos;
2168         cmd_function_t *func;
2169         cmd_alias_t *a;
2170         if (lockmutex)
2171                 Cbuf_Lock(cmd->cbuf);
2172         oldpos = cmd->cbuf->tokenizebufferpos;
2173         cmd->source = src;
2174
2175         Cmd_TokenizeString (cmd, text);
2176
2177 // execute the command line
2178         if (!Cmd_Argc(cmd))
2179                 goto done; // no tokens
2180
2181 // check functions
2182         for (func = cmd->userdefined->qc_functions; func; func = func->next)
2183         {
2184                 if (!strcasecmp(cmd->argv[0], func->name))
2185                 {
2186                         if(func->qcfunc)
2187                         {
2188                                 if((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text))
2189                                         goto done;
2190                                 else if((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text))
2191                                         goto done;
2192                         }
2193                 }
2194         }
2195
2196         for (func = cmd->engine_functions; func; func=func->next)
2197         {
2198                 if (!strcasecmp (cmd->argv[0], func->name))
2199                 {
2200                         switch (src)
2201                         {
2202                         case src_local:
2203                                 if (func->function)
2204                                         func->function(cmd);
2205                                 else
2206                                         Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0));
2207                                 goto done;
2208                         case src_client:
2209                                 if (func->function)
2210                                 {
2211                                         if((func->flags & CF_CHEAT) && !sv_cheats.integer)
2212                                                 SV_ClientPrintf("No cheats allowed. The server must have sv_cheats set to 1\n");
2213                                         else
2214                                                 func->function(cmd);
2215                                         goto done;
2216                                 }
2217                         }
2218                         break;
2219                 }
2220         }
2221
2222         // if it's a client command and no command was found, say so.
2223         if (cmd->source == src_client)
2224         {
2225                 Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text);
2226                 goto done;
2227         }
2228
2229 // check alias
2230         for (a=cmd->userdefined->alias ; a ; a=a->next)
2231         {
2232                 if (!strcasecmp (cmd->argv[0], a->name))
2233                 {
2234                         Cmd_ExecuteAlias(cmd, a);
2235                         goto done;
2236                 }
2237         }
2238
2239 // check cvars
2240         if (!Cvar_Command(cmd) && host.framecount > 0)
2241                 Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(cmd, 0));
2242 done:
2243         cmd->cbuf->tokenizebufferpos = oldpos;
2244         if (lockmutex)
2245                 Cbuf_Unlock(cmd->cbuf);
2246 }
2247
2248 /*
2249 ================
2250 Cmd_CheckParm
2251
2252 Returns the position (1 to argc-1) in the command's argument list
2253 where the given parameter apears, or 0 if not present
2254 ================
2255 */
2256
2257 int Cmd_CheckParm (cmd_state_t *cmd, const char *parm)
2258 {
2259         int i;
2260
2261         if (!parm)
2262         {
2263                 Con_Printf ("Cmd_CheckParm: NULL");
2264                 return 0;
2265         }
2266
2267         for (i = 1; i < Cmd_Argc (cmd); i++)
2268                 if (!strcasecmp (parm, Cmd_Argv(cmd, i)))
2269                         return i;
2270
2271         return 0;
2272 }
2273
2274
2275
2276 void Cmd_SaveInitState(void)
2277 {
2278         cmd_iter_t *cmd_iter;
2279         for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++)
2280         {
2281                 cmd_state_t *cmd = cmd_iter->cmd;
2282                 cmd_function_t *f;
2283                 cmd_alias_t *a;
2284                 for (f = cmd->userdefined->qc_functions; f; f = f->next)
2285                         f->initstate = true;
2286                 for (f = cmd->engine_functions; f; f = f->next)
2287                         f->initstate = true;
2288                 for (a = cmd->userdefined->alias; a; a = a->next)
2289                 {
2290                         a->initstate = true;
2291                         a->initialvalue = Mem_strdup(zonemempool, a->value);
2292                 }
2293         }
2294         Cvar_SaveInitState(&cvars_all);
2295 }
2296
2297 void Cmd_RestoreInitState(void)
2298 {
2299         cmd_iter_t *cmd_iter;
2300         for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++)
2301         {
2302                 cmd_state_t *cmd = cmd_iter->cmd;
2303                 cmd_function_t *f, **fp;
2304                 cmd_alias_t *a, **ap;
2305                 for (fp = &cmd->userdefined->qc_functions; (f = *fp);)
2306                 {
2307                         if (f->initstate)
2308                                 fp = &f->next;
2309                         else
2310                         {
2311                                 // destroy this command, it didn't exist at init
2312                                 Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name);
2313                                 *fp = f->next;
2314                                 Z_Free(f);
2315                         }
2316                 }
2317                 for (fp = &cmd->engine_functions; (f = *fp);)
2318                 {
2319                         if (f->initstate)
2320                                 fp = &f->next;
2321                         else
2322                         {
2323                                 // destroy this command, it didn't exist at init
2324                                 Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name);
2325                                 *fp = f->next;
2326                                 Z_Free(f);
2327                         }
2328                 }
2329                 for (ap = &cmd->userdefined->alias; (a = *ap);)
2330                 {
2331                         if (a->initstate)
2332                         {
2333                                 // restore this alias, it existed at init
2334                                 if (strcmp(a->value ? a->value : "", a->initialvalue ? a->initialvalue : ""))
2335                                 {
2336                                         Con_DPrintf("Cmd_RestoreInitState: Restoring alias %s\n", a->name);
2337                                         if (a->value)
2338                                                 Z_Free(a->value);
2339                                         a->value = Mem_strdup(zonemempool, a->initialvalue);
2340                                 }
2341                                 ap = &a->next;
2342                         }
2343                         else
2344                         {
2345                                 // free this alias, it didn't exist at init...
2346                                 Con_DPrintf("Cmd_RestoreInitState: Destroying alias %s\n", a->name);
2347                                 *ap = a->next;
2348                                 if (a->value)
2349                                         Z_Free(a->value);
2350                                 Z_Free(a);
2351                         }
2352                 }
2353         }
2354         Cvar_RestoreInitState(&cvars_all);
2355 }