most of Q2's keyboard handling ported over - what this means: keypad is now separatel...
[divverent/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 (const 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 (const 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 static char *CopyString (char *in)
327 {
328         char *out;
329
330         out = Z_Malloc (strlen(in)+1);
331         strcpy (out, in);
332         return out;
333 }
334
335 static void Cmd_Alias_f (void)
336 {
337         cmdalias_t      *a;
338         char            cmd[1024];
339         int                     i, c;
340         const char              *s;
341
342         if (Cmd_Argc() == 1)
343         {
344                 Con_Printf ("Current alias commands:\n");
345                 for (a = cmd_alias ; a ; a=a->next)
346                         Con_Printf ("%s : %s\n", a->name, a->value);
347                 return;
348         }
349
350         s = Cmd_Argv(1);
351         if (strlen(s) >= MAX_ALIAS_NAME)
352         {
353                 Con_Printf ("Alias name is too long\n");
354                 return;
355         }
356
357         // if the alias already exists, reuse it
358         for (a = cmd_alias ; a ; a=a->next)
359         {
360                 if (!strcmp(s, a->name))
361                 {
362                         Z_Free (a->value);
363                         break;
364                 }
365         }
366
367         if (!a)
368         {
369                 a = Z_Malloc (sizeof(cmdalias_t));
370                 a->next = cmd_alias;
371                 cmd_alias = a;
372         }
373         strcpy (a->name, s);
374
375 // copy the rest of the command line
376         cmd[0] = 0;             // start out with a null string
377         c = Cmd_Argc();
378         for (i=2 ; i< c ; i++)
379         {
380                 strcat (cmd, Cmd_Argv(i));
381                 if (i != c)
382                         strcat (cmd, " ");
383         }
384         strcat (cmd, "\n");
385
386         a->value = CopyString (cmd);
387 }
388
389 /*
390 =============================================================================
391
392                                         COMMAND EXECUTION
393
394 =============================================================================
395 */
396
397 typedef struct cmd_function_s
398 {
399         struct cmd_function_s *next;
400         const char *name;
401         xcommand_t function;
402 } cmd_function_t;
403
404
405 #define MAX_ARGS                80
406
407 static int cmd_argc;
408 static const char *cmd_argv[MAX_ARGS];
409 static const char *cmd_null_string = "";
410 static const char *cmd_args = NULL;
411
412 cmd_source_t cmd_source;
413
414
415 static cmd_function_t *cmd_functions;           // possible commands to execute
416
417 /*
418 ========
419 Cmd_List
420
421         CmdList Added by EvilTypeGuy eviltypeguy@qeradiant.com
422         Thanks to Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
423
424 ========
425 */
426 static void Cmd_List_f (void)
427 {
428         cmd_function_t *cmd;
429         const char *partial;
430         int len, count;
431
432         if (Cmd_Argc() > 1)
433         {
434                 partial = Cmd_Argv (1);
435                 len = strlen(partial);
436         }
437         else
438         {
439                 partial = NULL;
440                 len = 0;
441         }
442
443         count = 0;
444         for (cmd = cmd_functions; cmd; cmd = cmd->next)
445         {
446                 if (partial && strncmp(partial, cmd->name, len))
447                         continue;
448                 Con_Printf ("%s\n", cmd->name);
449                 count++;
450         }
451
452         Con_Printf ("%i Command%s", count, (count > 1) ? "s" : "");
453         if (partial)
454                 Con_Printf(" beginning with \"%s\"", partial);
455
456         Con_Printf ("\n\n");
457 }
458
459 /*
460 ============
461 Cmd_Init
462 ============
463 */
464 void Cmd_Init (void)
465 {
466         cmd_mempool = Mem_AllocPool("commands");
467
468 //
469 // register our commands
470 //
471         Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
472         Cmd_AddCommand ("exec",Cmd_Exec_f);
473         Cmd_AddCommand ("echo",Cmd_Echo_f);
474         Cmd_AddCommand ("alias",Cmd_Alias_f);
475         Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
476         Cmd_AddCommand ("wait", Cmd_Wait_f);
477         Cmd_AddCommand ("cmdlist", Cmd_List_f);         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
478         Cmd_AddCommand ("cvarlist", Cvar_List_f);       // 2000-01-09 CmdList, CvarList commands
479                                                                                                 // By Matthias "Maddes" Buecher
480 }
481
482 /*
483 ============
484 Cmd_Argc
485 ============
486 */
487 int             Cmd_Argc (void)
488 {
489         return cmd_argc;
490 }
491
492 /*
493 ============
494 Cmd_Argv
495 ============
496 */
497 const char *Cmd_Argv (int arg)
498 {
499         if (arg >= cmd_argc )
500                 return cmd_null_string;
501         return cmd_argv[arg];
502 }
503
504 /*
505 ============
506 Cmd_Args
507 ============
508 */
509 const char *Cmd_Args (void)
510 {
511         return cmd_args;
512 }
513
514
515 #define CMD_TOKENIZELENGTH 4096
516 char cmd_tokenizebuffer[CMD_TOKENIZELENGTH];
517
518 /*
519 ============
520 Cmd_TokenizeString
521
522 Parses the given string into command line tokens.
523 ============
524 */
525 static void Cmd_TokenizeString (const char *text)
526 {
527         int l;
528         int pos;
529         pos = 0;
530
531         cmd_argc = 0;
532         cmd_args = NULL;
533
534         while (1)
535         {
536 // skip whitespace up to a /n
537                 while (*text && *text <= ' ' && *text != '\n')
538                 {
539                         text++;
540                 }
541
542                 if (*text == '\n')
543                 {       // a newline seperates commands in the buffer
544                         text++;
545                         break;
546                 }
547
548                 if (!*text)
549                         return;
550
551                 if (cmd_argc == 1)
552                          cmd_args = text;
553
554                 if (!COM_ParseToken (&text))
555                         return;
556
557                 if (cmd_argc < MAX_ARGS)
558                 {
559                         l = strlen(com_token) + 1;
560                         if (pos + l > CMD_TOKENIZELENGTH)
561                                 Sys_Error("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
562                         strcpy (cmd_tokenizebuffer + pos, com_token);
563                         cmd_argv[cmd_argc] = cmd_tokenizebuffer + pos;
564                         pos += l;
565                         cmd_argc++;
566                 }
567         }
568
569 }
570
571
572 /*
573 ============
574 Cmd_AddCommand
575 ============
576 */
577 void Cmd_AddCommand (const char *cmd_name, xcommand_t function)
578 {
579         cmd_function_t *cmd;
580
581 // fail if the command is a variable name
582         if (Cvar_VariableString(cmd_name)[0])
583         {
584                 Con_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
585                 return;
586         }
587
588 // fail if the command already exists
589         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
590         {
591                 if (!strcmp (cmd_name, cmd->name))
592                 {
593                         Con_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
594                         return;
595                 }
596         }
597
598         cmd = Mem_Alloc(cmd_mempool, sizeof(cmd_function_t));
599         cmd->name = cmd_name;
600         cmd->function = function;
601         cmd->next = cmd_functions;
602         cmd_functions = cmd;
603 }
604
605 /*
606 ============
607 Cmd_Exists
608 ============
609 */
610 qboolean Cmd_Exists (const char *cmd_name)
611 {
612         cmd_function_t  *cmd;
613
614         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
615                 if (!strcmp (cmd_name,cmd->name))
616                         return true;
617
618         return false;
619 }
620
621
622 /*
623 ============
624 Cmd_CompleteCommand
625 ============
626 */
627 const char *Cmd_CompleteCommand (const char *partial)
628 {
629         cmd_function_t *cmd;
630         int len;
631
632         len = strlen(partial);
633
634         if (!len)
635                 return NULL;
636
637 // check functions
638         for (cmd = cmd_functions; cmd; cmd = cmd->next)
639                 if (!strncmp(partial, cmd->name, len))
640                         return cmd->name;
641
642         return NULL;
643 }
644
645 /*
646         Cmd_CompleteCountPossible
647
648         New function for tab-completion system
649         Added by EvilTypeGuy
650         Thanks to Fett erich@heintz.com
651         Thanks to taniwha
652
653 */
654 int Cmd_CompleteCountPossible (const char *partial)
655 {
656         cmd_function_t *cmd;
657         int len, h;
658
659         h = 0;
660         len = strlen(partial);
661
662         if (!len)
663                 return 0;
664
665         // Loop through the command list and count all partial matches
666         for (cmd = cmd_functions; cmd; cmd = cmd->next)
667                 if (!strncasecmp(partial, cmd->name, len))
668                         h++;
669
670         return h;
671 }
672
673 /*
674         Cmd_CompleteBuildList
675
676         New function for tab-completion system
677         Added by EvilTypeGuy
678         Thanks to Fett erich@heintz.com
679         Thanks to taniwha
680
681 */
682 const char **Cmd_CompleteBuildList (const char *partial)
683 {
684         cmd_function_t *cmd;
685         int len = 0;
686         int bpos = 0;
687         int sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (const char *);
688         const char **buf;
689
690         len = strlen(partial);
691         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
692         // Loop through the alias list and print all matches
693         for (cmd = cmd_functions; cmd; cmd = cmd->next)
694                 if (!strncasecmp(partial, cmd->name, len))
695                         buf[bpos++] = cmd->name;
696
697         buf[bpos] = NULL;
698         return buf;
699 }
700
701 /*
702         Cmd_CompleteAlias
703
704         New function for tab-completion system
705         Added by EvilTypeGuy
706         Thanks to Fett erich@heintz.com
707         Thanks to taniwha
708
709 */
710 const char *Cmd_CompleteAlias (const char *partial)
711 {
712         cmdalias_t *alias;
713         int len;
714
715         len = strlen(partial);
716
717         if (!len)
718                 return NULL;
719
720         // Check functions
721         for (alias = cmd_alias; alias; alias = alias->next)
722                 if (!strncasecmp(partial, alias->name, len))
723                         return alias->name;
724
725         return NULL;
726 }
727
728 /*
729         Cmd_CompleteAliasCountPossible
730
731         New function for tab-completion system
732         Added by EvilTypeGuy
733         Thanks to Fett erich@heintz.com
734         Thanks to taniwha
735
736 */
737 int Cmd_CompleteAliasCountPossible (const char *partial)
738 {
739         cmdalias_t      *alias;
740         int                     len;
741         int                     h;
742
743         h = 0;
744
745         len = strlen(partial);
746
747         if (!len)
748                 return 0;
749
750         // Loop through the command list and count all partial matches
751         for (alias = cmd_alias; alias; alias = alias->next)
752                 if (!strncasecmp(partial, alias->name, len))
753                         h++;
754
755         return h;
756 }
757
758 /*
759         Cmd_CompleteAliasBuildList
760
761         New function for tab-completion system
762         Added by EvilTypeGuy
763         Thanks to Fett erich@heintz.com
764         Thanks to taniwha
765
766 */
767 const char **Cmd_CompleteAliasBuildList (const char *partial)
768 {
769         cmdalias_t *alias;
770         int len = 0;
771         int bpos = 0;
772         int sizeofbuf = (Cmd_CompleteAliasCountPossible (partial) + 1) * sizeof (const char *);
773         const char **buf;
774
775         len = strlen(partial);
776         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
777         // Loop through the alias list and print all matches
778         for (alias = cmd_alias; alias; alias = alias->next)
779                 if (!strncasecmp(partial, alias->name, len))
780                         buf[bpos++] = alias->name;
781
782         buf[bpos] = NULL;
783         return buf;
784 }
785
786 /*
787 ============
788 Cmd_ExecuteString
789
790 A complete command line has been parsed, so try to execute it
791 FIXME: lookupnoadd the token to speed search?
792 ============
793 */
794 void Cmd_ExecuteString (const char *text, cmd_source_t src)
795 {
796         cmd_function_t *cmd;
797         cmdalias_t *a;
798
799         cmd_source = src;
800         Cmd_TokenizeString (text);
801
802 // execute the command line
803         if (!Cmd_Argc())
804                 return;         // no tokens
805
806 // check functions
807         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
808         {
809                 if (!Q_strcasecmp (cmd_argv[0],cmd->name))
810                 {
811                         cmd->function ();
812                         return;
813                 }
814         }
815
816 // check alias
817         for (a=cmd_alias ; a ; a=a->next)
818         {
819                 if (!Q_strcasecmp (cmd_argv[0], a->name))
820                 {
821                         Cbuf_InsertText (a->value);
822                         return;
823                 }
824         }
825
826 // check cvars
827         if (!Cvar_Command ())
828                 Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
829 }
830
831
832 /*
833 ===================
834 Cmd_ForwardToServer
835
836 Sends the entire command line over to the server
837 ===================
838 */
839 void Cmd_ForwardToServer (void)
840 {
841         if (cls.state != ca_connected)
842         {
843                 Con_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
844                 return;
845         }
846
847         if (cls.demoplayback)
848                 return;         // not really connected
849
850         MSG_WriteByte (&cls.message, clc_stringcmd);
851         if (Q_strcasecmp(Cmd_Argv(0), "cmd") != 0)
852         {
853                 SZ_Print (&cls.message, Cmd_Argv(0));
854                 SZ_Print (&cls.message, " ");
855         }
856         if (Cmd_Argc() > 1)
857                 SZ_Print (&cls.message, Cmd_Args());
858         else
859                 SZ_Print (&cls.message, "\n");
860 }
861
862
863 /*
864 ================
865 Cmd_CheckParm
866
867 Returns the position (1 to argc-1) in the command's argument list
868 where the given parameter apears, or 0 if not present
869 ================
870 */
871
872 int Cmd_CheckParm (const char *parm)
873 {
874         int i;
875
876         if (!parm)
877                 Sys_Error ("Cmd_CheckParm: NULL");
878
879         for (i = 1; i < Cmd_Argc (); i++)
880                 if (!Q_strcasecmp (parm, Cmd_Argv (i)))
881                         return i;
882
883         return 0;
884 }
885