|
5 | 5 | // |
6 | 6 | // Copyright(C) 2020 Chris Warren-Smith |
7 | 7 |
|
8 | | -#include <string.h> |
9 | | -#include <stdio.h> |
| 8 | +#include <cstring> |
| 9 | +#include <cstdio> |
| 10 | +#include <cstdlib> |
| 11 | +#include <cassert> |
10 | 12 |
|
11 | 13 | #include "config.h" |
12 | 14 | #include "param.h" |
| 15 | +#include "hashmap.h" |
13 | 16 | #include "var_map.h" |
| 17 | +#include "var.h" |
| 18 | + |
| 19 | +float get_num(var_p_t var) { |
| 20 | + float result; |
| 21 | + switch (var->type) { |
| 22 | + case V_INT: |
| 23 | + result = var->v.i; |
| 24 | + break; |
| 25 | + case V_NUM: |
| 26 | + result = var->v.n; |
| 27 | + break; |
| 28 | + default: |
| 29 | + result = 0.0; |
| 30 | + break; |
| 31 | + } |
| 32 | + return result; |
| 33 | +} |
| 34 | + |
| 35 | +float get_map_num(var_p_t map, const char *name) { |
| 36 | + var_p_t var = map_get(map, name); |
| 37 | + return var != nullptr ? get_num(var) : 0; |
| 38 | +} |
| 39 | + |
| 40 | +float get_array_elem_num(var_p_t array, int index) { |
| 41 | + float result; |
| 42 | + int size = v_asize(array); |
| 43 | + if (index >= 0 && index < size) { |
| 44 | + result = get_num(v_elem(array, index)); |
| 45 | + } else { |
| 46 | + result = 0.0; |
| 47 | + } |
| 48 | + return result; |
| 49 | +} |
| 50 | + |
| 51 | +bool get_bool(var_p_t var) { |
| 52 | + bool result; |
| 53 | + switch (var->type) { |
| 54 | + case V_INT: |
| 55 | + result = (var->v.i != 0); |
| 56 | + break; |
| 57 | + case V_NUM: |
| 58 | + result = (var->v.n != 0); |
| 59 | + break; |
| 60 | + case V_STR: |
| 61 | + result = (strncasecmp(var->v.p.ptr, "true", 4)); |
| 62 | + break; |
| 63 | + default: |
| 64 | + result = false; |
| 65 | + break; |
| 66 | + } |
| 67 | + return result; |
| 68 | +} |
| 69 | + |
| 70 | +int get_int(var_t *v) { |
| 71 | + int result; |
| 72 | + switch (v ? v->type : -1) { |
| 73 | + case V_INT: |
| 74 | + result = v->v.i; |
| 75 | + break; |
| 76 | + case V_NUM: |
| 77 | + result = v->v.n; |
| 78 | + break; |
| 79 | + default: |
| 80 | + result = 0; |
| 81 | + break; |
| 82 | + } |
| 83 | + return result; |
| 84 | +} |
| 85 | + |
| 86 | +void v_init(var_t *v) { |
| 87 | + v->type = V_INT; |
| 88 | + v->const_flag = 0; |
| 89 | + v->v.i = 0; |
| 90 | +} |
| 91 | + |
| 92 | +uint32_t v_get_capacity(uint32_t size) { |
| 93 | + return size + (size / 2) + 1; |
| 94 | +} |
| 95 | + |
| 96 | +void v_alloc_capacity(var_t *var, uint32_t size) { |
| 97 | + uint32_t capacity = v_get_capacity(size); |
| 98 | + v_capacity(var) = capacity; |
| 99 | + v_asize(var) = size; |
| 100 | + v_data(var) = (var_t *)malloc(sizeof(var_t) * capacity); |
| 101 | + if (v_data(var)) { |
| 102 | + for (uint32_t i = 0; i < capacity; i++) { |
| 103 | + var_t *e = v_elem(var, i); |
| 104 | + e->pooled = 0; |
| 105 | + v_init(e); |
| 106 | + } |
| 107 | + } |
| 108 | +} |
| 109 | + |
| 110 | +var_t *v_new() { |
| 111 | + var_t *result = (var_t *)malloc(sizeof(var_t)); |
| 112 | + result->pooled = 0; |
| 113 | + v_init(result); |
| 114 | + return result; |
| 115 | +} |
| 116 | + |
| 117 | +void v_setint(var_t *var, var_int_t i) { |
| 118 | + assert(var->type == V_INT); |
| 119 | + var->type = V_INT; |
| 120 | + var->v.i = i; |
| 121 | +} |
| 122 | + |
| 123 | +void v_setreal(var_t *var, var_num_t n) { |
| 124 | + assert(var->type == V_INT); |
| 125 | + var->type = V_NUM; |
| 126 | + var->v.n = n; |
| 127 | +} |
| 128 | + |
| 129 | +void v_setstr(var_t *var, const char *str) { |
| 130 | + assert(var->type == V_INT); |
| 131 | + |
| 132 | + int length = strlen(str == nullptr ? 0 : str); |
| 133 | + var->type = V_STR; |
| 134 | + var->v.p.ptr = (char *)malloc(length + 1); |
| 135 | + var->v.p.ptr[0] = '\0'; |
| 136 | + var->v.p.length = length + 1; |
| 137 | + var->v.p.owner = 1; |
| 138 | + strcpy(var->v.p.ptr, str); |
| 139 | +} |
| 140 | + |
| 141 | +int v_strlen(const var_t *v) { |
| 142 | + int result; |
| 143 | + if (v->type == V_STR) { |
| 144 | + result = v->v.p.length; |
| 145 | + if (result && v->v.p.ptr[result - 1] == '\0') { |
| 146 | + result--; |
| 147 | + } |
| 148 | + } else { |
| 149 | + result = 0; |
| 150 | + } |
| 151 | + return result; |
| 152 | +} |
| 153 | + |
| 154 | +void v_new_array(var_t *var, uint32_t size) { |
| 155 | + var->type = V_ARRAY; |
| 156 | + v_alloc_capacity(var, size); |
| 157 | +} |
| 158 | + |
| 159 | +void v_toarray1(var_t *v, uint32_t r) { |
| 160 | + assert(v->type == V_INT); |
| 161 | + |
| 162 | + v_new_array(v, r); |
| 163 | + v_maxdim(v) = 1; |
| 164 | + v_lbound(v, 0) = 0; |
| 165 | + v_ubound(v, 0) = r - 1; |
| 166 | +} |
| 167 | + |
| 168 | +void v_tomatrix(var_t *v, int r, int c) { |
| 169 | + assert(v->type == V_INT); |
| 170 | + |
| 171 | + v_new_array(v, r * c); |
| 172 | + v_maxdim(v) = 2; |
| 173 | + v_lbound(v, 0) = v_lbound(v, 1) = 0; |
| 174 | + v_ubound(v, 0) = r - 1; |
| 175 | + v_ubound(v, 1) = c - 1; |
| 176 | +} |
| 177 | + |
| 178 | +var_p_t map_add_var(var_p_t base, const char *name, int value) { |
| 179 | + var_p_t key = v_new(); |
| 180 | + v_setstr(key, name); |
| 181 | + var_p_t var = hashmap_putv(base, key); |
| 182 | + v_setint(var, value); |
| 183 | + return var; |
| 184 | +} |
| 185 | + |
| 186 | +var_p_t map_get(var_p_t base, const char *name) { |
| 187 | + var_p_t result; |
| 188 | + if (base != NULL && base->type == V_MAP) { |
| 189 | + result = hashmap_get(base, name); |
| 190 | + } else { |
| 191 | + result = NULL; |
| 192 | + } |
| 193 | + return result; |
| 194 | +} |
| 195 | + |
| 196 | +void map_init(var_p_t map) { |
| 197 | + v_init(map); |
| 198 | + hashmap_create(map, 0); |
| 199 | +} |
| 200 | + |
| 201 | +int map_get_bool(var_p_t base, const char *name) { |
| 202 | + var_p_t var = map_get(base, name); |
| 203 | + return var != nullptr ? get_bool(var) : 0; |
| 204 | +} |
| 205 | + |
| 206 | +void map_set_int(var_p_t base, const char *name, var_int_t n) { |
| 207 | + var_p_t var = map_get(base, name); |
| 208 | + if (var != nullptr) { |
| 209 | + v_setint(var, n); |
| 210 | + } |
| 211 | +} |
| 212 | + |
| 213 | +int map_get_int(var_p_t base, const char *name, int def) { |
| 214 | + var_p_t var = map_get(base, name); |
| 215 | + return var != nullptr ? get_int(var) : def; |
| 216 | +} |
14 | 217 |
|
15 | 218 | int is_param_array(int argc, slib_par_t *params, int n) { |
16 | 219 | int result; |
@@ -160,34 +363,3 @@ const char *get_param_str_field(int argc, slib_par_t *params, int n, const char |
160 | 363 | return result; |
161 | 364 | } |
162 | 365 |
|
163 | | -float get_num(var_p_t var) { |
164 | | - float result; |
165 | | - switch (var->type) { |
166 | | - case V_INT: |
167 | | - result = var->v.i; |
168 | | - break; |
169 | | - case V_NUM: |
170 | | - result = var->v.n; |
171 | | - break; |
172 | | - default: |
173 | | - result = 0.0; |
174 | | - break; |
175 | | - } |
176 | | - return result; |
177 | | -} |
178 | | - |
179 | | -float get_map_num(var_p_t map, const char *name) { |
180 | | - var_p_t var = map_get(map, name); |
181 | | - return var != nullptr ? get_num(var) : 0; |
182 | | -} |
183 | | - |
184 | | -float get_array_elem_num(var_p_t array, int index) { |
185 | | - float result; |
186 | | - int size = v_asize(array); |
187 | | - if (index >= 0 && index < size) { |
188 | | - result = get_num(v_elem(array, index)); |
189 | | - } else { |
190 | | - result = 0.0; |
191 | | - } |
192 | | - return result; |
193 | | -} |
|
0 commit comments