cvar: Rename aliasindex to aliases_size and only use it for size of the aliases array...
[xonotic/darkplaces.git] / cvar.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3 Copyright (C) 2000-2021 DarkPlaces contributors
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13
14 See the GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19
20 */
21 // cvar.c -- dynamic variable tracking
22
23 #include "quakedef.h"
24
25 const char *cvar_dummy_description = "custom cvar";
26 static const char *cvar_null_string = "";
27
28 cvar_state_t cvars_all;
29 cvar_state_t cvars_null;
30
31 /*
32 ============
33 Cvar_FindVar
34 ============
35 */
36 cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags)
37 {
38         int hashindex;
39         cvar_hash_t *hash;
40
41         // use hash lookup to minimize search time
42         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
43         for (hash = cvars->hashtable[hashindex];hash;hash = hash->next)
44                 if (!strcmp (var_name, hash->cvar->name) && (hash->cvar->flags & neededflags))
45                         return hash->cvar;
46                 else
47                         for (char **alias = hash->cvar->aliases; alias && *alias; alias++)
48                                 if (!strcmp (var_name, *alias) && (hash->cvar->flags & neededflags))
49                                         return hash->cvar;
50         return NULL;
51 }
52
53 cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags)
54 {
55         cvar_t *var;
56
57         if (*prev_var_name)
58         {
59                 var = Cvar_FindVar(cvars, prev_var_name, neededflags);
60                 if (!var)
61                         return NULL;
62                 var = var->next;
63         }
64         else
65                 var = cvars->vars;
66
67         // search for the next cvar matching the needed flags
68         while (var)
69         {
70                 if (var->flags & neededflags)
71                         break;
72                 var = var->next;
73         }
74         return var;
75 }
76
77 static cvar_t *Cvar_FindVarLink(cvar_state_t *cvars, const char *var_name, cvar_t **parent, cvar_t ***link, cvar_t **prev_alpha, int neededflags)
78 {
79         int hashindex;
80         cvar_hash_t *hash;
81
82         // use hash lookup to minimize search time
83         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
84         if(parent) *parent = NULL;
85         if(prev_alpha) *prev_alpha = NULL;
86         if(link) *link = &cvars->hashtable[hashindex]->cvar;
87         for (hash = cvars->hashtable[hashindex];hash;hash = hash->next)
88         {
89                 if (!strcmp (var_name, hash->cvar->name) && (hash->cvar->flags & neededflags))
90                         goto match;
91                 else
92                         for (char **alias = hash->cvar->aliases; alias && *alias; alias++)
93                                 if (!strcmp (var_name, *alias) && (hash->cvar->flags & neededflags))
94                                         goto match;
95                 if(parent) *parent = hash->cvar;
96         }
97         return NULL;
98 match:
99         if(!prev_alpha || hash->cvar == cvars->vars)
100                 return hash->cvar;
101
102         *prev_alpha = cvars->vars;
103         // if prev_alpha happens to become NULL then there has been some inconsistency elsewhere
104         // already - should I still insert '*prev_alpha &&' in the loop?
105         while((*prev_alpha)->next != hash->cvar)
106                 *prev_alpha = (*prev_alpha)->next;
107         return hash->cvar;
108 }
109
110 /*
111 ============
112 Cvar_VariableValue
113 ============
114 */
115 float Cvar_VariableValueOr(cvar_state_t *cvars, const char *var_name, float def, int neededflags)
116 {
117         cvar_t *var;
118
119         var = Cvar_FindVar(cvars, var_name, neededflags);
120         if (!var)
121                 return def;
122         return atof (var->string);
123 }
124
125 float Cvar_VariableValue(cvar_state_t *cvars, const char *var_name, int neededflags)
126 {
127         return Cvar_VariableValueOr(cvars, var_name, 0, neededflags);
128 }
129
130 /*
131 ============
132 Cvar_VariableString
133 ============
134 */
135 const char *Cvar_VariableStringOr(cvar_state_t *cvars, const char *var_name, const char *def, int neededflags)
136 {
137         cvar_t *var;
138
139         var = Cvar_FindVar(cvars, var_name, neededflags);
140         if (!var)
141                 return def;
142         return var->string;
143 }
144
145 const char *Cvar_VariableString(cvar_state_t *cvars, const char *var_name, int neededflags)
146 {
147         return Cvar_VariableStringOr(cvars, var_name, cvar_null_string, neededflags);
148 }
149
150 /*
151 ============
152 Cvar_VariableDefString
153 ============
154 */
155 const char *Cvar_VariableDefString(cvar_state_t *cvars, const char *var_name, int neededflags)
156 {
157         cvar_t *var;
158
159         var = Cvar_FindVar(cvars, var_name, neededflags);
160         if (!var)
161                 return cvar_null_string;
162         return var->defstring;
163 }
164
165 /*
166 ============
167 Cvar_VariableDescription
168 ============
169 */
170 const char *Cvar_VariableDescription(cvar_state_t *cvars, const char *var_name, int neededflags)
171 {
172         cvar_t *var;
173
174         var = Cvar_FindVar(cvars, var_name, neededflags);
175         if (!var)
176                 return cvar_null_string;
177         return var->description;
178 }
179
180
181 /*
182 ============
183 Cvar_CompleteVariable
184 ============
185 */
186 const char *Cvar_CompleteVariable(cvar_state_t *cvars, const char *partial, int neededflags)
187 {
188         cvar_t          *cvar;
189         size_t          len;
190
191         len = strlen(partial);
192
193         if (!len)
194                 return NULL;
195
196 // check functions
197         for (cvar=cvars->vars ; cvar ; cvar=cvar->next)
198                 if (!strncasecmp (partial,cvar->name, len) && (cvar->flags & neededflags))
199                         return cvar->name;
200
201         return NULL;
202 }
203
204
205 /*
206         CVar_CompleteCountPossible
207
208         New function for tab-completion system
209         Added by EvilTypeGuy
210         Thanks to Fett erich@heintz.com
211
212 */
213 int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags)
214 {
215         cvar_t  *cvar;
216         size_t  len;
217         int             h;
218
219         h = 0;
220         len = strlen(partial);
221
222         if (!len)
223                 return  0;
224
225         // Loop through the cvars and count all possible matches
226         for (cvar = cvars->vars; cvar; cvar = cvar->next)
227                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
228                         h++;
229                 else
230                         for (char **alias = cvar->aliases; alias && *alias; alias++)
231                                 if (!strncasecmp(partial, *alias, len) && (cvar->flags & neededflags))
232                                         h++;
233                 
234         return h;
235 }
236
237 /*
238         CVar_CompleteBuildList
239
240         New function for tab-completion system
241         Added by EvilTypeGuy
242         Thanks to Fett erich@heintz.com
243         Thanks to taniwha
244
245 */
246 const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, int neededflags)
247 {
248         const cvar_t *cvar;
249         size_t len = 0;
250         size_t bpos = 0;
251         size_t sizeofbuf = (Cvar_CompleteCountPossible(cvars, partial, neededflags) + 1) * sizeof(const char *);
252         const char **buf;
253
254         len = strlen(partial);
255         buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof(const char *));
256         // Loop through the alias list and print all matches
257         for (cvar = cvars->vars; cvar; cvar = cvar->next)
258                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
259                         buf[bpos++] = cvar->name;
260                 else
261                         for (char **alias = cvar->aliases; alias && *alias; alias++)
262                                 if (!strncasecmp(partial, *alias, len) && (cvar->flags & neededflags))
263                                         buf[bpos++] = *alias;
264                 
265
266         buf[bpos] = NULL;
267         return buf;
268 }
269
270 void Cvar_PrintHelp(cvar_t *cvar, const char *name, qbool full)
271 {
272         // Aliases are purple, cvars are yellow
273         if (strcmp(cvar->name, name))
274                 Con_Printf("^6");
275         else
276                 Con_Printf("^3");
277         Con_Printf("%s^7 is \"%s\" [\"%s\"]", name, ((cvar->flags & CF_PRIVATE) ? "********"/*hunter2*/ : cvar->string), cvar->defstring);
278         if (strcmp(cvar->name, name))
279                 Con_Printf(" (also ^3%s^7)", cvar->name);
280         if (full)
281                 Con_Printf(" %s", cvar->description);
282         Con_Printf("\n");
283 }
284
285 // written by LadyHavoc
286 void Cvar_CompleteCvarPrint(cvar_state_t *cvars, const char *partial, int neededflags)
287 {
288         cvar_t *cvar;
289         size_t len = strlen(partial);
290         // Loop through the command list and print all matches
291         for (cvar = cvars->vars; cvar; cvar = cvar->next)
292                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
293                         Cvar_PrintHelp(cvar, cvar->name, true);
294                 else
295                         for (char **alias = cvar->aliases; alias && *alias; alias++)
296                                 if (!strncasecmp (partial, *alias, len) && (cvar->flags & neededflags))
297                                         Cvar_PrintHelp(cvar, *alias, true);
298
299                 
300 }
301
302 // check if a cvar is held by some progs
303 static qbool Cvar_IsAutoCvar(cvar_t *var)
304 {
305         int i;
306         prvm_prog_t *prog;
307         for (i = 0;i < PRVM_PROG_MAX;i++)
308         {
309                 prog = &prvm_prog_list[i];
310                 if (prog->loaded && var->globaldefindex[i] >= 0)
311                         return true;
312         }
313         return false;
314 }
315
316 // we assume that prog is already set to the target progs
317 static void Cvar_UpdateAutoCvar(cvar_t *var)
318 {
319         int i;
320         int j;
321         const char *s;
322         vec3_t v;
323         prvm_prog_t *prog;
324         for (i = 0;i < PRVM_PROG_MAX;i++)
325         {
326                 prog = &prvm_prog_list[i];
327                 if (prog->loaded && var->globaldefindex[i] >= 0)
328                 {
329                         // MUST BE SYNCED WITH prvm_edict.c PRVM_LoadProgs
330                         switch(prog->globaldefs[var->globaldefindex[i]].type & ~DEF_SAVEGLOBAL)
331                         {
332                         case ev_float:
333                                 PRVM_GLOBALFIELDFLOAT(prog->globaldefs[var->globaldefindex[i]].ofs) = var->value;
334                                 break;
335                         case ev_vector:
336                                 s = var->string;
337                                 VectorClear(v);
338                                 for (j = 0;j < 3;j++)
339                                 {
340                                         while (*s && ISWHITESPACE(*s))
341                                                 s++;
342                                         if (!*s)
343                                                 break;
344                                         v[j] = atof(s);
345                                         while (!ISWHITESPACE(*s))
346                                                 s++;
347                                         if (!*s)
348                                                 break;
349                                 }
350                                 VectorCopy(v, PRVM_GLOBALFIELDVECTOR(prog->globaldefs[var->globaldefindex[i]].ofs));
351                                 break;
352                         case ev_string:
353                                 PRVM_ChangeEngineString(prog, var->globaldefindex_stringno[i], var->string);
354                                 PRVM_GLOBALFIELDSTRING(prog->globaldefs[var->globaldefindex[i]].ofs) = var->globaldefindex_stringno[i];
355                                 break;
356                         }
357                 }
358         }
359 }
360
361 // called after loading a savegame
362 void Cvar_UpdateAllAutoCvars(cvar_state_t *cvars)
363 {
364         cvar_t *var;
365         for (var = cvars->vars ; var ; var = var->next)
366                 Cvar_UpdateAutoCvar(var);
367 }
368
369 void Cvar_Callback(cvar_t *var)
370 {
371         if (var == NULL)
372         {
373                 Con_Print("Cvar_Callback: var == NULL\n");
374                 return;
375         }
376
377         if(var->callback)
378                 var->callback(var);
379 }
380
381 /*
382 ============
383 Cvar_Set
384 ============
385 */
386 extern cvar_t sv_disablenotify;
387 static void Cvar_SetQuick_Internal (cvar_t *var, const char *value)
388 {
389         qbool changed;
390         size_t valuelen;
391
392         changed = strcmp(var->string, value) != 0;
393         // LadyHavoc: don't reallocate when there is no change
394         if (!changed)
395                 return;
396
397         // LadyHavoc: don't reallocate when the buffer is the same size
398         valuelen = strlen(value);
399         if (!var->string || strlen(var->string) != valuelen)
400         {
401                 Z_Free ((char *)var->string);   // free the old value string
402
403                 var->string = (char *)Z_Malloc (valuelen + 1);
404         }
405         memcpy ((char *)var->string, value, valuelen + 1);
406         var->value = atof (var->string);
407         var->integer = (int) var->value;
408         if ((var->flags & CF_NOTIFY) && sv.active && !sv_disablenotify.integer)
409                 SV_BroadcastPrintf("\003^3Server cvar \"%s\" changed to \"%s\"\n", var->name, var->string);
410 #if 0
411         // TODO: add infostring support to the server?
412         if ((var->flags & CF_SERVERINFO) && changed && sv.active)
413         {
414                 InfoString_SetValue(svs.serverinfo, sizeof(svs.serverinfo), var->name, var->string);
415                 if (sv.active)
416                 {
417                         MSG_WriteByte (&sv.reliable_datagram, svc_serverinfostring);
418                         MSG_WriteString (&sv.reliable_datagram, var->name);
419                         MSG_WriteString (&sv.reliable_datagram, var->string);
420                 }
421         }
422 #endif
423         if (var->flags & CF_USERINFO)
424                 CL_SetInfo(var->name, var->string, true, false, false, false);
425
426         Cvar_UpdateAutoCvar(var);
427
428         // Call the function stored in the cvar for bounds checking, cleanup, etc
429         Cvar_Callback(var);
430 }
431
432 void Cvar_SetQuick (cvar_t *var, const char *value)
433 {
434         if (var == NULL)
435         {
436                 Con_Print("Cvar_SetQuick: var == NULL\n");
437                 return;
438         }
439
440         if (developer_extra.integer)
441                 Con_DPrintf("Cvar_SetQuick({\"%s\", \"%s\", %i, \"%s\"}, \"%s\");\n", var->name, var->string, var->flags, var->defstring, value);
442
443         Cvar_SetQuick_Internal(var, value);
444 }
445
446 void Cvar_Set(cvar_state_t *cvars, const char *var_name, const char *value)
447 {
448         cvar_t *var;
449         var = Cvar_FindVar(cvars, var_name, ~0);
450         if (var == NULL)
451         {
452                 Con_Printf("Cvar_Set: variable %s not found\n", var_name);
453                 return;
454         }
455         Cvar_SetQuick(var, value);
456 }
457
458 /*
459 ============
460 Cvar_SetValue
461 ============
462 */
463 void Cvar_SetValueQuick(cvar_t *var, float value)
464 {
465         char val[MAX_INPUTLINE];
466
467         if ((float)((int)value) == value)
468                 dpsnprintf(val, sizeof(val), "%i", (int)value);
469         else
470                 dpsnprintf(val, sizeof(val), "%f", value);
471         Cvar_SetQuick(var, val);
472 }
473
474 void Cvar_SetValue(cvar_state_t *cvars, const char *var_name, float value)
475 {
476         char val[MAX_INPUTLINE];
477
478         if ((float)((int)value) == value)
479                 dpsnprintf(val, sizeof(val), "%i", (int)value);
480         else
481                 dpsnprintf(val, sizeof(val), "%f", value);
482         Cvar_Set(cvars, var_name, val);
483 }
484
485 void Cvar_RegisterCallback(cvar_t *variable, void (*callback)(cvar_t *))
486 {
487         if (variable == NULL)
488         {
489                 Con_Print("Cvar_RegisterCallback: var == NULL\n");
490                 return;
491         }
492         variable->callback = callback;
493 }
494
495 void Cvar_RegisterAlias(cvar_t *variable, const char *alias )
496 {
497         cvar_state_t *cvars = &cvars_all;
498         cvar_hash_t *hash;
499         int hashindex;
500
501         if(!*alias)
502         {
503                 Con_Printf("Cvar_RegisterAlias: invalid alias name\n");
504                 return;
505         }
506
507         // check for overlap with a command
508         if (Cmd_Exists(cmd_local, alias))
509         {
510                 Con_Printf("Cvar_RegisterAlias: %s is a command\n", alias);
511                 return;
512         }
513
514         if(Cvar_FindVar(&cvars_all, alias, 0))
515         {
516                 Con_Printf("Cvar_RegisterAlias: %s is a cvar\n", alias);
517                 return;
518         }
519
520         if(!variable->aliases)
521                 variable->aliases = (char **)Z_Malloc(sizeof(char *) * 2); // For NULL terminator
522         else
523                 variable->aliases = (char **)Mem_Realloc(zonemempool, variable->aliases, sizeof(char *) * (variable->aliases_size + 1));
524         
525         variable->aliases[variable->aliases_size + 1] = NULL;
526         
527         // Add to it
528         variable->aliases[variable->aliases_size] = (char *)Z_Malloc(strlen(alias) + 1);
529         memcpy(variable->aliases[variable->aliases_size], alias, strlen(alias) + 1);
530         variable->aliases_size++;
531
532         // link to head of list in this hash table index
533         hash = (cvar_hash_t *)Z_Malloc(sizeof(cvar_hash_t));
534         hashindex = CRC_Block((const unsigned char *)alias, strlen(alias)) % CVAR_HASHSIZE;
535         hash->next = cvars->hashtable[hashindex];
536         cvars->hashtable[hashindex] = hash;
537         hash->cvar = variable;
538 }
539
540 /*
541 ============
542 Cvar_Link
543
544 Links a variable to the variable list and hashtable
545 ============
546 */
547 static void Cvar_Link(cvar_t *variable, cvar_state_t *cvars)
548 {
549         cvar_t *current, *next;
550         cvar_hash_t *hash;
551         int hashindex;
552         /*
553          * Link the variable in
554          * alphanumerical order
555          */
556         for( current = NULL, next = cvars->vars ; next && strcmp( next->name, variable->name ) < 0 ; current = next, next = next->next )
557                 ;
558         if(current)
559                 current->next = variable;
560         else
561                 cvars->vars = variable;
562         variable->next = next;
563
564         // link to head of list in this hash table index
565         hash = (cvar_hash_t *)Z_Malloc(sizeof(cvar_hash_t));
566         hashindex = CRC_Block((const unsigned char *)variable->name, strlen(variable->name)) % CVAR_HASHSIZE;
567         hash->next = cvars->hashtable[hashindex];
568         hash->cvar = variable;
569         cvars->hashtable[hashindex] = hash;
570 }
571
572 /*
573 ============
574 Cvar_RegisterVariable
575
576 Adds a freestanding variable to the variable list.
577 ============
578 */
579 void Cvar_RegisterVariable (cvar_t *variable)
580 {
581         cvar_state_t *cvars = NULL;
582         cvar_t *current, *cvar;
583         int i;
584
585         switch (variable->flags & (CF_CLIENT | CF_SERVER))
586         {
587         case CF_CLIENT:
588         case CF_SERVER:
589         case CF_CLIENT | CF_SERVER:
590                 cvars = &cvars_all;
591                 break;
592         case 0:
593                 Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with no CF_CLIENT | CF_SERVER flags\n", variable->name, variable->string, variable->flags);
594                 break;
595         default:
596                 Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with weird CF_CLIENT | CF_SERVER flags\n", variable->name, variable->string, variable->flags);
597                 break;
598         }
599
600         if (developer_extra.integer)
601                 Con_DPrintf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
602
603         // first check to see if it has already been defined
604         cvar = Cvar_FindVar(cvars, variable->name, ~0);
605         if (cvar)
606         {
607                 if (cvar->flags & CF_ALLOCATED)
608                 {
609                         if (developer_extra.integer)
610                                 Con_DPrintf("...  replacing existing allocated cvar {\"%s\", \"%s\", %i}\n", cvar->name, cvar->string, cvar->flags);
611                         // fixed variables replace allocated ones
612                         // (because the engine directly accesses fixed variables)
613                         // NOTE: this isn't actually used currently
614                         // (all cvars are registered before config parsing)
615                         variable->flags |= (cvar->flags & ~CF_ALLOCATED);
616                         // cvar->string is now owned by variable instead
617                         variable->string = cvar->string;
618                         variable->defstring = cvar->defstring;
619                         variable->value = atof (variable->string);
620                         variable->integer = (int) variable->value;
621                         // Preserve autocvar status.
622                         memcpy(variable->globaldefindex, cvar->globaldefindex, sizeof(variable->globaldefindex));
623                         memcpy(variable->globaldefindex_stringno, cvar->globaldefindex_stringno, sizeof(variable->globaldefindex_stringno));
624                         // replace cvar with this one...
625                         variable->next = cvar->next;
626                         if (cvars->vars == cvar)
627                         {
628                                 // head of the list is easy to change
629                                 cvars->vars = variable;
630                         }
631                         else
632                         {
633                                 // otherwise find it somewhere in the list
634                                 for (current = cvars->vars;current->next != cvar;current = current->next)
635                                         ;
636                                 current->next = variable;
637                         }
638
639                         // get rid of old allocated cvar
640                         // (but not cvar->string and cvar->defstring, because we kept those)
641                         Z_Free((char *)cvar->name);
642                         Z_Free(cvar);
643                 }
644                 else
645                         Con_DPrintf("Can't register variable %s, already defined\n", variable->name);
646                 return;
647         }
648
649         // check for overlap with a command
650         if (Cmd_Exists(cmd_local, variable->name) || Cmd_Exists(cmd_local, variable->name))
651         {
652                 Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
653                 return;
654         }
655
656         // copy the value off, because future sets will Z_Free it
657         variable->name = (char *)Mem_strdup(zonemempool, variable->name);
658         variable->string = (char *)Mem_strdup(zonemempool, variable->string);
659         variable->defstring = (char *)Mem_strdup(zonemempool, variable->string);
660         variable->value = atof (variable->string);
661         variable->integer = (int) variable->value;
662         variable->aliases = NULL;
663         variable->aliases_size = 0;
664         variable->initstate = NULL;
665
666         // Mark it as not an autocvar.
667         for (i = 0;i < PRVM_PROG_MAX;i++)
668                 variable->globaldefindex[i] = -1;
669
670         Cvar_Link(variable, cvars);
671 }
672
673 /*
674 ============
675 Cvar_Get
676
677 Adds a newly allocated variable to the variable list or sets its value.
678 ============
679 */
680 cvar_t *Cvar_Get(cvar_state_t *cvars, const char *name, const char *value, int flags, const char *newdescription)
681 {
682         cvar_t *cvar;
683         int i;
684
685         if (developer_extra.integer)
686                 Con_DPrintf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
687
688         // first check to see if it has already been defined
689         cvar = Cvar_FindVar(cvars, name, ~0);
690         if (cvar)
691         {
692                 cvar->flags |= flags;
693                 Cvar_SetQuick_Internal (cvar, value);
694                 if(newdescription && (cvar->flags & CF_ALLOCATED))
695                 {
696                         if(cvar->description != cvar_dummy_description)
697                                 Z_Free((char *)cvar->description);
698
699                         if(*newdescription)
700                                 cvar->description = (char *)Mem_strdup(zonemempool, newdescription);
701                         else
702                                 cvar->description = cvar_dummy_description;
703                 }
704                 return cvar;
705         }
706
707         // check for pure evil
708         if (!*name)
709         {
710                 Con_Printf("Cvar_Get: invalid variable name\n");
711                 return NULL;
712         }
713
714         // check for overlap with a command
715         if (Cmd_Exists(cmd_local, name) || Cmd_Exists(cmd_local, name))
716         {
717                 Con_Printf("Cvar_Get: %s is a command\n", name);
718                 return NULL;
719         }
720
721         // allocate a new cvar, cvar name, and cvar string
722         // TODO: factorize the following code with the one at the end of Cvar_RegisterVariable()
723         // FIXME: these never get Z_Free'd
724         cvar = (cvar_t *)Z_Malloc(sizeof(cvar_t));
725         cvar->flags = flags | CF_ALLOCATED;
726         cvar->name = (char *)Mem_strdup(zonemempool, name);
727         cvar->string = (char *)Mem_strdup(zonemempool, value);
728         cvar->defstring = (char *)Mem_strdup(zonemempool, value);
729         cvar->value = atof (cvar->string);
730         cvar->integer = (int) cvar->value;
731         cvar->aliases = NULL;
732         cvar->aliases_size = 0;
733         cvar->initstate = NULL;
734         memset(cvar->aliases, 0, sizeof(char *));
735
736         if(newdescription && *newdescription)
737                 cvar->description = (char *)Mem_strdup(zonemempool, newdescription);
738         else
739                 cvar->description = cvar_dummy_description; // actually checked by VM_cvar_type
740
741         // Mark it as not an autocvar.
742         for (i = 0;i < PRVM_PROG_MAX;i++)
743                 cvar->globaldefindex[i] = -1;
744
745         Cvar_Link(cvar, cvars);
746
747         return cvar;
748 }
749
750 qbool Cvar_Readonly (cvar_t *var, const char *cmd_name)
751 {
752         if (var->flags & CF_READONLY)
753         {
754                 if(cmd_name)
755                         Con_Printf("%s: ",cmd_name);
756                 Con_Printf("%s", var->name);
757                 Con_Printf(" is read-only\n");
758                 return true;
759         }
760         return false;
761 }
762
763 /*
764 ============
765 Cvar_Command
766
767 Handles variable inspection and changing from the console
768 ============
769 */
770 qbool   Cvar_Command (cmd_state_t *cmd)
771 {
772         cvar_state_t    *cvars = cmd->cvars;
773         cvar_t                  *v;
774
775         // check variables
776         v = Cvar_FindVar(cvars, Cmd_Argv(cmd, 0), (cmd->cvars_flagsmask));
777         if (!v)
778                 return false;
779
780         // perform a variable print or set
781         if (Cmd_Argc(cmd) == 1)
782         {
783                 Cvar_PrintHelp(v, Cmd_Argv(cmd, 0), true);
784                 return true;
785         }
786
787         if (developer_extra.integer)
788                 Con_DPrint("Cvar_Command: ");
789
790         if(Cvar_Readonly(v, NULL))
791                 return true;
792
793         Cvar_SetQuick(v, Cmd_Argv(cmd, 1));
794         if (developer_extra.integer)
795                 Con_DPrint("\n");
796         return true;
797 }
798
799 void Cvar_UnlockDefaults(cmd_state_t *cmd)
800 {
801         cvar_state_t *cvars = cmd->cvars;
802         cvar_t *var;
803         // unlock the default values of all cvars
804         for (var = cvars->vars ; var ; var = var->next)
805                 var->flags &= ~CF_DEFAULTSET;
806 }
807
808 void Cvar_LockDefaults_f(cmd_state_t *cmd)
809 {
810         cvar_state_t *cvars = cmd->cvars;
811         cvar_t *var;
812         // lock in the default values of all cvars
813         for (var = cvars->vars ; var ; var = var->next)
814         {
815                 if (!(var->flags & CF_DEFAULTSET))
816                 {
817                         size_t alloclen;
818
819                         //Con_Printf("locking cvar %s (%s -> %s)\n", var->name, var->string, var->defstring);
820                         var->flags |= CF_DEFAULTSET;
821                         Z_Free((char *)var->defstring);
822                         alloclen = strlen(var->string) + 1;
823                         var->defstring = (char *)Z_Malloc(alloclen);
824                         memcpy((char *)var->defstring, var->string, alloclen);
825                 }
826         }
827 }
828
829 void Cvar_SaveInitState(cvar_state_t *cvars)
830 {
831         cvar_t *c;
832         for (c = cvars->vars;c;c = c->next)
833         {
834                 c->initstate = (cvar_t *)Z_Malloc(sizeof(cvar_t));
835                 memcpy(c->initstate, c, sizeof(cvar_t));
836         }
837 }
838
839 void Cvar_RestoreInitState(cvar_state_t *cvars)
840 {
841         int hashindex;
842         cvar_t *c, **cp;
843         cvar_t *c2, **cp2;
844         for (cp = &cvars->vars;(c = *cp);)
845         {
846                 if (c->initstate)
847                 {
848                         // restore this cvar, it existed at init
849                         if (((c->flags ^ c->initstate->flags) & CF_MAXFLAGSVAL)
850                          || strcmp(c->defstring ? c->defstring : "", c->initstate->defstring ? c->initstate->defstring : "")
851                          || strcmp(c->string ? c->string : "", c->initstate->string ? c->initstate->string : ""))
852                         {
853                                 Con_DPrintf("Cvar_RestoreInitState: Restoring cvar \"%s\"\n", c->name);
854                                 if (c->defstring)
855                                         Z_Free((char *)c->defstring);
856                                 c->defstring = Mem_strdup(zonemempool, c->initstate->defstring);
857                                 if (c->string)
858                                         Z_Free((char *)c->string);
859                                 c->string = Mem_strdup(zonemempool, c->initstate->string);
860                         }
861                         c->flags = c->initstate->flags;
862                         c->value = c->initstate->value;
863                         c->integer = c->initstate->integer;
864                         VectorCopy(c->initstate->vector, c->vector);
865                         cp = &c->next;
866                 }
867                 else
868                 {
869                         if (!(c->flags & CF_ALLOCATED))
870                         {
871                                 Con_DPrintf("Cvar_RestoreInitState: Unable to destroy cvar \"%s\", it was registered after init!\n", c->name);
872                                 // In this case, at least reset it to the default.
873                                 if((c->flags & CF_PERSISTENT) == 0)
874                                         Cvar_SetQuick(c, c->defstring);
875                                 cp = &c->next;
876                                 continue;
877                         }
878                         if (Cvar_IsAutoCvar(c))
879                         {
880                                 Con_DPrintf("Cvar_RestoreInitState: Unable to destroy cvar \"%s\", it is an autocvar used by running progs!\n", c->name);
881                                 // In this case, at least reset it to the default.
882                                 if((c->flags & CF_PERSISTENT) == 0)
883                                         Cvar_SetQuick(c, c->defstring);
884                                 cp = &c->next;
885                                 continue;
886                         }
887                         // remove this cvar, it did not exist at init
888                         Con_DPrintf("Cvar_RestoreInitState: Destroying cvar \"%s\"\n", c->name);
889                         // unlink struct from hash
890                         hashindex = CRC_Block((const unsigned char *)c->name, strlen(c->name)) % CVAR_HASHSIZE;
891                         for (cp2 = &cvars->hashtable[hashindex]->cvar;(c2 = *cp2);)
892                         {
893                                 if (c2 == c)
894                                 {
895                                         *cp2 = cvars->hashtable[hashindex]->next->cvar;
896                                         break;
897                                 }
898                                 else
899                                         cp2 = &cvars->hashtable[hashindex]->next->cvar;
900                         }
901                         // unlink struct from main list
902                         *cp = c->next;
903                         // free strings
904                         if (c->defstring)
905                                 Z_Free((char *)c->defstring);
906                         if (c->string)
907                                 Z_Free((char *)c->string);
908                         if (c->description && c->description != cvar_dummy_description)
909                                 Z_Free((char *)c->description);
910                         // free struct
911                         Z_Free(c);
912                 }
913         }
914 }
915
916 void Cvar_ResetToDefaults_All_f(cmd_state_t *cmd)
917 {
918         cvar_state_t *cvars = cmd->cvars;
919         cvar_t *var;
920         // restore the default values of all cvars
921         for (var = cvars->vars ; var ; var = var->next)
922         {
923                 if((var->flags & CF_PERSISTENT) == 0)
924                         Cvar_SetQuick(var, var->defstring);
925         }
926 }
927
928 void Cvar_ResetToDefaults_NoSaveOnly_f(cmd_state_t *cmd)
929 {
930         cvar_state_t *cvars = cmd->cvars;
931         cvar_t *var;
932         // restore the default values of all cvars
933         for (var = cvars->vars ; var ; var = var->next)
934         {
935                 if ((var->flags & (CF_PERSISTENT | CF_ARCHIVE)) == 0)
936                         Cvar_SetQuick(var, var->defstring);
937         }
938 }
939
940
941 void Cvar_ResetToDefaults_SaveOnly_f(cmd_state_t *cmd)
942 {
943         cvar_state_t *cvars = cmd->cvars;
944         cvar_t *var;
945         // restore the default values of all cvars
946         for (var = cvars->vars ; var ; var = var->next)
947         {
948                 if ((var->flags & (CF_PERSISTENT | CF_ARCHIVE)) == CF_ARCHIVE)
949                         Cvar_SetQuick(var, var->defstring);
950         }
951 }
952
953 /*
954 ============
955 Cvar_WriteVariables
956
957 Writes lines containing "set variable value" for all variables
958 with the archive flag set to true.
959 ============
960 */
961 void Cvar_WriteVariables (cvar_state_t *cvars, qfile_t *f)
962 {
963         cvar_t  *var;
964         char buf1[MAX_INPUTLINE], buf2[MAX_INPUTLINE];
965
966         // don't save cvars that match their default value
967         for (var = cvars->vars ; var ; var = var->next) {
968                 if ((var->flags & CF_ARCHIVE) && (strcmp(var->string, var->defstring) || ((var->flags & CF_ALLOCATED) && !(var->flags & CF_DEFAULTSET))))
969                 {
970                         Cmd_QuoteString(buf1, sizeof(buf1), var->name, "\"\\$", false);
971                         Cmd_QuoteString(buf2, sizeof(buf2), var->string, "\"\\$", false);
972                         FS_Printf(f, "%s\"%s\" \"%s\"\n", var->flags & CF_ALLOCATED ? "seta " : "", buf1, buf2);
973                 }
974         }
975 }
976
977 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
978 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
979 /*
980 =========
981 Cvar_List
982 =========
983 */
984 void Cvar_List_f(cmd_state_t *cmd)
985 {
986         cvar_state_t *cvars = cmd->cvars;
987         cvar_t *cvar;
988         const char *partial;
989         int count;
990         qbool ispattern;
991         char vabuf[1024];
992
993         if (Cmd_Argc(cmd) > 1)
994         {
995                 partial = Cmd_Argv(cmd, 1);
996                 ispattern = (strchr(partial, '*') || strchr(partial, '?'));
997                 if(!ispattern)
998                         partial = va(vabuf, sizeof(vabuf), "%s*", partial);
999         }
1000         else
1001         {
1002                 partial = va(vabuf, sizeof(vabuf), "*");
1003                 ispattern = false;
1004         }
1005
1006         count = 0;
1007         for (cvar = cvars->vars; cvar; cvar = cvar->next)
1008         {
1009                 if (matchpattern_with_separator(cvar->name, partial, false, "", false))
1010                 {
1011                         Cvar_PrintHelp(cvar, cvar->name, true);
1012                         count++;
1013                 }
1014                 for (char **alias = cvar->aliases; alias && *alias; alias++)
1015                 {
1016                         if (matchpattern_with_separator(*alias, partial, false, "", false))
1017                         {
1018                                 Cvar_PrintHelp(cvar, *alias, true);
1019                                 count++;
1020                         }
1021                 }
1022         }
1023
1024         if (Cmd_Argc(cmd) > 1)
1025         {
1026                 if(ispattern)
1027                         Con_Printf("%i cvar%s matching \"%s\"\n", count, (count > 1) ? "s" : "", partial);
1028                 else
1029                         Con_Printf("%i cvar%s beginning with \"%s\"\n", count, (count > 1) ? "s" : "", Cmd_Argv(cmd,1));
1030         }
1031         else
1032                 Con_Printf("%i cvar(s)\n", count);
1033 }
1034 // 2000-01-09 CvarList command by Maddes
1035
1036 void Cvar_Set_f(cmd_state_t *cmd)
1037 {
1038         cvar_state_t *cvars = cmd->cvars;
1039         cvar_t *cvar;
1040
1041         // make sure it's the right number of parameters
1042         if (Cmd_Argc(cmd) < 3)
1043         {
1044                 Con_Printf("Set: wrong number of parameters, usage: set <variablename> <value> [<description>]\n");
1045                 return;
1046         }
1047
1048         // check if it's read-only
1049         cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
1050         if (cvar)
1051                 if(Cvar_Readonly(cvar,"Set"))
1052                         return;
1053
1054         if (developer_extra.integer)
1055                 Con_DPrint("Set: ");
1056
1057         // all looks ok, create/modify the cvar
1058         Cvar_Get(cvars, Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), cmd->cvars_flagsmask, Cmd_Argc(cmd) > 3 ? Cmd_Argv(cmd, 3) : NULL);
1059 }
1060
1061 void Cvar_SetA_f(cmd_state_t *cmd)
1062 {
1063         cvar_state_t *cvars = cmd->cvars;
1064         cvar_t *cvar;
1065
1066         // make sure it's the right number of parameters
1067         if (Cmd_Argc(cmd) < 3)
1068         {
1069                 Con_Printf("SetA: wrong number of parameters, usage: seta <variablename> <value> [<description>]\n");
1070                 return;
1071         }
1072
1073         // check if it's read-only
1074         cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
1075         if (cvar)
1076                 if(Cvar_Readonly(cvar,"SetA"))
1077                         return;
1078
1079         if (developer_extra.integer)
1080                 Con_DPrint("SetA: ");
1081
1082         // all looks ok, create/modify the cvar
1083         Cvar_Get(cvars, Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), cmd->cvars_flagsmask | CF_ARCHIVE, Cmd_Argc(cmd) > 3 ? Cmd_Argv(cmd, 3) : NULL);
1084 }
1085
1086 void Cvar_Del_f(cmd_state_t *cmd)
1087 {
1088         cvar_state_t *cvars = cmd->cvars;
1089         int neededflags = ~0;
1090         int i;
1091         cvar_t *parent, **link;
1092         cvar_t *cvar, *prev;
1093
1094         if(Cmd_Argc(cmd) < 2)
1095         {
1096                 Con_Printf("%s: wrong number of parameters, usage: unset <variablename1> [<variablename2> ...]\n", Cmd_Argv(cmd, 0));
1097                 return;
1098         }
1099         for(i = 1; i < Cmd_Argc(cmd); ++i)
1100         {
1101                 cvar = Cvar_FindVarLink(cvars, Cmd_Argv(cmd, i), &parent, &link, &prev, neededflags);
1102
1103                 if(!cvar)
1104                 {
1105                         Con_Printf("%s: %s is not defined\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, i));
1106                         continue;
1107                 }
1108                 if(Cvar_Readonly(cvar, Cmd_Argv(cmd, 0)))
1109                         continue;
1110                 if(!(cvar->flags & CF_ALLOCATED))
1111                 {
1112                         Con_Printf("%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
1113                         continue;
1114                 }
1115                 if(cvar == cvars->vars)
1116                 {
1117                         cvars->vars = cvar->next;
1118                 }
1119                 else
1120                 {
1121                         // in this case, prev must be set, otherwise there has been some inconsistensy
1122                         // elsewhere already... should I still check for prev != NULL?
1123                         prev->next = cvar->next;
1124                 }
1125
1126                 if(parent)
1127                         parent->next = cvar->next;
1128                 else if(link)
1129                         *link = cvar->next;
1130                 if(cvar->description != cvar_dummy_description)
1131                         Z_Free((char *)cvar->description);
1132
1133                 Z_Free((char *)cvar->name);
1134                 Z_Free((char *)cvar->string);
1135                 Z_Free((char *)cvar->defstring);
1136                 Z_Free(cvar);
1137         }
1138 }
1139
1140 #ifdef FILLALLCVARSWITHRUBBISH
1141 void Cvar_FillAll_f(cmd_state_t *cmd)
1142 {
1143         char *buf, *p, *q;
1144         int n, i;
1145         cvar_t *var;
1146         qbool verify;
1147         if(Cmd_Argc(cmd) != 2)
1148         {
1149                 Con_Printf("Usage: %s length to plant rubbish\n", Cmd_Argv(cmd, 0));
1150                 Con_Printf("Usage: %s -length to verify that the rubbish is still there\n", Cmd_Argv(cmd, 0));
1151                 return;
1152         }
1153         n = atoi(Cmd_Argv(cmd, 1));
1154         verify = (n < 0);
1155         if(verify)
1156                 n = -n;
1157         buf = Z_Malloc(n + 1);
1158         buf[n] = 0;
1159         for(var = cvars->vars; var; var = var->next)
1160         {
1161                 for(i = 0, p = buf, q = var->name; i < n; ++i)
1162                 {
1163                         *p++ = *q++;
1164                         if(!*q)
1165                                 q = var->name;
1166                 }
1167                 if(verify && strcmp(var->string, buf))
1168                 {
1169                         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);
1170                 }
1171                 Cvar_SetQuick(var, buf);
1172         }
1173         Z_Free(buf);
1174 }
1175 #endif /* FILLALLCVARSWITHRUBBISH */