make infobar height configurable
[divverent/darkplaces.git] / cvar.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 // cvar.c -- dynamic variable tracking
21
22 #include "quakedef.h"
23
24 const char *cvar_dummy_description = "custom cvar";
25
26 cvar_t *cvar_vars = NULL;
27 cvar_t *cvar_hashtable[CVAR_HASHSIZE];
28 const char *cvar_null_string = "";
29
30 /*
31 ============
32 Cvar_FindVar
33 ============
34 */
35 cvar_t *Cvar_FindVar (const char *var_name)
36 {
37         int hashindex;
38         cvar_t *var;
39
40         // use hash lookup to minimize search time
41         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
42         for (var = cvar_hashtable[hashindex];var;var = var->nextonhashchain)
43                 if (!strcmp (var_name, var->name))
44                         return var;
45
46         return NULL;
47 }
48
49 cvar_t *Cvar_FindVarAfter (const char *prev_var_name, int neededflags)
50 {
51         cvar_t *var;
52
53         if (*prev_var_name)
54         {
55                 var = Cvar_FindVar (prev_var_name);
56                 if (!var)
57                         return NULL;
58                 var = var->next;
59         }
60         else
61                 var = cvar_vars;
62
63         // search for the next cvar matching the needed flags
64         while (var)
65         {
66                 if ((var->flags & neededflags) || !neededflags)
67                         break;
68                 var = var->next;
69         }
70         return var;
71 }
72
73 cvar_t *Cvar_FindVarLink (const char *var_name, cvar_t **parent, cvar_t ***link, cvar_t **prev_alpha)
74 {
75         int hashindex;
76         cvar_t *var;
77
78         // use hash lookup to minimize search time
79         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name));
80         if(parent) *parent = NULL;
81         if(prev_alpha) *prev_alpha = NULL;
82         if(link) *link = &cvar_hashtable[hashindex];
83         for (var = cvar_hashtable[hashindex];var;var = var->nextonhashchain)
84         {
85                 if (!strcmp (var_name, var->name))
86                 {
87                         if(!prev_alpha || var == cvar_vars)
88                                 return var;
89
90                         *prev_alpha = cvar_vars;
91                         // if prev_alpha happens to become NULL then there has been some inconsistency elsewhere
92                         // already - should I still insert '*prev_alpha &&' in the loop?
93                         while((*prev_alpha)->next != var)
94                                 *prev_alpha = (*prev_alpha)->next;
95                         return var;
96                 }
97                 if(parent) *parent = var;
98         }
99
100         return NULL;
101 }
102
103 /*
104 ============
105 Cvar_VariableValue
106 ============
107 */
108 float Cvar_VariableValue (const char *var_name)
109 {
110         cvar_t *var;
111
112         var = Cvar_FindVar (var_name);
113         if (!var)
114                 return 0;
115         return atof (var->string);
116 }
117
118
119 /*
120 ============
121 Cvar_VariableString
122 ============
123 */
124 const char *Cvar_VariableString (const char *var_name)
125 {
126         cvar_t *var;
127
128         var = Cvar_FindVar (var_name);
129         if (!var)
130                 return cvar_null_string;
131         return var->string;
132 }
133
134 /*
135 ============
136 Cvar_VariableDefString
137 ============
138 */
139 const char *Cvar_VariableDefString (const char *var_name)
140 {
141         cvar_t *var;
142
143         var = Cvar_FindVar (var_name);
144         if (!var)
145                 return cvar_null_string;
146         return var->defstring;
147 }
148
149 /*
150 ============
151 Cvar_VariableDescription
152 ============
153 */
154 const char *Cvar_VariableDescription (const char *var_name)
155 {
156         cvar_t *var;
157
158         var = Cvar_FindVar (var_name);
159         if (!var)
160                 return cvar_null_string;
161         return var->description;
162 }
163
164
165 /*
166 ============
167 Cvar_CompleteVariable
168 ============
169 */
170 const char *Cvar_CompleteVariable (const char *partial)
171 {
172         cvar_t          *cvar;
173         size_t          len;
174
175         len = strlen(partial);
176
177         if (!len)
178                 return NULL;
179
180 // check functions
181         for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
182                 if (!strncasecmp (partial,cvar->name, len))
183                         return cvar->name;
184
185         return NULL;
186 }
187
188
189 /*
190         CVar_CompleteCountPossible
191
192         New function for tab-completion system
193         Added by EvilTypeGuy
194         Thanks to Fett erich@heintz.com
195
196 */
197 int Cvar_CompleteCountPossible (const char *partial)
198 {
199         cvar_t  *cvar;
200         size_t  len;
201         int             h;
202
203         h = 0;
204         len = strlen(partial);
205
206         if (!len)
207                 return  0;
208
209         // Loop through the cvars and count all possible matches
210         for (cvar = cvar_vars; cvar; cvar = cvar->next)
211                 if (!strncasecmp(partial, cvar->name, len))
212                         h++;
213
214         return h;
215 }
216
217 /*
218         CVar_CompleteBuildList
219
220         New function for tab-completion system
221         Added by EvilTypeGuy
222         Thanks to Fett erich@heintz.com
223         Thanks to taniwha
224
225 */
226 const char **Cvar_CompleteBuildList (const char *partial)
227 {
228         const cvar_t *cvar;
229         size_t len = 0;
230         size_t bpos = 0;
231         size_t sizeofbuf = (Cvar_CompleteCountPossible (partial) + 1) * sizeof (const char *);
232         const char **buf;
233
234         len = strlen(partial);
235         buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
236         // Loop through the alias list and print all matches
237         for (cvar = cvar_vars; cvar; cvar = cvar->next)
238                 if (!strncasecmp(partial, cvar->name, len))
239                         buf[bpos++] = cvar->name;
240
241         buf[bpos] = NULL;
242         return buf;
243 }
244
245 // written by LordHavoc
246 void Cvar_CompleteCvarPrint (const char *partial)
247 {
248         cvar_t *cvar;
249         size_t len = strlen(partial);
250         // Loop through the command list and print all matches
251         for (cvar = cvar_vars; cvar; cvar = cvar->next)
252                 if (!strncasecmp(partial, cvar->name, len))
253                         Con_Printf ("^3%s^7 is \"%s\" [\"%s\"] %s\n", cvar->name, cvar->string, cvar->defstring, cvar->description);
254 }
255
256 // we assume that prog is already set to the target progs
257 static void Cvar_UpdateAutoCvar(cvar_t *var)
258 {
259         int i;
260         if(!prog)
261                 Host_Error("Cvar_UpdateAutoCvar: no prog set");
262         i = PRVM_GetProgNr();
263         if(var->globaldefindex_progid[i] == prog->id)
264         {
265                 // MUST BE SYNCED WITH prvm_edict.c PRVM_LoadProgs
266                 int j;
267                 const char *s;
268                 prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[var->globaldefindex[i]].ofs);
269                 switch(prog->globaldefs[var->globaldefindex[i]].type & ~DEF_SAVEGLOBAL)
270                 {
271                         case ev_float:
272                                 val->_float = var->value;
273                                 break;
274                         case ev_vector:
275                                 s = var->string;
276                                 VectorClear(val->vector);
277                                 for (j = 0;j < 3;j++)
278                                 {
279                                         while (*s && ISWHITESPACE(*s))
280                                                 s++;
281                                         if (!*s)
282                                                 break;
283                                         val->vector[j] = atof(s);
284                                         while (!ISWHITESPACE(*s))
285                                                 s++;
286                                         if (!*s)
287                                                 break;
288                                 }
289                                 break;
290                         case ev_string:
291                                 PRVM_ChangeEngineString(var->globaldefindex_stringno[i], var->string);
292                                 val->string = var->globaldefindex_stringno[i];
293                                 break;
294                 }
295         }
296 }
297
298 // called after loading a savegame
299 void Cvar_UpdateAllAutoCvars(void)
300 {
301         cvar_t *var;
302         for (var = cvar_vars ; var ; var = var->next)
303                 Cvar_UpdateAutoCvar(var);
304 }
305
306 /*
307 ============
308 Cvar_Set
309 ============
310 */
311 void Cvar_SetQuick_Internal (cvar_t *var, const char *value)
312 {
313         qboolean changed;
314         size_t valuelen;
315         prvm_prog_t *tmpprog;
316         int i;
317
318         changed = strcmp(var->string, value) != 0;
319         // LordHavoc: don't reallocate when there is no change
320         if (!changed)
321                 return;
322
323         // LordHavoc: don't reallocate when the buffer is the same size
324         valuelen = strlen(value);
325         if (!var->string || strlen(var->string) != valuelen)
326         {
327                 Z_Free ((char *)var->string);   // free the old value string
328
329                 var->string = (char *)Z_Malloc (valuelen + 1);
330         }
331         memcpy ((char *)var->string, value, valuelen + 1);
332         var->value = atof (var->string);
333         var->integer = (int) var->value;
334         if ((var->flags & CVAR_NOTIFY) && changed && sv.active)
335                 SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, var->string);
336 #if 0
337         // TODO: add infostring support to the server?
338         if ((var->flags & CVAR_SERVERINFO) && changed && sv.active)
339         {
340                 InfoString_SetValue(svs.serverinfo, sizeof(svs.serverinfo), var->name, var->string);
341                 if (sv.active)
342                 {
343                         MSG_WriteByte (&sv.reliable_datagram, svc_serverinfostring);
344                         MSG_WriteString (&sv.reliable_datagram, var->name);
345                         MSG_WriteString (&sv.reliable_datagram, var->string);
346                 }
347         }
348 #endif
349         if ((var->flags & CVAR_USERINFO) && cls.state != ca_dedicated)
350                 CL_SetInfo(var->name, var->string, true, false, false, false);
351         else if ((var->flags & CVAR_NQUSERINFOHACK) && cls.state != ca_dedicated)
352         {
353                 // update the cls.userinfo to have proper values for the
354                 // silly nq config variables.
355                 //
356                 // this is done when these variables are changed rather than at
357                 // connect time because if the user or code checks the userinfo and it
358                 // holds weird values it may cause confusion...
359                 if (!strcmp(var->name, "_cl_color"))
360                 {
361                         int top = (var->integer >> 4) & 15, bottom = var->integer & 15;
362                         CL_SetInfo("topcolor", va("%i", top), true, false, false, false);
363                         CL_SetInfo("bottomcolor", va("%i", bottom), true, false, false, false);
364                         if (cls.protocol != PROTOCOL_QUAKEWORLD && cls.netcon)
365                         {
366                                 MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
367                                 MSG_WriteString(&cls.netcon->message, va("color %i %i", top, bottom));
368                         }
369                 }
370                 else if (!strcmp(var->name, "_cl_rate"))
371                         CL_SetInfo("rate", va("%i", var->integer), true, false, false, false);
372                 else if (!strcmp(var->name, "_cl_playerskin"))
373                         CL_SetInfo("playerskin", var->string, true, false, false, false);
374                 else if (!strcmp(var->name, "_cl_playermodel"))
375                         CL_SetInfo("playermodel", var->string, true, false, false, false);
376                 else if (!strcmp(var->name, "_cl_name"))
377                         CL_SetInfo("name", var->string, true, false, false, false);
378                 else if (!strcmp(var->name, "rcon_secure"))
379                 {
380                         // whenever rcon_secure is changed to 0, clear rcon_password for
381                         // security reasons (prevents a send-rcon-password-as-plaintext
382                         // attack based on NQ protocol session takeover and svc_stufftext)
383                         if(var->integer <= 0)
384                                 Cvar_Set("rcon_password", "");
385                 }
386                 else if (!strcmp(var->name, "net_slist_favorites"))
387                         NetConn_UpdateFavorites();
388         }
389
390         tmpprog = prog;
391         for(i = 0; i < PRVM_MAXPROGS; ++i)
392         {
393                 if(PRVM_ProgLoaded(i))
394                 {
395                         PRVM_SetProg(i);
396                         Cvar_UpdateAutoCvar(var);
397                 }
398         }
399         prog = tmpprog;
400 }
401
402 void Cvar_SetQuick (cvar_t *var, const char *value)
403 {
404         if (var == NULL)
405         {
406                 Con_Print("Cvar_SetQuick: var == NULL\n");
407                 return;
408         }
409
410         if (developer_extra.integer)
411                 Con_DPrintf("Cvar_SetQuick({\"%s\", \"%s\", %i, \"%s\"}, \"%s\");\n", var->name, var->string, var->flags, var->defstring, value);
412
413         Cvar_SetQuick_Internal(var, value);
414 }
415
416 void Cvar_Set (const char *var_name, const char *value)
417 {
418         cvar_t *var;
419         var = Cvar_FindVar (var_name);
420         if (var == NULL)
421         {
422                 Con_Printf("Cvar_Set: variable %s not found\n", var_name);
423                 return;
424         }
425         Cvar_SetQuick(var, value);
426 }
427
428 /*
429 ============
430 Cvar_SetValue
431 ============
432 */
433 void Cvar_SetValueQuick(cvar_t *var, float value)
434 {
435         char val[MAX_INPUTLINE];
436
437         if ((float)((int)value) == value)
438                 dpsnprintf(val, sizeof(val), "%i", (int)value);
439         else
440                 dpsnprintf(val, sizeof(val), "%f", value);
441         Cvar_SetQuick(var, val);
442 }
443
444 void Cvar_SetValue(const char *var_name, float value)
445 {
446         char val[MAX_INPUTLINE];
447
448         if ((float)((int)value) == value)
449                 dpsnprintf(val, sizeof(val), "%i", (int)value);
450         else
451                 dpsnprintf(val, sizeof(val), "%f", value);
452         Cvar_Set(var_name, val);
453 }
454
455 /*
456 ============
457 Cvar_RegisterVariable
458
459 Adds a freestanding variable to the variable list.
460 ============
461 */
462 void Cvar_RegisterVariable (cvar_t *variable)
463 {
464         int hashindex;
465         cvar_t *current, *next, *cvar;
466         char *oldstr;
467         size_t alloclen;
468
469         if (developer_extra.integer)
470                 Con_DPrintf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
471
472 // first check to see if it has already been defined
473         cvar = Cvar_FindVar (variable->name);
474         if (cvar)
475         {
476                 if (cvar->flags & CVAR_ALLOCATED)
477                 {
478                         if (developer_extra.integer)
479                                 Con_DPrintf("...  replacing existing allocated cvar {\"%s\", \"%s\", %i}\n", cvar->name, cvar->string, cvar->flags);
480                         // fixed variables replace allocated ones
481                         // (because the engine directly accesses fixed variables)
482                         // NOTE: this isn't actually used currently
483                         // (all cvars are registered before config parsing)
484                         variable->flags |= (cvar->flags & ~CVAR_ALLOCATED);
485                         // cvar->string is now owned by variable instead
486                         variable->string = cvar->string;
487                         variable->defstring = cvar->defstring;
488                         variable->value = atof (variable->string);
489                         variable->integer = (int) variable->value;
490                         // replace cvar with this one...
491                         variable->next = cvar->next;
492                         if (cvar_vars == cvar)
493                         {
494                                 // head of the list is easy to change
495                                 cvar_vars = variable;
496                         }
497                         else
498                         {
499                                 // otherwise find it somewhere in the list
500                                 for (current = cvar_vars;current->next != cvar;current = current->next)
501                                         ;
502                                 current->next = variable;
503                         }
504
505                         // get rid of old allocated cvar
506                         // (but not cvar->string and cvar->defstring, because we kept those)
507                         Z_Free((char *)cvar->name);
508                         Z_Free(cvar);
509                 }
510                 else
511                         Con_DPrintf("Can't register variable %s, already defined\n", variable->name);
512                 return;
513         }
514
515 // check for overlap with a command
516         if (Cmd_Exists (variable->name))
517         {
518                 Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
519                 return;
520         }
521
522 // copy the value off, because future sets will Z_Free it
523         oldstr = (char *)variable->string;
524         alloclen = strlen(variable->string) + 1;
525         variable->string = (char *)Z_Malloc (alloclen);
526         memcpy ((char *)variable->string, oldstr, alloclen);
527         variable->defstring = (char *)Z_Malloc (alloclen);
528         memcpy ((char *)variable->defstring, oldstr, alloclen);
529         variable->value = atof (variable->string);
530         variable->integer = (int) variable->value;
531
532 // link the variable in
533 // alphanumerical order
534         for( current = NULL, next = cvar_vars ; next && strcmp( next->name, variable->name ) < 0 ; current = next, next = next->next )
535                 ;
536         if( current ) {
537                 current->next = variable;
538         } else {
539                 cvar_vars = variable;
540         }
541         variable->next = next;
542
543         // link to head of list in this hash table index
544         hashindex = CRC_Block((const unsigned char *)variable->name, strlen(variable->name)) % CVAR_HASHSIZE;
545         variable->nextonhashchain = cvar_hashtable[hashindex];
546         cvar_hashtable[hashindex] = variable;
547 }
548
549 /*
550 ============
551 Cvar_Get
552
553 Adds a newly allocated variable to the variable list or sets its value.
554 ============
555 */
556 cvar_t *Cvar_Get (const char *name, const char *value, int flags, const char *newdescription)
557 {
558         int hashindex;
559         cvar_t *current, *next, *cvar;
560         size_t alloclen;
561
562         if (developer_extra.integer)
563                 Con_DPrintf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
564
565 // first check to see if it has already been defined
566         cvar = Cvar_FindVar (name);
567         if (cvar)
568         {
569                 cvar->flags |= flags;
570                 Cvar_SetQuick_Internal (cvar, value);
571                 if(newdescription && (cvar->flags & CVAR_ALLOCATED))
572                 {
573                         if(cvar->description != cvar_dummy_description)
574                                 Z_Free((char *)cvar->description);
575
576                         if(*newdescription)
577                         {
578                                 alloclen = strlen(newdescription) + 1;
579                                 cvar->description = (char *)Z_Malloc(alloclen);
580                                 memcpy((char *)cvar->description, newdescription, alloclen);
581                         }
582                         else
583                                 cvar->description = cvar_dummy_description;
584                 }
585                 return cvar;
586         }
587
588 // check for pure evil
589         if (!*name)
590         {
591                 Con_Printf("Cvar_Get: invalid variable name\n");
592                 return NULL;
593         }
594
595 // check for overlap with a command
596         if (Cmd_Exists (name))
597         {
598                 Con_Printf("Cvar_Get: %s is a command\n", name);
599                 return NULL;
600         }
601
602 // allocate a new cvar, cvar name, and cvar string
603 // TODO: factorize the following code with the one at the end of Cvar_RegisterVariable()
604 // FIXME: these never get Z_Free'd
605         cvar = (cvar_t *)Z_Malloc(sizeof(cvar_t));
606         cvar->flags = flags | CVAR_ALLOCATED;
607         alloclen = strlen(name) + 1;
608         cvar->name = (char *)Z_Malloc(alloclen);
609         memcpy((char *)cvar->name, name, alloclen);
610         alloclen = strlen(value) + 1;
611         cvar->string = (char *)Z_Malloc(alloclen);
612         memcpy((char *)cvar->string, value, alloclen);
613         cvar->defstring = (char *)Z_Malloc(alloclen);
614         memcpy((char *)cvar->defstring, value, alloclen);
615         cvar->value = atof (cvar->string);
616         cvar->integer = (int) cvar->value;
617
618         if(newdescription && *newdescription)
619         {
620                 alloclen = strlen(newdescription) + 1;
621                 cvar->description = (char *)Z_Malloc(alloclen);
622                 memcpy((char *)cvar->description, newdescription, alloclen);
623         }
624         else
625                 cvar->description = cvar_dummy_description; // actually checked by VM_cvar_type
626
627 // link the variable in
628 // alphanumerical order
629         for( current = NULL, next = cvar_vars ; next && strcmp( next->name, cvar->name ) < 0 ; current = next, next = next->next )
630                 ;
631         if( current )
632                 current->next = cvar;
633         else
634                 cvar_vars = cvar;
635         cvar->next = next;
636
637         // link to head of list in this hash table index
638         hashindex = CRC_Block((const unsigned char *)cvar->name, strlen(cvar->name)) % CVAR_HASHSIZE;
639         cvar->nextonhashchain = cvar_hashtable[hashindex];
640         cvar_hashtable[hashindex] = cvar;
641
642         return cvar;
643 }
644
645
646 /*
647 ============
648 Cvar_Command
649
650 Handles variable inspection and changing from the console
651 ============
652 */
653 qboolean        Cvar_Command (void)
654 {
655         cvar_t                  *v;
656
657 // check variables
658         v = Cvar_FindVar (Cmd_Argv(0));
659         if (!v)
660                 return false;
661
662 // perform a variable print or set
663         if (Cmd_Argc() == 1)
664         {
665                 Con_Printf("\"%s\" is \"%s\" [\"%s\"]\n", v->name, ((v->flags & CVAR_PRIVATE) ? "********"/*hunter2*/ : v->string), v->defstring);
666                 return true;
667         }
668
669         if (developer_extra.integer)
670                 Con_DPrint("Cvar_Command: ");
671
672         if (v->flags & CVAR_READONLY)
673         {
674                 Con_Printf("%s is read-only\n", v->name);
675                 return true;
676         }
677         Cvar_Set (v->name, Cmd_Argv(1));
678         if (developer_extra.integer)
679                 Con_DPrint("\n");
680         return true;
681 }
682
683
684 void Cvar_UnlockDefaults (void)
685 {
686         cvar_t *var;
687         // unlock the default values of all cvars
688         for (var = cvar_vars ; var ; var = var->next)
689                 var->flags &= ~CVAR_DEFAULTSET;
690 }
691
692
693 void Cvar_LockDefaults_f (void)
694 {
695         cvar_t *var;
696         // lock in the default values of all cvars
697         for (var = cvar_vars ; var ; var = var->next)
698         {
699                 if (!(var->flags & CVAR_DEFAULTSET))
700                 {
701                         size_t alloclen;
702
703                         //Con_Printf("locking cvar %s (%s -> %s)\n", var->name, var->string, var->defstring);
704                         var->flags |= CVAR_DEFAULTSET;
705                         Z_Free((char *)var->defstring);
706                         alloclen = strlen(var->string) + 1;
707                         var->defstring = (char *)Z_Malloc(alloclen);
708                         memcpy((char *)var->defstring, var->string, alloclen);
709                 }
710         }
711 }
712
713
714 void Cvar_ResetToDefaults_All_f (void)
715 {
716         cvar_t *var;
717         // restore the default values of all cvars
718         for (var = cvar_vars ; var ; var = var->next)
719                 if((var->flags & CVAR_NORESETTODEFAULTS) == 0)
720                         Cvar_SetQuick(var, var->defstring);
721 }
722
723
724 void Cvar_ResetToDefaults_NoSaveOnly_f (void)
725 {
726         cvar_t *var;
727         // restore the default values of all cvars
728         for (var = cvar_vars ; var ; var = var->next)
729                 if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == 0)
730                         Cvar_SetQuick(var, var->defstring);
731 }
732
733
734 void Cvar_ResetToDefaults_SaveOnly_f (void)
735 {
736         cvar_t *var;
737         // restore the default values of all cvars
738         for (var = cvar_vars ; var ; var = var->next)
739                 if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == CVAR_SAVE)
740                         Cvar_SetQuick(var, var->defstring);
741 }
742
743
744 /*
745 ============
746 Cvar_WriteVariables
747
748 Writes lines containing "set variable value" for all variables
749 with the archive flag set to true.
750 ============
751 */
752 void Cvar_WriteVariables (qfile_t *f)
753 {
754         cvar_t  *var;
755         char buf1[MAX_INPUTLINE], buf2[MAX_INPUTLINE];
756
757         // don't save cvars that match their default value
758         for (var = cvar_vars ; var ; var = var->next)
759                 if ((var->flags & CVAR_SAVE) && (strcmp(var->string, var->defstring) || !(var->flags & CVAR_DEFAULTSET)))
760                 {
761                         Cmd_QuoteString(buf1, sizeof(buf1), var->name, "\"\\$");
762                         Cmd_QuoteString(buf2, sizeof(buf2), var->string, "\"\\$");
763                         FS_Printf(f, "%s\"%s\" \"%s\"\n", var->flags & CVAR_ALLOCATED ? "seta " : "", buf1, buf2);
764                 }
765 }
766
767
768 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
769 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
770 /*
771 =========
772 Cvar_List
773 =========
774 */
775 void Cvar_List_f (void)
776 {
777         cvar_t *cvar;
778         const char *partial;
779         size_t len;
780         int count;
781         qboolean ispattern;
782
783         if (Cmd_Argc() > 1)
784         {
785                 partial = Cmd_Argv (1);
786                 len = strlen(partial);
787         }
788         else
789         {
790                 partial = NULL;
791                 len = 0;
792         }
793
794         ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
795
796         count = 0;
797         for (cvar = cvar_vars; cvar; cvar = cvar->next)
798         {
799                 if (len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp (partial,cvar->name,len)))
800                         continue;
801
802                 Con_Printf("%s is \"%s\" [\"%s\"] %s\n", cvar->name, ((cvar->flags & CVAR_PRIVATE) ? "********"/*hunter2*/ : cvar->string), cvar->defstring, cvar->description);
803                 count++;
804         }
805
806         if (len)
807         {
808                 if(ispattern)
809                         Con_Printf("%i cvar%s matching \"%s\"\n", count, (count > 1) ? "s" : "", partial);
810                 else
811                         Con_Printf("%i cvar%s beginning with \"%s\"\n", count, (count > 1) ? "s" : "", partial);
812         }
813         else
814                 Con_Printf("%i cvar(s)\n", count);
815 }
816 // 2000-01-09 CvarList command by Maddes
817
818 void Cvar_Set_f (void)
819 {
820         cvar_t *cvar;
821
822         // make sure it's the right number of parameters
823         if (Cmd_Argc() < 3)
824         {
825                 Con_Printf("Set: wrong number of parameters, usage: set <variablename> <value> [<description>]\n");
826                 return;
827         }
828
829         // check if it's read-only
830         cvar = Cvar_FindVar(Cmd_Argv(1));
831         if (cvar && cvar->flags & CVAR_READONLY)
832         {
833                 Con_Printf("Set: %s is read-only\n", cvar->name);
834                 return;
835         }
836
837         if (developer_extra.integer)
838                 Con_DPrint("Set: ");
839
840         // all looks ok, create/modify the cvar
841         Cvar_Get(Cmd_Argv(1), Cmd_Argv(2), 0, Cmd_Argc() > 3 ? Cmd_Argv(3) : NULL);
842 }
843
844 void Cvar_SetA_f (void)
845 {
846         cvar_t *cvar;
847
848         // make sure it's the right number of parameters
849         if (Cmd_Argc() < 3)
850         {
851                 Con_Printf("SetA: wrong number of parameters, usage: seta <variablename> <value> [<description>]\n");
852                 return;
853         }
854
855         // check if it's read-only
856         cvar = Cvar_FindVar(Cmd_Argv(1));
857         if (cvar && cvar->flags & CVAR_READONLY)
858         {
859                 Con_Printf("SetA: %s is read-only\n", cvar->name);
860                 return;
861         }
862
863         if (developer_extra.integer)
864                 Con_DPrint("SetA: ");
865
866         // all looks ok, create/modify the cvar
867         Cvar_Get(Cmd_Argv(1), Cmd_Argv(2), CVAR_SAVE, Cmd_Argc() > 3 ? Cmd_Argv(3) : NULL);
868 }
869
870 void Cvar_Del_f (void)
871 {
872         int i;
873         cvar_t *cvar, *parent, **link, *prev;
874
875         if(Cmd_Argc() < 2)
876         {
877                 Con_Printf("Del: wrong number of parameters, useage: unset <variablename1> [<variablename2> ...]\n");
878                 return;
879         }
880         for(i = 1; i < Cmd_Argc(); ++i)
881         {
882                 cvar = Cvar_FindVarLink(Cmd_Argv(i), &parent, &link, &prev);
883                 if(!cvar)
884                 {
885                         Con_Printf("Del: %s is not defined\n", Cmd_Argv(i));
886                         continue;
887                 }
888                 if(cvar->flags & CVAR_READONLY)
889                 {
890                         Con_Printf("Del: %s is read-only\n", cvar->name);
891                         continue;
892                 }
893                 if(!(cvar->flags & CVAR_ALLOCATED))
894                 {
895                         Con_Printf("Del: %s is static and cannot be deleted\n", cvar->name);
896                         continue;
897                 }
898                 if(cvar == cvar_vars)
899                 {
900                         cvar_vars = cvar->next;
901                 }
902                 else
903                 {
904                         // in this case, prev must be set, otherwise there has been some inconsistensy
905                         // elsewhere already... should I still check for prev != NULL?
906                         prev->next = cvar->next;
907                 }
908
909                 if(parent)
910                         parent->nextonhashchain = cvar->nextonhashchain;
911                 else if(link)
912                         *link = cvar->nextonhashchain;
913
914                 if(cvar->description != cvar_dummy_description)
915                         Z_Free((char *)cvar->description);
916
917                 Z_Free((char *)cvar->name);
918                 Z_Free((char *)cvar->string);
919                 Z_Free((char *)cvar->defstring);
920                 Z_Free(cvar);
921         }
922 }
923
924 #ifdef FILLALLCVARSWITHRUBBISH
925 void Cvar_FillAll_f()
926 {
927         char *buf, *p, *q;
928         int n, i;
929         cvar_t *var;
930         qboolean verify;
931         if(Cmd_Argc() != 2)
932         {
933                 Con_Printf("Usage: %s length to plant rubbish\n", Cmd_Argv(0));
934                 Con_Printf("Usage: %s -length to verify that the rubbish is still there\n", Cmd_Argv(0));
935                 return;
936         }
937         n = atoi(Cmd_Argv(1));
938         verify = (n < 0);
939         if(verify)
940                 n = -n;
941         buf = Z_Malloc(n + 1);
942         buf[n] = 0;
943         for(var = cvar_vars; var; var = var->next)
944         {
945                 for(i = 0, p = buf, q = var->name; i < n; ++i)
946                 {
947                         *p++ = *q++;
948                         if(!*q)
949                                 q = var->name;
950                 }
951                 if(verify && strcmp(var->string, buf))
952                 {
953                         Con_Printf("\n%s does not contain the right rubbish, either this is the first run or a possible overrun was detected, or something changed it intentionally; it DOES contain: %s\n", var->name, var->string);
954                 }
955                 Cvar_SetQuick(var, buf);
956         }
957         Z_Free(buf);
958 }
959 #endif /* FILLALLCVARSWITHRUBBISH */