![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / qcommon|
Return to cmd.c CVS log | Up to [Quake II] / quake2 / qcommon |
1.1 ! root 1: // cmd.c -- Quake script command processing module ! 2: #include "qcommon.h" ! 3: void Cmd_ForwardToServer (void); ! 4: #define MAX_ALIAS_NAME 32 ! 5: typedef struct cmdalias_s ! 6: { ! 7: struct cmdalias_s *next; ! 8: char name[MAX_ALIAS_NAME]; ! 9: char *value; ! 10: } cmdalias_t; ! 11: cmdalias_t *cmd_alias; ! 12: qboolean cmd_wait; ! 13: #define ALIAS_LOOP_COUNT 16 ! 14: int alias_count; // for detecting runaway loops ! 15: //============================================================================= ! 16: /* ! 17: ============ ! 18: Cmd_Wait_f ! 19: Causes execution of the remainder of the command buffer to be delayed until ! 20: next frame. This allows commands like: ! 21: bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2" ! 22: ============ ! 23: */ ! 24: void Cmd_Wait_f (void) ! 25: { ! 26: cmd_wait = true; ! 27: } ! 28: ! 29: /* ! 30: ============================================================================= ! 31: COMMAND BUFFER ! 32: ============================================================================= ! 33: */ ! 34: sizebuf_t cmd_text; ! 35: byte cmd_text_buf[8192]; ! 36: ! 37: byte defer_text_buf[8192]; ! 38: /* ! 39: ============ ! 40: Cbuf_Init ! 41: ============ ! 42: */ ! 43: void Cbuf_Init (void) ! 44: { ! 45: SZ_Init (&cmd_text, cmd_text_buf, sizeof(cmd_text_buf)); ! 46: } ! 47: ! 48: /* ! 49: ============ ! 50: Cbuf_AddText ! 51: Adds command text at the end of the buffer ! 52: ============ ! 53: */ ! 54: void Cbuf_AddText (char *text) ! 55: { ! 56: int l; ! 57: ! 58: l = strlen (text); ! 59: if (cmd_text.cursize + l >= cmd_text.maxsize) ! 60: { ! 61: Com_Printf ("Cbuf_AddText: overflow\n"); ! 62: return; ! 63: } ! 64: SZ_Write (&cmd_text, text, strlen (text)); ! 65: } ! 66: /* ! 67: ============ ! 68: Cbuf_InsertText ! 69: Adds command text immediately after the current command ! 70: Adds a \n to the text ! 71: FIXME: actually change the command buffer to do less copying ! 72: ============ ! 73: */ ! 74: void Cbuf_InsertText (char *text) ! 75: { ! 76: char *temp; ! 77: int templen; ! 78: // copy off any commands still remaining in the exec buffer ! 79: templen = cmd_text.cursize; ! 80: if (templen) ! 81: { ! 82: temp = Z_Malloc (templen); ! 83: memcpy (temp, cmd_text.data, templen); ! 84: SZ_Clear (&cmd_text); ! 85: } ! 86: else ! 87: temp = NULL; // shut up compiler ! 88: ! 89: // add the entire text of the file ! 90: Cbuf_AddText (text); ! 91: ! 92: // add the copied off data ! 93: if (templen) ! 94: { ! 95: SZ_Write (&cmd_text, temp, templen); ! 96: Z_Free (temp); ! 97: } ! 98: } ! 99: ! 100: /* ! 101: ============ ! 102: Cbuf_CopyToDefer ! 103: ============ ! 104: */ ! 105: void Cbuf_CopyToDefer (void) ! 106: { ! 107: memcpy(defer_text_buf, cmd_text_buf, cmd_text.cursize); ! 108: defer_text_buf[cmd_text.cursize] = 0; ! 109: cmd_text.cursize = 0; ! 110: } ! 111: ! 112: /* ! 113: ============ ! 114: Cbuf_InsertFromDefer ! 115: ============ ! 116: */ ! 117: void Cbuf_InsertFromDefer (void) ! 118: { ! 119: Cbuf_InsertText (defer_text_buf); ! 120: defer_text_buf[0] = 0; ! 121: } ! 122: ! 123: ! 124: /* ! 125: ============ ! 126: Cbuf_ExecuteText ! 127: ============ ! 128: */ ! 129: void Cbuf_ExecuteText (int exec_when, char *text) ! 130: { ! 131: switch (exec_when) ! 132: { ! 133: case EXEC_NOW: ! 134: Cmd_ExecuteString (text); ! 135: break; ! 136: case EXEC_INSERT: ! 137: Cbuf_InsertText (text); ! 138: break; ! 139: case EXEC_APPEND: ! 140: Cbuf_AddText (text); ! 141: break; ! 142: default: ! 143: Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when"); ! 144: } ! 145: } ! 146: /* ! 147: ============ ! 148: Cbuf_Execute ! 149: ============ ! 150: */ ! 151: void Cbuf_Execute (void) ! 152: { ! 153: int i; ! 154: char *text; ! 155: char line[1024]; ! 156: int quotes; ! 157: ! 158: alias_count = 0; // don't allow infinite alias loops ! 159: while (cmd_text.cursize) ! 160: { ! 161: // find a \n or ; line break ! 162: text = (char *)cmd_text.data; ! 163: quotes = 0; ! 164: for (i=0 ; i< cmd_text.cursize ; i++) ! 165: { ! 166: if (text[i] == '"') ! 167: quotes++; ! 168: if ( !(quotes&1) && text[i] == ';') ! 169: break; // don't break if inside a quoted string ! 170: if (text[i] == '\n') ! 171: break; ! 172: } ! 173: ! 174: ! 175: memcpy (line, text, i); ! 176: line[i] = 0; ! 177: ! 178: // delete the text from the command buffer and move remaining commands down ! 179: // this is necessary because commands (exec, alias) can insert data at the ! 180: // beginning of the text buffer ! 181: if (i == cmd_text.cursize) ! 182: cmd_text.cursize = 0; ! 183: else ! 184: { ! 185: i++; ! 186: cmd_text.cursize -= i; ! 187: memmove (text, text+i, cmd_text.cursize); ! 188: } ! 189: // execute the command line ! 190: Cmd_ExecuteString (line); ! 191: ! 192: if (cmd_wait) ! 193: { ! 194: // skip out while text still remains in buffer, leaving it ! 195: // for next frame ! 196: cmd_wait = false; ! 197: break; ! 198: } ! 199: } ! 200: } ! 201: /* ! 202: =============== ! 203: Cbuf_AddEarlyCommands ! 204: Adds command line parameters as script statements ! 205: Commands lead with a +, and continue until another + ! 206: Set commands are added early, so they are guaranteed to be set before ! 207: the client and server initialize for the first time. ! 208: Other commands are added late, after all initialization is complete. ! 209: =============== ! 210: */ ! 211: void Cbuf_AddEarlyCommands (qboolean clear) ! 212: { ! 213: int i; ! 214: char *s; ! 215: for (i=0 ; i<COM_Argc() ; i++) ! 216: { ! 217: s = COM_Argv(i); ! 218: if (strcmp (s, "+set")) ! 219: continue; ! 220: Cbuf_AddText (va("set %s %s\n", COM_Argv(i+1), COM_Argv(i+2))); ! 221: if (clear) ! 222: { ! 223: COM_ClearArgv(i); ! 224: COM_ClearArgv(i+1); ! 225: COM_ClearArgv(i+2); ! 226: } ! 227: i+=2; ! 228: } ! 229: } ! 230: /* ! 231: ================= ! 232: Cbuf_AddLateCommands ! 233: Adds command line parameters as script statements ! 234: Commands lead with a + and continue until another + or - ! 235: quake +vid_ref gl +map amlev1 ! 236: Returns true if any late commands were added, which ! 237: will keep the demoloop from immediately starting ! 238: ================= ! 239: */ ! 240: qboolean Cbuf_AddLateCommands (void) ! 241: { ! 242: int i, j; ! 243: int s; ! 244: char *text, *build, c; ! 245: int argc; ! 246: qboolean ret; ! 247: // build the combined string to parse from ! 248: s = 0; ! 249: argc = COM_Argc(); ! 250: for (i=1 ; i<argc ; i++) ! 251: { ! 252: s += strlen (COM_Argv(i)) + 1; ! 253: } ! 254: if (!s) ! 255: return false; ! 256: ! 257: text = Z_Malloc (s+1); ! 258: text[0] = 0; ! 259: for (i=1 ; i<argc ; i++) ! 260: { ! 261: strcat (text,COM_Argv(i)); ! 262: if (i != argc-1) ! 263: strcat (text, " "); ! 264: } ! 265: ! 266: // pull out the commands ! 267: build = Z_Malloc (s+1); ! 268: build[0] = 0; ! 269: ! 270: for (i=0 ; i<s-1 ; i++) ! 271: { ! 272: if (text[i] == '+') ! 273: { ! 274: i++; ! 275: for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++) ! 276: ; ! 277: c = text[j]; ! 278: text[j] = 0; ! 279: ! 280: strcat (build, text+i); ! 281: strcat (build, "\n"); ! 282: text[j] = c; ! 283: i = j-1; ! 284: } ! 285: } ! 286: ret = (build[0] != 0); ! 287: if (ret) ! 288: Cbuf_AddText (build); ! 289: ! 290: Z_Free (text); ! 291: Z_Free (build); ! 292: return ret; ! 293: } ! 294: /* ! 295: ============================================================================== ! 296: SCRIPT COMMANDS ! 297: ============================================================================== ! 298: */ ! 299: /* ! 300: =============== ! 301: Cmd_Exec_f ! 302: =============== ! 303: */ ! 304: void Cmd_Exec_f (void) ! 305: { ! 306: char *f, *f2; ! 307: int len; ! 308: if (Cmd_Argc () != 2) ! 309: { ! 310: Com_Printf ("exec <filename> : execute a script file\n"); ! 311: return; ! 312: } ! 313: len = FS_LoadFile (Cmd_Argv(1), (void **)&f); ! 314: if (!f) ! 315: { ! 316: Com_Printf ("couldn't exec %s\n",Cmd_Argv(1)); ! 317: return; ! 318: } ! 319: Com_Printf ("execing %s\n",Cmd_Argv(1)); ! 320: ! 321: // the file doesn't have a trailing 0, so we need to copy it off ! 322: f2 = Z_Malloc(len+1); ! 323: memcpy (f2, f, len); ! 324: f2[len] = 0; ! 325: Cbuf_InsertText (f2); ! 326: Z_Free (f2); ! 327: FS_FreeFile (f); ! 328: } ! 329: /* ! 330: =============== ! 331: Cmd_Echo_f ! 332: Just prints the rest of the line to the console ! 333: =============== ! 334: */ ! 335: void Cmd_Echo_f (void) ! 336: { ! 337: int i; ! 338: ! 339: for (i=1 ; i<Cmd_Argc() ; i++) ! 340: Com_Printf ("%s ",Cmd_Argv(i)); ! 341: Com_Printf ("\n"); ! 342: } ! 343: /* ! 344: =============== ! 345: Cmd_Alias_f ! 346: Creates a new command that executes a command string (possibly ; seperated) ! 347: =============== ! 348: */ ! 349: void Cmd_Alias_f (void) ! 350: { ! 351: cmdalias_t *a; ! 352: char cmd[1024]; ! 353: int i, c; ! 354: char *s; ! 355: if (Cmd_Argc() == 1) ! 356: { ! 357: Com_Printf ("Current alias commands:\n"); ! 358: for (a = cmd_alias ; a ; a=a->next) ! 359: Com_Printf ("%s : %s\n", a->name, a->value); ! 360: return; ! 361: } ! 362: s = Cmd_Argv(1); ! 363: if (strlen(s) >= MAX_ALIAS_NAME) ! 364: { ! 365: Com_Printf ("Alias name is too long\n"); ! 366: return; ! 367: } ! 368: // if the alias already exists, reuse it ! 369: for (a = cmd_alias ; a ; a=a->next) ! 370: { ! 371: if (!strcmp(s, a->name)) ! 372: { ! 373: Z_Free (a->value); ! 374: break; ! 375: } ! 376: } ! 377: if (!a) ! 378: { ! 379: a = Z_Malloc (sizeof(cmdalias_t)); ! 380: a->next = cmd_alias; ! 381: cmd_alias = a; ! 382: } ! 383: strcpy (a->name, s); ! 384: // copy the rest of the command line ! 385: cmd[0] = 0; // start out with a null string ! 386: c = Cmd_Argc(); ! 387: for (i=2 ; i< c ; i++) ! 388: { ! 389: strcat (cmd, Cmd_Argv(i)); ! 390: if (i != (c - 1)) ! 391: strcat (cmd, " "); ! 392: } ! 393: strcat (cmd, "\n"); ! 394: ! 395: a->value = CopyString (cmd); ! 396: } ! 397: /* ! 398: ============================================================================= ! 399: COMMAND EXECUTION ! 400: ============================================================================= ! 401: */ ! 402: typedef struct cmd_function_s ! 403: { ! 404: struct cmd_function_s *next; ! 405: char *name; ! 406: xcommand_t function; ! 407: } cmd_function_t; ! 408: static int cmd_argc; ! 409: static char *cmd_argv[MAX_STRING_TOKENS]; ! 410: static char *cmd_null_string = ""; ! 411: static char cmd_args[MAX_STRING_CHARS]; ! 412: static cmd_function_t *cmd_functions; // possible commands to execute ! 413: /* ! 414: ============ ! 415: Cmd_Argc ! 416: ============ ! 417: */ ! 418: int Cmd_Argc (void) ! 419: { ! 420: return cmd_argc; ! 421: } ! 422: /* ! 423: ============ ! 424: Cmd_Argv ! 425: ============ ! 426: */ ! 427: char *Cmd_Argv (int arg) ! 428: { ! 429: if ( (unsigned)arg >= cmd_argc ) ! 430: return cmd_null_string; ! 431: return cmd_argv[arg]; ! 432: } ! 433: /* ! 434: ============ ! 435: Cmd_Args ! 436: Returns a single string containing argv(1) to argv(argc()-1) ! 437: ============ ! 438: */ ! 439: char *Cmd_Args (void) ! 440: { ! 441: return cmd_args; ! 442: } ! 443: /* ! 444: ====================== ! 445: Cmd_MacroExpandString ! 446: ====================== ! 447: */ ! 448: char *Cmd_MacroExpandString (char *text) ! 449: { ! 450: int i, j, count, len; ! 451: qboolean inquote; ! 452: char *scan; ! 453: static char expanded[MAX_STRING_CHARS]; ! 454: char temporary[MAX_STRING_CHARS]; ! 455: char *token, *start; ! 456: ! 457: inquote = false; ! 458: scan = text; ! 459: ! 460: len = strlen (scan); ! 461: if (len >= MAX_STRING_CHARS) ! 462: { ! 463: Com_Printf ("Line exceeded %i chars, discarded.\n", MAX_STRING_CHARS); ! 464: return NULL; ! 465: } ! 466: ! 467: count = 0; ! 468: ! 469: for (i=0 ; i<len ; i++) ! 470: { ! 471: if (scan[i] == '"') ! 472: inquote ^= 1; ! 473: if (inquote) ! 474: continue; // don't expand inside quotes ! 475: if (scan[i] != '$') ! 476: continue; ! 477: // scan out the complete macro ! 478: start = scan+i+1; ! 479: token = COM_Parse (&start); ! 480: if (!start) ! 481: continue; ! 482: ! 483: token = Cvar_VariableString (token); ! 484: ! 485: j = strlen(token); ! 486: len += j; ! 487: if (len >= MAX_STRING_CHARS) ! 488: { ! 489: Com_Printf ("Expanded line exceeded %i chars, discarded.\n", MAX_STRING_CHARS); ! 490: return NULL; ! 491: } ! 492: ! 493: strncpy (temporary, scan, i); ! 494: strcpy (temporary+i, token); ! 495: strcpy (temporary+i+j, start); ! 496: ! 497: strcpy (expanded, temporary); ! 498: scan = expanded; ! 499: i--; ! 500: ! 501: if (++count == 100) ! 502: { ! 503: Com_Printf ("Macro expansion loop, discarded.\n"); ! 504: return NULL; ! 505: } ! 506: } ! 507: ! 508: if (inquote) ! 509: { ! 510: Com_Printf ("Line has unmatched quote, discarded.\n"); ! 511: return NULL; ! 512: } ! 513: ! 514: return scan; ! 515: } ! 516: ! 517: ! 518: /* ! 519: ============ ! 520: Cmd_TokenizeString ! 521: Parses the given string into command line tokens. ! 522: $Cvars will be expanded unless they are in a quoted token ! 523: ============ ! 524: */ ! 525: void Cmd_TokenizeString (char *text, qboolean macroExpand) ! 526: { ! 527: int i; ! 528: char *com_token; ! 529: // clear the args from the last string ! 530: for (i=0 ; i<cmd_argc ; i++) ! 531: Z_Free (cmd_argv[i]); ! 532: ! 533: cmd_argc = 0; ! 534: cmd_args[0] = 0; ! 535: ! 536: // macro expand the text ! 537: if (macroExpand) ! 538: text = Cmd_MacroExpandString (text); ! 539: if (!text) ! 540: return; ! 541: while (1) ! 542: { ! 543: // skip whitespace up to a /n ! 544: while (*text && *text <= ' ' && *text != '\n') ! 545: { ! 546: text++; ! 547: } ! 548: ! 549: if (*text == '\n') ! 550: { // a newline seperates commands in the buffer ! 551: text++; ! 552: break; ! 553: } ! 554: if (!*text) ! 555: return; ! 556: ! 557: // set cmd_args to everything after the first arg ! 558: if (cmd_argc == 1) ! 559: { ! 560: int l; ! 561: ! 562: strcpy (cmd_args, text); ! 563: ! 564: // strip off any trailing whitespace ! 565: l = strlen(cmd_args) - 1; ! 566: for ( ; l >= 0 ; l--) ! 567: if (cmd_args[l] <= ' ') ! 568: cmd_args[l] = 0; ! 569: else ! 570: break; ! 571: } ! 572: ! 573: com_token = COM_Parse (&text); ! 574: if (!text) ! 575: return; ! 576: if (cmd_argc < MAX_STRING_TOKENS) ! 577: { ! 578: cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1); ! 579: strcpy (cmd_argv[cmd_argc], com_token); ! 580: cmd_argc++; ! 581: } ! 582: } ! 583: ! 584: } ! 585: /* ! 586: ============ ! 587: Cmd_AddCommand ! 588: ============ ! 589: */ ! 590: void Cmd_AddCommand (char *cmd_name, xcommand_t function) ! 591: { ! 592: cmd_function_t *cmd; ! 593: ! 594: // fail if the command is a variable name ! 595: if (Cvar_VariableString(cmd_name)[0]) ! 596: { ! 597: Com_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name); ! 598: return; ! 599: } ! 600: ! 601: // fail if the command already exists ! 602: for (cmd=cmd_functions ; cmd ; cmd=cmd->next) ! 603: { ! 604: if (!strcmp (cmd_name, cmd->name)) ! 605: { ! 606: Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name); ! 607: return; ! 608: } ! 609: } ! 610: cmd = Z_Malloc (sizeof(cmd_function_t)); ! 611: cmd->name = cmd_name; ! 612: cmd->function = function; ! 613: cmd->next = cmd_functions; ! 614: cmd_functions = cmd; ! 615: } ! 616: /* ! 617: ============ ! 618: Cmd_RemoveCommand ! 619: ============ ! 620: */ ! 621: void Cmd_RemoveCommand (char *cmd_name) ! 622: { ! 623: cmd_function_t *cmd, **back; ! 624: back = &cmd_functions; ! 625: while (1) ! 626: { ! 627: cmd = *back; ! 628: if (!cmd) ! 629: { ! 630: Com_Printf ("Cmd_RemoveCommand: %s not added\n", cmd_name); ! 631: return; ! 632: } ! 633: if (!strcmp (cmd_name, cmd->name)) ! 634: { ! 635: *back = cmd->next; ! 636: Z_Free (cmd); ! 637: return; ! 638: } ! 639: back = &cmd->next; ! 640: } ! 641: } ! 642: /* ! 643: ============ ! 644: Cmd_Exists ! 645: ============ ! 646: */ ! 647: qboolean Cmd_Exists (char *cmd_name) ! 648: { ! 649: cmd_function_t *cmd; ! 650: for (cmd=cmd_functions ; cmd ; cmd=cmd->next) ! 651: { ! 652: if (!strcmp (cmd_name,cmd->name)) ! 653: return true; ! 654: } ! 655: return false; ! 656: } ! 657: /* ! 658: ============ ! 659: Cmd_CompleteCommand ! 660: ============ ! 661: */ ! 662: char *Cmd_CompleteCommand (char *partial) ! 663: { ! 664: cmd_function_t *cmd; ! 665: int len; ! 666: cmdalias_t *a; ! 667: ! 668: len = strlen(partial); ! 669: ! 670: if (!len) ! 671: return NULL; ! 672: ! 673: // check for exact match ! 674: for (cmd=cmd_functions ; cmd ; cmd=cmd->next) ! 675: if (!strcmp (partial,cmd->name)) ! 676: return cmd->name; ! 677: for (a=cmd_alias ; a ; a=a->next) ! 678: if (!strcmp (partial, a->name)) ! 679: return a->name; ! 680: // check for partial match ! 681: for (cmd=cmd_functions ; cmd ; cmd=cmd->next) ! 682: if (!strncmp (partial,cmd->name, len)) ! 683: return cmd->name; ! 684: for (a=cmd_alias ; a ; a=a->next) ! 685: if (!strncmp (partial, a->name, len)) ! 686: return a->name; ! 687: return NULL; ! 688: } ! 689: /* ! 690: ============ ! 691: Cmd_ExecuteString ! 692: A complete command line has been parsed, so try to execute it ! 693: FIXME: lookupnoadd the token to speed search? ! 694: ============ ! 695: */ ! 696: void Cmd_ExecuteString (char *text) ! 697: { ! 698: cmd_function_t *cmd; ! 699: cmdalias_t *a; ! 700: Cmd_TokenizeString (text, true); ! 701: ! 702: // execute the command line ! 703: if (!Cmd_Argc()) ! 704: return; // no tokens ! 705: // check functions ! 706: for (cmd=cmd_functions ; cmd ; cmd=cmd->next) ! 707: { ! 708: if (!Q_strcasecmp (cmd_argv[0],cmd->name)) ! 709: { ! 710: if (!cmd->function) ! 711: { // forward to server command ! 712: Cmd_ExecuteString (va("cmd %s", text)); ! 713: } ! 714: else ! 715: cmd->function (); ! 716: return; ! 717: } ! 718: } ! 719: // check alias ! 720: for (a=cmd_alias ; a ; a=a->next) ! 721: { ! 722: if (!Q_strcasecmp (cmd_argv[0], a->name)) ! 723: { ! 724: if (++alias_count == ALIAS_LOOP_COUNT) ! 725: { ! 726: Com_Printf ("ALIAS_LOOP_COUNT\n"); ! 727: return; ! 728: } ! 729: Cbuf_InsertText (a->value); ! 730: return; ! 731: } ! 732: } ! 733: ! 734: // check cvars ! 735: if (Cvar_Command ()) ! 736: return; ! 737: ! 738: // send it as a server command if we are connected ! 739: Cmd_ForwardToServer (); ! 740: } ! 741: /* ! 742: ============ ! 743: Cmd_List_f ! 744: ============ ! 745: */ ! 746: void Cmd_List_f (void) ! 747: { ! 748: cmd_function_t *cmd; ! 749: int i; ! 750: i = 0; ! 751: for (cmd=cmd_functions ; cmd ; cmd=cmd->next, i++) ! 752: Com_Printf ("%s\n", cmd->name); ! 753: Com_Printf ("%i commands\n", i); ! 754: } ! 755: /* ! 756: ============ ! 757: Cmd_Init ! 758: ============ ! 759: */ ! 760: void Cmd_Init (void) ! 761: { ! 762: // ! 763: // register our commands ! 764: // ! 765: Cmd_AddCommand ("cmdlist",Cmd_List_f); ! 766: Cmd_AddCommand ("exec",Cmd_Exec_f); ! 767: Cmd_AddCommand ("echo",Cmd_Echo_f); ! 768: Cmd_AddCommand ("alias",Cmd_Alias_f); ! 769: Cmd_AddCommand ("wait", Cmd_Wait_f); ! 770: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.