src/gras/gs/vars.c

   1 /* gs_vars.c */
   2
   3 #include "gs/gs_private.h"
   4
   5 struct s_gs_var {
   6         struct s_gs_type        *p_type;
   7         void                    *data;
   8 };
   9
  10
  11 struct s_gs_vars {
  12         gras_dict_t             *space;
  13         gras_dynar_t            *stack;
  14         gras_dynar_t            *globals;
  15 };
  16
  17
  18 static
  19 void
  20 _gs_vars_pop(struct s_gs_vars   *p_vars,
  21              const char         *name) {
  22
  23         gras_dynar_t            *p_dynar        = NULL;
  24         struct s_gs_var         *p_var          = NULL;
  25
  26         gras_dict_retrieve(p_vars->space, name, (void **)&p_dynar);
  27         gras_dynar_pop(p_dynar, &p_var);
  28
  29         if (!gras_dynar_length(p_dynar)) {
  30                 gras_dict_remove(p_vars->space, name);
  31                 gras_dynar_free_container(p_dynar);
  32         }
  33
  34         free(p_var);
  35 }
  36
  37 void *
  38 gs_vars_pop(void                 *_p_vars,
  39             const char           *name,
  40             struct s_gs_type    **pp_type) {
  41
  42         struct s_gs_vars        *p_vars         = _p_vars;
  43         gras_dynar_t            *p_dynar        = NULL;
  44         struct s_gs_var         *p_var          = NULL;
  45         void                    *data           = NULL;
  46
  47         gras_dict_retrieve(p_vars->space, name, (void **)&p_dynar);
  48         gras_dynar_pop(p_dynar, &p_var);
  49
  50         if (!gras_dynar_length(p_dynar)) {
  51                 gras_dict_remove(p_vars->space, name);
  52                 gras_dynar_free_container(p_dynar);
  53         }
  54
  55         if (pp_type) {
  56                 *pp_type = p_var->p_type;
  57         }
  58
  59         data    = p_var->data;
  60
  61         free(p_var);
  62
  63         gras_dynar_pop(p_vars->stack, &p_dynar);
  64         {
  65                 int l = gras_dynar_length(p_dynar);
  66
  67                 while (l--) {
  68                         char *_name = NULL;
  69
  70                         gras_dynar_get(p_dynar, l, &_name);
  71                         if (!strcmp(name, _name)) {
  72                                 gras_dynar_remove_at(p_dynar, l, &_name);
  73                                 free(_name);
  74                                 break;
  75                         }
  76                 }
  77         }
  78         gras_dynar_push(p_vars->stack, &p_dynar);
  79
  80
  81         return data;
  82 }
  83
  84 void
  85 gs_vars_push(void               *_p_vars,
  86              struct s_gs_type   *p_type,
  87              const char         *name,
  88              void               *data) {
  89
  90         struct s_gs_vars        *p_vars         = _p_vars;
  91         gras_dynar_t            *p_dynar        = NULL;
  92         struct s_gs_var         *p_var          = NULL;
  93
  94         name = strdup(name);
  95
  96         gras_dict_retrieve(p_vars->space, name, (void **)&p_dynar);
  97
  98         if (!p_dynar) {
  99                 gras_dynar_new(&p_dynar, sizeof (struct s_gs_var *), NULL);
 100                 gras_dict_insert(p_vars->space, name, (void **)p_dynar, NULL);
 101         }
 102
 103         p_var           = calloc(1, sizeof(struct s_gs_var));
 104         p_var->p_type   = p_type;
 105         p_var->data     = data;
 106
 107         gras_dynar_push(p_dynar, &p_var);
 108
 109         gras_dynar_pop(p_vars->stack, &p_dynar);
 110         gras_dynar_push(p_dynar, &name);
 111         gras_dynar_push(p_vars->stack, &p_dynar);
 112 }
 113
 114 void
 115 gs_vars_set(void                *_p_vars,
 116              struct s_gs_type   *p_type,
 117              const char         *name,
 118              void               *data) {
 119
 120         struct s_gs_vars        *p_vars         = _p_vars;
 121         gras_dynar_t            *p_dynar        = NULL;
 122         struct s_gs_var         *p_var          = NULL;
 123
 124         name = strdup(name);
 125         gras_dict_retrieve(p_vars->space, name, (void **)&p_dynar);
 126
 127         if (!p_dynar) {
 128                 gras_dynar_new(&p_dynar, sizeof (struct s_gs_var *), NULL);
 129                 gras_dict_insert(p_vars->space, name, (void **)p_dynar, NULL);
 130
 131                 p_var   = calloc(1, sizeof(struct s_gs_var));
 132                 gras_dynar_push(p_vars->globals, &name);
 133         } else {
 134                 gras_dynar_pop(p_dynar, &p_var);
 135         }
 136
 137         p_var->p_type   = p_type;
 138         p_var->data     = data;
 139
 140         gras_dynar_push(p_dynar, &p_var);
 141 }
 142
 143 void *
 144 gs_vars_get(void                 *_p_vars,
 145             const char           *name,
 146             struct s_gs_type    **pp_type) {
 147
 148         struct s_gs_vars        *p_vars = _p_vars;
 149         gras_dynar_t            *p_dynar        = NULL;
 150         struct s_gs_var         *p_var          = NULL;
 151
 152         gras_dict_retrieve(p_vars->space, name, (void **)&p_dynar);
 153         gras_dynar_pop(p_dynar, &p_var);
 154         gras_dynar_push(p_dynar, &p_var);
 155
 156         if (pp_type) {
 157                 *pp_type = p_var->p_type;
 158         }
 159
 160         return p_var->data;
 161 }
 162
 163 void
 164 gs_vars_enter(void *_p_vars) {
 165
 166         struct s_gs_vars        *p_vars         = _p_vars;
 167         gras_dynar_t            *p_dynar        = NULL;
 168
 169         gras_dynar_new(&p_dynar, sizeof (char *), NULL);
 170         gras_dynar_push(p_vars->stack, &p_dynar);
 171 }
 172
 173
 174 void
 175 gs_vars_leave(void *_p_vars) {
 176         struct s_gs_vars        *p_vars         = _p_vars;
 177         gras_dynar_t            *p_dynar        = NULL;
 178         int                      cursor         =    0;
 179         char                    *name           = NULL;
 180
 181         gras_dynar_pop(p_vars->stack, &p_dynar);
 182
 183         gras_dynar_foreach(p_dynar, cursor, name) {
 184                 _gs_vars_pop(p_vars, name);
 185                 free(name);
 186         }
 187
 188         gras_dynar_free_container(p_dynar);
 189 }
 190
 191
 192 void *
 193 gs_vars_alloc(void) {
 194
 195         struct s_gs_vars        *p_vars = NULL;
 196
 197         p_vars = calloc(1, sizeof (struct s_gs_vars));
 198
 199         gras_dict_new (&p_vars->space);
 200         gras_dynar_new(&p_vars->stack, sizeof (gras_dynar_t *), NULL);
 201
 202         gs_vars_enter(p_vars);
 203
 204         gras_dynar_pop(p_vars->stack, &p_vars->globals);
 205         gras_dynar_push(p_vars->stack, &p_vars->globals);
 206
 207         return p_vars;
 208 }
 209
 210
 211 void
 212 gs_vars_free(void *_p_vars) {
 213
 214         struct s_gs_vars        *p_vars = _p_vars;
 215
 216         gs_vars_leave(p_vars);
 217
 218         gras_dynar_free_container(p_vars->stack);
 219         gras_dict_free(&p_vars->space);
 220
 221         free(p_vars);
 222 }
 223