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