got rid of Hunk_Alloc, all allocations now have a proper name (perhaps a bit too...
[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         int             mark;
287
288         if (Cmd_Argc () != 2)
289         {
290                 Con_Printf ("exec <filename> : execute a script file\n");
291                 return;
292         }
293
294         mark = Hunk_LowMark ();
295         f = (char *)COM_LoadHunkFile (Cmd_Argv(1), false);
296         if (!f)
297         {
298                 Con_Printf ("couldn't exec %s\n",Cmd_Argv(1));
299                 return;
300         }
301         Con_Printf ("execing %s\n",Cmd_Argv(1));
302         
303         Cbuf_InsertText (f);
304         Hunk_FreeToLowMark (mark);
305 }
306
307
308 /*
309 ===============
310 Cmd_Echo_f
311
312 Just prints the rest of the line to the console
313 ===============
314 */
315 void Cmd_Echo_f (void)
316 {
317         int             i;
318         
319         for (i=1 ; i<Cmd_Argc() ; i++)
320                 Con_Printf ("%s ",Cmd_Argv(i));
321         Con_Printf ("\n");
322 }
323
324 /*
325 ===============
326 Cmd_Alias_f
327
328 Creates a new command that executes a command string (possibly ; seperated)
329 ===============
330 */
331
332 char *CopyString (char *in)
333 {
334         char    *out;
335         
336         out = Z_Malloc (strlen(in)+1);
337         strcpy (out, in);
338         return out;
339 }
340
341 void Cmd_Alias_f (void)
342 {
343         cmdalias_t      *a;
344         char            cmd[1024];
345         int                     i, c;
346         char            *s;
347
348         if (Cmd_Argc() == 1)
349         {
350                 Con_Printf ("Current alias commands:\n");
351                 for (a = cmd_alias ; a ; a=a->next)
352                         Con_Printf ("%s : %s\n", a->name, a->value);
353                 return;
354         }
355
356         s = Cmd_Argv(1);
357         if (strlen(s) >= MAX_ALIAS_NAME)
358         {
359                 Con_Printf ("Alias name is too long\n");
360                 return;
361         }
362
363         // if the alias allready exists, reuse it
364         for (a = cmd_alias ; a ; a=a->next)
365         {
366                 if (!strcmp(s, a->name))
367                 {
368                         Z_Free (a->value);
369                         break;
370                 }
371         }
372
373         if (!a)
374         {
375                 a = Z_Malloc (sizeof(cmdalias_t));
376                 a->next = cmd_alias;
377                 cmd_alias = a;
378         }
379         strcpy (a->name, s);    
380
381 // copy the rest of the command line
382         cmd[0] = 0;             // start out with a null string
383         c = Cmd_Argc();
384         for (i=2 ; i< c ; i++)
385         {
386                 strcat (cmd, Cmd_Argv(i));
387                 if (i != c)
388                         strcat (cmd, " ");
389         }
390         strcat (cmd, "\n");
391         
392         a->value = CopyString (cmd);
393 }
394
395 /*
396 =============================================================================
397
398                                         COMMAND EXECUTION
399
400 =============================================================================
401 */
402
403 typedef struct cmd_function_s
404 {
405         struct cmd_function_s   *next;
406         char                                    *name;
407         xcommand_t                              function;
408 } cmd_function_t;
409
410
411 #define MAX_ARGS                80
412
413 static  int                     cmd_argc;
414 static  char            *cmd_argv[MAX_ARGS];
415 static  char            *cmd_null_string = "";
416 static  char            *cmd_args = NULL;
417
418 cmd_source_t    cmd_source;
419
420
421 static  cmd_function_t  *cmd_functions;         // possible commands to execute
422
423 /*
424 ============
425 Cmd_Init
426 ============
427 */
428 void Cmd_Init (void)
429 {
430 //
431 // register our commands
432 //
433         Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
434         Cmd_AddCommand ("exec",Cmd_Exec_f);
435         Cmd_AddCommand ("echo",Cmd_Echo_f);
436         Cmd_AddCommand ("alias",Cmd_Alias_f);
437         Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
438         Cmd_AddCommand ("wait", Cmd_Wait_f);
439 }
440
441 /*
442 ============
443 Cmd_Argc
444 ============
445 */
446 int             Cmd_Argc (void)
447 {
448         return cmd_argc;
449 }
450
451 /*
452 ============
453 Cmd_Argv
454 ============
455 */
456 char    *Cmd_Argv (int arg)
457 {
458         if (arg >= cmd_argc )
459                 return cmd_null_string;
460         return cmd_argv[arg];   
461 }
462
463 /*
464 ============
465 Cmd_Args
466 ============
467 */
468 char            *Cmd_Args (void)
469 {
470         return cmd_args;
471 }
472
473
474 /*
475 ============
476 Cmd_TokenizeString
477
478 Parses the given string into command line tokens.
479 ============
480 */
481 void Cmd_TokenizeString (char *text)
482 {
483         int             i;
484         
485 // clear the args from the last string
486         for (i=0 ; i<cmd_argc ; i++)
487                 Z_Free (cmd_argv[i]);
488                 
489         cmd_argc = 0;
490         cmd_args = NULL;
491         
492         while (1)
493         {
494 // skip whitespace up to a /n
495                 while (*text && *text <= ' ' && *text != '\n')
496                 {
497                         text++;
498                 }
499                 
500                 if (*text == '\n')
501                 {       // a newline seperates commands in the buffer
502                         text++;
503                         break;
504                 }
505
506                 if (!*text)
507                         return;
508         
509                 if (cmd_argc == 1)
510                          cmd_args = text;
511                         
512                 text = COM_Parse (text);
513                 if (!text)
514                         return;
515
516                 if (cmd_argc < MAX_ARGS)
517                 {
518                         cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1);
519                         strcpy (cmd_argv[cmd_argc], com_token);
520                         cmd_argc++;
521                 }
522         }
523         
524 }
525
526
527 /*
528 ============
529 Cmd_AddCommand
530 ============
531 */
532 void    Cmd_AddCommand (char *cmd_name, xcommand_t function)
533 {
534         cmd_function_t  *cmd;
535         
536         if (host_initialized)   // because hunk allocation would get stomped
537                 Sys_Error ("Cmd_AddCommand after host_initialized");
538                 
539 // fail if the command is a variable name
540         if (Cvar_VariableString(cmd_name)[0])
541         {
542                 Con_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
543                 return;
544         }
545         
546 // fail if the command already exists
547         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
548         {
549                 if (!strcmp (cmd_name, cmd->name))
550                 {
551                         Con_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
552                         return;
553                 }
554         }
555
556         cmd = Hunk_AllocName (sizeof(cmd_function_t), "commands");
557         cmd->name = cmd_name;
558         cmd->function = function;
559         cmd->next = cmd_functions;
560         cmd_functions = cmd;
561 }
562
563 /*
564 ============
565 Cmd_Exists
566 ============
567 */
568 qboolean        Cmd_Exists (char *cmd_name)
569 {
570         cmd_function_t  *cmd;
571
572         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
573         {
574                 if (!strcmp (cmd_name,cmd->name))
575                         return true;
576         }
577
578         return false;
579 }
580
581
582
583 /*
584 ============
585 Cmd_CompleteCommand
586 ============
587 */
588 char *Cmd_CompleteCommand (char *partial)
589 {
590         cmd_function_t  *cmd;
591         int                             len;
592         
593         len = strlen(partial);
594         
595         if (!len)
596                 return NULL;
597                 
598 // check functions
599         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
600                 if (!strncmp (partial,cmd->name, len))
601                         return cmd->name;
602
603         return NULL;
604 }
605
606 /*
607 ============
608 Cmd_ExecuteString
609
610 A complete command line has been parsed, so try to execute it
611 FIXME: lookupnoadd the token to speed search?
612 ============
613 */
614 void    Cmd_ExecuteString (char *text, cmd_source_t src)
615 {       
616         cmd_function_t  *cmd;
617         cmdalias_t              *a;
618
619         cmd_source = src;
620         Cmd_TokenizeString (text);
621                         
622 // execute the command line
623         if (!Cmd_Argc())
624                 return;         // no tokens
625
626 // check functions
627         for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
628         {
629                 if (!Q_strcasecmp (cmd_argv[0],cmd->name))
630                 {
631                         cmd->function ();
632                         return;
633                 }
634         }
635
636 // check alias
637         for (a=cmd_alias ; a ; a=a->next)
638         {
639                 if (!Q_strcasecmp (cmd_argv[0], a->name))
640                 {
641                         Cbuf_InsertText (a->value);
642                         return;
643                 }
644         }
645         
646 // check cvars
647         if (!Cvar_Command ())
648                 Con_Printf ("Unknown command \"%s\"\n", Cmd_Argv(0));
649         
650 }
651
652
653 /*
654 ===================
655 Cmd_ForwardToServer
656
657 Sends the entire command line over to the server
658 ===================
659 */
660 void Cmd_ForwardToServer (void)
661 {
662         if (cls.state != ca_connected)
663         {
664                 Con_Printf ("Can't \"%s\", not connected\n", Cmd_Argv(0));
665                 return;
666         }
667         
668         if (cls.demoplayback)
669                 return;         // not really connected
670
671         MSG_WriteByte (&cls.message, clc_stringcmd);
672         if (Q_strcasecmp(Cmd_Argv(0), "cmd") != 0)
673         {
674                 SZ_Print (&cls.message, Cmd_Argv(0));
675                 SZ_Print (&cls.message, " ");
676         }
677         if (Cmd_Argc() > 1)
678                 SZ_Print (&cls.message, Cmd_Args());
679         else
680                 SZ_Print (&cls.message, "\n");
681 }
682
683
684 /*
685 ================
686 Cmd_CheckParm
687
688 Returns the position (1 to argc-1) in the command's argument list
689 where the given parameter apears, or 0 if not present
690 ================
691 */
692
693 int Cmd_CheckParm (char *parm)
694 {
695         int i;
696         
697         if (!parm)
698                 Sys_Error ("Cmd_CheckParm: NULL");
699
700         for (i = 1; i < Cmd_Argc (); i++)
701                 if (!Q_strcasecmp (parm, Cmd_Argv (i)))
702                         return i;
703                         
704         return 0;
705 }