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