converted script loading to use COM_LoadMallocFile instead of COM_LoadHunkFile
[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 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_Init
424 ============
425 */
426 void Cmd_Init (void)
427 {
428 //
429 // register our commands
430 //
431         Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
432         Cmd_AddCommand ("exec",Cmd_Exec_f);
433         Cmd_AddCommand ("echo",Cmd_Echo_f);
434         Cmd_AddCommand ("alias",Cmd_Alias_f);
435         Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
436         Cmd_AddCommand ("wait", Cmd_Wait_f);
437 }
438
439 /*
440 ============
441 Cmd_Argc
442 ============
443 */
444 int             Cmd_Argc (void)
445 {
446         return cmd_argc;
447 }
448
449 /*
450 ============
451 Cmd_Argv
452 ============
453 */
454 char    *Cmd_Argv (int arg)
455 {
456         if (arg >= cmd_argc )
457                 return cmd_null_string;
458         return cmd_argv[arg];   
459 }
460
461 /*
462 ============
463 Cmd_Args
464 ============
465 */
466 char            *Cmd_Args (void)
467 {
468         return cmd_args;
469 }
470
471
472 /*
473 ============
474 Cmd_TokenizeString
475
476 Parses the given string into command line tokens.
477 ============
478 */
479 void Cmd_TokenizeString (char *text)
480 {
481         int             i;
482         
483 // clear the args from the last string
484         for (i=0 ; i<cmd_argc ; i++)
485                 Z_Free (cmd_argv[i]);
486                 
487         cmd_argc = 0;
488         cmd_args = NULL;
489         
490         while (1)
491         {
492 // skip whitespace up to a /n
493                 while (*text && *text <= ' ' && *text != '\n')
494                 {
495                         text++;
496                 }
497                 
498                 if (*text == '\n')
499                 {       // a newline seperates commands in the buffer
500                         text++;
501                         break;
502                 }
503
504                 if (!*text)
505                         return;
506         
507                 if (cmd_argc == 1)
508                          cmd_args = text;
509                         
510                 text = COM_Parse (text);
511                 if (!text)
512                         return;
513
514                 if (cmd_argc < MAX_ARGS)
515                 {
516                         cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1);
517                         strcpy (cmd_argv[cmd_argc], com_token);
518                         cmd_argc++;
519                 }
520         }
521         
522 }
523
524
525 /*
526 ============
527 Cmd_AddCommand
528 ============
529 */
530 void    Cmd_AddCommand (char *cmd_name, xcommand_t function)
531 {
532         cmd_function_t  *cmd;
533         
534         if (host_initialized)   // because hunk allocation would get stomped
535                 Sys_Error ("Cmd_AddCommand after host_initialized");
536                 
537 // fail if the command is a variable name
538         if (Cvar_VariableString(cmd_name)[0])
539         {
540                 Con_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
541                 return;
542         }
543         
544 // fail if the command already exists
545         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
546         {
547                 if (!strcmp (cmd_name, cmd->name))
548                 {
549                         Con_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
550                         return;
551                 }
552         }
553
554         cmd = Hunk_AllocName (sizeof(cmd_function_t), "commands");
555         cmd->name = cmd_name;
556         cmd->function = function;
557         cmd->next = cmd_functions;
558         cmd_functions = cmd;
559 }
560
561 /*
562 ============
563 Cmd_Exists
564 ============
565 */
566 qboolean        Cmd_Exists (char *cmd_name)
567 {
568         cmd_function_t  *cmd;
569
570         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
571         {
572                 if (!strcmp (cmd_name,cmd->name))
573                         return true;
574         }
575
576         return false;
577 }
578
579
580
581 /*
582 ============
583 Cmd_CompleteCommand
584 ============
585 */
586 char *Cmd_CompleteCommand (char *partial)
587 {
588         cmd_function_t  *cmd;
589         int                             len;
590         
591         len = strlen(partial);
592         
593         if (!len)
594                 return NULL;
595                 
596 // check functions
597         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
598                 if (!strncmp (partial,cmd->name, len))
599                         return cmd->name;
600
601         return NULL;
602 }
603
604 /*
605 ============
606 Cmd_ExecuteString
607
608 A complete command line has been parsed, so try to execute it
609 FIXME: lookupnoadd the token to speed search?
610 ============
611 */
612 void    Cmd_ExecuteString (char *text, cmd_source_t src)
613 {       
614         cmd_function_t  *cmd;
615         cmdalias_t              *a;
616
617         cmd_source = src;
618         Cmd_TokenizeString (text);
619                         
620 // execute the command line
621         if (!Cmd_Argc())
622                 return;         // no tokens
623
624 // check functions
625         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
626         {
627                 if (!Q_strcasecmp (cmd_argv[0],cmd->name))
628                 {
629                         cmd->function ();
630                         return;
631                 }
632         }
633
634 // check alias
635         for (a=cmd_alias ; a ; a=a->next)
636         {
637                 if (!Q_strcasecmp (cmd_argv[0], a->name))
638                 {
639                         Cbuf_InsertText (a->value);
640                         return;
641                 }
642         }
643         
644 // check cvars
645         if (!Cvar_Command ())
646                 Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
647         
648 }
649
650
651 /*
652 ===================
653 Cmd_ForwardToServer
654
655 Sends the entire command line over to the server
656 ===================
657 */
658 void Cmd_ForwardToServer (void)
659 {
660         if (cls.state != ca_connected)
661         {
662                 Con_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
663                 return;
664         }
665         
666         if (cls.demoplayback)
667                 return;         // not really connected
668
669         MSG_WriteByte (&cls.message, clc_stringcmd);
670         if (Q_strcasecmp(Cmd_Argv(0), "cmd") != 0)
671         {
672                 SZ_Print (&cls.message, Cmd_Argv(0));
673                 SZ_Print (&cls.message, " ");
674         }
675         if (Cmd_Argc() > 1)
676                 SZ_Print (&cls.message, Cmd_Args());
677         else
678                 SZ_Print (&cls.message, "\n");
679 }
680
681
682 /*
683 ================
684 Cmd_CheckParm
685
686 Returns the position (1 to argc-1) in the command's argument list
687 where the given parameter apears, or 0 if not present
688 ================
689 */
690
691 int Cmd_CheckParm (char *parm)
692 {
693         int i;
694         
695         if (!parm)
696                 Sys_Error ("Cmd_CheckParm: NULL");
697
698         for (i = 1; i < Cmd_Argc (); i++)
699                 if (!Q_strcasecmp (parm, Cmd_Argv (i)))
700                         return i;
701                         
702         return 0;
703 }