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