main/cvar.c

   1 /* Console variables */
   2
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include <conf.h>
   6 #endif
   7
   8 #include <stdlib.h>
   9 #include <float.h>
  10
  11 #include "console.h"
  12 #include "error.h"
  13 #include "strutil.h"
  14 #include "u_mem.h"
  15 #include "hash.h"
  16
  17
  18 #define CVAR_MAX_LENGTH 1024
  19 #define CVAR_MAX_CVARS  1024
  20
  21 /* The list of cvars */
  22 hashtable cvar_hash;
  23 cvar_t *cvar_list[CVAR_MAX_CVARS];
  24 int Num_cvars;
  25
  26
  27 void cvar_free(void)
  28 {
  29         while (Num_cvars--)
  30                 d_free(cvar_list[Num_cvars]->string);
  31
  32         hashtable_free(&cvar_hash);
  33 }
  34
  35
  36 void cvar_cmd_set(int argc, char **argv)
  37 {
  38         char buf[CVAR_MAX_LENGTH];
  39         int ret, i;
  40
  41         if (argc == 2) {
  42                 cvar_t *ptr;
  43
  44                 if ((ptr = cvar_find(argv[1])))
  45                         con_printf(CON_NORMAL, "%s: %s\n", ptr->name, ptr->string);
  46                 else
  47                         con_printf(CON_NORMAL, "set: variable %s not found\n", argv[1]);
  48                 return;
  49         }
  50
  51         if (argc == 1) {
  52                 for (i = 0; i < Num_cvars; i++)
  53                         con_printf(CON_NORMAL, "%s: %s\n", cvar_list[i]->name, cvar_list[i]->string);
  54                 return;
  55         }
  56
  57         ret = snprintf(buf, sizeof(buf), "%s", argv[2]);
  58         if (ret >= CVAR_MAX_LENGTH) {
  59                 con_printf(CON_CRITICAL, "set: value too long (max %d characters)\n", CVAR_MAX_LENGTH);
  60                 return;
  61         }
  62
  63         for (i = 3; i < argc; i++) {
  64                 ret = snprintf(buf, CVAR_MAX_LENGTH, "%s %s", buf, argv[i]);
  65                 if (ret >= CVAR_MAX_LENGTH) {
  66                         con_printf(CON_CRITICAL, "set: value too long (max %d characters)\n", CVAR_MAX_LENGTH);
  67                         return;
  68                 }
  69         }
  70         cvar_set(argv[1], buf);
  71 }
  72
  73
  74 void cvar_init(void)
  75 {
  76         hashtable_init( &cvar_hash, CVAR_MAX_CVARS );
  77
  78         cmd_addcommand("set", cvar_cmd_set, "set <name> <value>\n"  "    set variable <name> equal to <value>\n"
  79                                             "set <name>\n"          "    show value of <name>\n"
  80                                             "set\n"                 "    show value of all variables");
  81
  82         atexit(cvar_free);
  83 }
  84
  85
  86 cvar_t *cvar_find(char *cvar_name)
  87 {
  88         int i;
  89
  90         i = hashtable_search( &cvar_hash, cvar_name );
  91
  92         if ( i < 0 )
  93                 return NULL;
  94
  95         return cvar_list[i];
  96 }
  97
  98
  99 const char *cvar_complete(char *text)
 100 {
 101         int i;
 102         size_t len = strlen(text);
 103
 104         if (!len)
 105                 return NULL;
 106
 107         for (i = 0; i < Num_cvars; i++)
 108                 if (!strnicmp(text, cvar_list[i]->name, len))
 109                         return cvar_list[i]->name;
 110
 111         return NULL;
 112 }
 113
 114
 115 /* Register a cvar */
 116 void cvar_registervariable(cvar_t *cvar)
 117 {
 118         char *stringval;
 119         int i;
 120
 121         Assert(cvar != NULL);
 122
 123         stringval = cvar->string;
 124
 125         cvar->string = d_strdup(stringval);
 126         cvar->value = fl2f(strtod(cvar->string, NULL));
 127         cvar->intval = (int)strtol(cvar->string, NULL, 10);
 128
 129         /* insert at end of list */
 130         for (i = 0; i < Num_cvars; i++)
 131                 Assert(stricmp(cvar->name, cvar_list[i]->name));
 132         hashtable_insert(&cvar_hash, cvar->name, Num_cvars);
 133         cvar_list[Num_cvars++] = cvar;
 134 }
 135
 136
 137 /* Set a CVar's value */
 138 void cvar_set_cvar(cvar_t *cvar, char *value)
 139 {
 140         if (!cvar)
 141                 return;
 142
 143         d_free(cvar->string);
 144         cvar->string = d_strdup(value);
 145         cvar->value = fl2f(strtod(cvar->string, NULL));
 146         cvar->intval = (int)strtol(cvar->string, NULL, 10);
 147         con_printf(CON_VERBOSE, "%s: %s\n", cvar->name, cvar->string);
 148 }
 149
 150
 151 void cvar_set_cvarf(cvar_t *cvar, const char *fmt, ...)
 152 {
 153         va_list arglist;
 154         char buf[CVAR_MAX_LENGTH];
 155         int n;
 156
 157         va_start (arglist, fmt);
 158         n = vsnprintf(buf, sizeof(buf), fmt, arglist);
 159         va_end (arglist);
 160
 161         Assert(!(n < 0 || n > CVAR_MAX_LENGTH));
 162
 163         cvar_set_cvar(cvar, buf);
 164 }
 165
 166
 167 void cvar_set(char *cvar_name, char *value)
 168 {
 169         cvar_t *cvar;
 170
 171         cvar = cvar_find(cvar_name);
 172         if (!cvar) {
 173                 Int3();
 174                 con_printf(CON_NORMAL, "cvar %s not found\n", cvar_name);
 175                 return;
 176         }
 177
 178         cvar_set_cvar(cvar, value);
 179 }
 180
 181
 182 /* Write archive cvars to file */
 183 void cvar_write(CFILE *file)
 184 {
 185         int i;
 186
 187         for (i = 0; i < Num_cvars; i++)
 188                 if (cvar_list[i]->archive)
 189                         PHYSFSX_printf(file, "%s=%s\n", cvar_list[i]->name, cvar_list[i]->string);
 190 }