rcvars.c

   1
   2
   3 #undef _GNU_SOURCE
   4 #define _GNU_SOURCE
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <ctype.h>
   8
   9
  10 #include "defs.h"
  11 #include "rc.h"
  12
  13
  14
  15
  16
  17
  18 static rcvar_t *rcvars;
  19
  20 static int nvars;
  21
  22
  23
  24
  25
  26 void rc_export(rcvar_t *v)
  27 {
  28         const rcvar_t end = RCV_END;
  29
  30         if (!v) return;
  31         nvars++;
  32         rcvars = realloc(rcvars, sizeof (rcvar_t) * (nvars+1));
  33         if (!rcvars)
  34                 die("out of memory adding rcvar %s\n", v->name);
  35         rcvars[nvars-1] = *v;
  36         rcvars[nvars] = end;
  37 }
  38
  39 void rc_exportvars(rcvar_t *vars)
  40 {
  41         while(vars->type)
  42                 rc_export(vars++);
  43 }
  44
  45
  46
  47 int rc_findvar(char *name)
  48 {
  49         int i;
  50         if (!rcvars) return -1;
  51         for (i = 0; rcvars[i].name; i++)
  52                 if (!strcmp(rcvars[i].name, name))
  53                         break;
  54         if (!rcvars[i].name)
  55                 return -1;
  56         return i;
  57 }
  58
  59
  60 int my_atoi(const char *s)
  61 {
  62         int a = 0;
  63         if (*s == '0')
  64         {
  65                 s++;
  66                 if (*s == 'x' || *s == 'X')
  67                 {
  68                         s++;
  69                         while (*s)
  70                         {
  71                                 if (isdigit(*s))
  72                                         a = (a<<4) + *s - '0';
  73                                 else if (strchr("ABCDEF", *s))
  74                                         a = (a<<4) + *s - 'A' + 10;
  75                                 else if (strchr("abcdef", *s))
  76                                         a = (a<<4) + *s - 'a' + 10;
  77                                 else return a;
  78                                 s++;
  79                         }
  80                         return a;
  81                 }
  82                 while (*s)
  83                 {
  84                         if (strchr("01234567", *s))
  85                                 a = (a<<3) + *s - '0';
  86                         else return a;
  87                         s++;
  88                 }
  89                 return a;
  90         }
  91         if (*s == '-')
  92         {
  93                 s++;
  94                 for (;;)
  95                 {
  96                         if (isdigit(*s))
  97                                 a = (a*10) + *s - '0';
  98                         else return -a;
  99                         s++;
 100                 }
 101         }
 102         while (*s)
 103         {
 104                 if (isdigit(*s))
 105                         a = (a*10) + *s - '0';
 106                 else return a;
 107                 s++;
 108         }
 109         return a;
 110 }
 111
 112
 113 /* i - index of variable in rcvars array
 114    c - count of values in v string array
 115    v - the actual values as string array */
 116 int rc_setvar_n(int i, int c, char **v)
 117 {
 118         int j;
 119         int *n;
 120         char **s;
 121
 122         switch (rcvars[i].type)
 123         {
 124         case rcv_int:
 125                 if (c < 1) return -1;
 126                 n = (int *)rcvars[i].mem;
 127                 *n = my_atoi(v[0]);
 128                 return 0;
 129         case rcv_string:
 130                 if (c < 1) return -1;
 131                 s = (char **)rcvars[i].mem;
 132                 if (*s) free(*s);
 133                 *s = strdup(v[0]);
 134                 if (!*s)
 135                         die("out of memory setting rcvar %s\n", rcvars[i].name);
 136                 return 0;
 137         case rcv_vector:
 138                 if (c > rcvars[i].len)
 139                         c = rcvars[i].len;
 140                 for (j = 0; j < c ; j++)
 141                         ((int *)rcvars[i].mem)[j] = my_atoi(v[j]);
 142                 return 0;
 143         case rcv_bool:
 144                 if (c < 1 || atoi(v[0]) || strchr("yYtT", v[0][0]))
 145                         *(int *)rcvars[i].mem = 1;
 146                 else if (strchr("0nNfF", v[0][0]))
 147                         *(int *)rcvars[i].mem = 0;
 148                 else
 149                         return -1;
 150                 return 0;
 151         }
 152         return -1;
 153 }
 154
 155
 156 int rc_setvar(char *name, int c, char **v)
 157 {
 158         int i;
 159
 160         i = rc_findvar(name);
 161         if (i < 0) return i;
 162
 163         return rc_setvar_n(i, c, v);
 164 }
 165
 166
 167 void *rc_getmem_n(int i)
 168 {
 169         return rcvars[i].mem;
 170 }
 171
 172
 173 void *rc_getmem(char *name)
 174 {
 175         int i;
 176         i = rc_findvar(name);
 177         if (i < 0) return NULL;
 178         return rcvars[i].mem;
 179 }
 180
 181 int rc_getint_n(int i)
 182 {
 183         if (i < 0) return 0;
 184         switch (rcvars[i].type)
 185         {
 186         case rcv_int:
 187         case rcv_bool:
 188                 return *(int *)rcvars[i].mem;
 189         }
 190         return 0;
 191 }
 192
 193 int *rc_getvec_n(int i)
 194 {
 195         if (i < 0) return NULL;
 196         switch (rcvars[i].type)
 197         {
 198         case rcv_int:
 199         case rcv_bool:
 200         case rcv_vector:
 201                 return (int *)rcvars[i].mem;
 202         }
 203         return NULL;
 204 }
 205
 206 char *rc_getstr_n(int i)
 207 {
 208         if (i < 0) return 0;
 209         switch (rcvars[i].type)
 210         {
 211         case rcv_string:
 212                 return *(char **)rcvars[i].mem;
 213         }
 214         return 0;
 215 }
 216
 217 int rc_getint(char *name)
 218 {
 219         return rc_getint_n(rc_findvar(name));
 220 }
 221
 222 int *rc_getvec(char *name)
 223 {
 224         return rc_getvec_n(rc_findvar(name));
 225 }
 226
 227 char *rc_getstr(char *name)
 228 {
 229         return rc_getstr_n(rc_findvar(name));
 230 }
 231
 232 const char *rc_type_to_string(rcvtype_t type) {
 233         switch (type) {
 234         case rcv_int: return "int";
 235         case rcv_string: return "str";
 236         case rcv_vector: return "vec";
 237         case rcv_bool: return "bool";
 238         default: return "unknown";
 239         }
 240 }
 241
 242
 243
 244
 245