1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <math.h>
4 #include <ctype.h> // for tolower(), toupper()
5 #include "lib/mlr_globals.h"
6 #include "lib/mlrutil.h"
7 #include "lib/mlrregex.h"
8 #include "lib/mtrand.h"
9 #include "mapping/mapper.h"
10 #include "dsl/context_flags.h"
11 #include "dsl/rval_evaluators.h"
12
13 // ----------------------------------------------------------------
14 typedef struct _rval_evaluator_variadic_state_t {
15 mv_variadic_func_t* pfunc;
16 rval_evaluator_t** pargs;
17 mv_t* pmvs;
18 int nargs;
19 } rval_evaluator_variadic_state_t;
20
rval_evaluator_variadic_func(void * pvstate,variables_t * pvars)21 static mv_t rval_evaluator_variadic_func(void* pvstate, variables_t* pvars) {
22 rval_evaluator_variadic_state_t* pstate = pvstate;
23 int nargs = pstate->nargs;
24
25 for (int i = 0; i < nargs; i++) {
26 rval_evaluator_t* parg = pstate->pargs[i];
27 mv_t* pmv = &pstate->pmvs[i];
28 *pmv = parg->pprocess_func(parg->pvstate, pvars);
29 }
30
31 return pstate->pfunc(pstate->pmvs, nargs);
32 }
33
rval_evaluator_variadic_free(rval_evaluator_t * pevaluator)34 static void rval_evaluator_variadic_free(rval_evaluator_t* pevaluator) {
35 rval_evaluator_variadic_state_t* pstate = pevaluator->pvstate;
36
37 for (int i = 0; i < pstate->nargs; i++)
38 pstate->pargs[i]->pfree_func(pstate->pargs[i]);
39 free(pstate->pargs);
40 // contents already mv_freed by evaluator chains at process time
41 free(pstate->pmvs);
42
43 free(pstate);
44
45 free(pevaluator);
46 }
47
rval_evaluator_alloc_from_variadic_func(mv_variadic_func_t * pfunc,rval_evaluator_t ** pargs,int nargs)48 rval_evaluator_t* rval_evaluator_alloc_from_variadic_func(mv_variadic_func_t* pfunc, rval_evaluator_t** pargs, int nargs) {
49 rval_evaluator_variadic_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_variadic_state_t));
50 pstate->pfunc = pfunc;
51 pstate->pargs = pargs;
52 pstate->nargs = nargs;
53 pstate->pmvs = mlr_malloc_or_die(nargs * sizeof(mv_t));
54
55 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
56 pevaluator->pvstate = pstate;
57 pevaluator->pprocess_func = rval_evaluator_variadic_func;
58 pevaluator->pfree_func = rval_evaluator_variadic_free;
59
60 return pevaluator;
61 }
62
63 // ----------------------------------------------------------------
64 typedef struct _rval_evaluator_b_b_state_t {
65 mv_unary_func_t* pfunc;
66 rval_evaluator_t* parg1;
67 } rval_evaluator_b_b_state_t;
68
rval_evaluator_b_b_func(void * pvstate,variables_t * pvars)69 static mv_t rval_evaluator_b_b_func(void* pvstate, variables_t* pvars) {
70 rval_evaluator_b_b_state_t* pstate = pvstate;
71 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
72
73 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
74 if (val1.type != MT_BOOLEAN)
75 return mv_error();
76
77 return pstate->pfunc(&val1);
78 }
rval_evaluator_b_b_free(rval_evaluator_t * pevaluator)79 static void rval_evaluator_b_b_free(rval_evaluator_t* pevaluator) {
80 rval_evaluator_b_b_state_t* pstate = pevaluator->pvstate;
81 pstate->parg1->pfree_func(pstate->parg1);
82 free(pstate);
83 free(pevaluator);
84 }
85
rval_evaluator_alloc_from_b_b_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)86 rval_evaluator_t* rval_evaluator_alloc_from_b_b_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
87 rval_evaluator_b_b_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_b_b_state_t));
88 pstate->pfunc = pfunc;
89 pstate->parg1 = parg1;
90
91 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
92 pevaluator->pvstate = pstate;
93 pevaluator->pprocess_func = rval_evaluator_b_b_func;
94 pevaluator->pfree_func = rval_evaluator_b_b_free;
95
96 return pevaluator;
97 }
98
99 // ----------------------------------------------------------------
100 typedef struct _rval_evaluator_b_bb_state_t {
101 rval_evaluator_t* parg1;
102 rval_evaluator_t* parg2;
103 } rval_evaluator_b_bb_state_t;
104
105 // This is different from most of the lrec-evaluator functions in that it does short-circuiting: since is logical AND,
106 // the second argument is not evaluated if the first argument is false.
rval_evaluator_b_bb_and_func(void * pvstate,variables_t * pvars)107 static mv_t rval_evaluator_b_bb_and_func(void* pvstate, variables_t* pvars) {
108 rval_evaluator_b_bb_state_t* pstate = pvstate;
109
110 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
111 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
112 if (val1.type == MT_BOOLEAN) {
113 if (val1.u.boolv == FALSE)
114 return val1;
115 } else if (val1.type != MT_ABSENT) {
116 return mv_error();
117 }
118
119 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
120 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
121 if (val2.type == MT_BOOLEAN) {
122 return val2;
123 } else if (val2.type == MT_ABSENT) {
124 return val1;
125 } else {
126 return mv_error();
127 }
128 }
129
130 // This is different from most of the lrec-evaluator functions in that it does short-circuiting: since is logical OR,
131 // the second argument is not evaluated if the first argument is true.
rval_evaluator_b_bb_or_func(void * pvstate,variables_t * pvars)132 static mv_t rval_evaluator_b_bb_or_func(void* pvstate, variables_t* pvars) {
133 rval_evaluator_b_bb_state_t* pstate = pvstate;
134
135 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
136 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
137 if (val1.type == MT_BOOLEAN) {
138 if (val1.u.boolv == TRUE)
139 return val1;
140 } else if (val1.type != MT_ABSENT) {
141 return mv_error();
142 }
143
144 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
145 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
146 if (val2.type == MT_BOOLEAN) {
147 return val2;
148 } else if (val2.type == MT_ABSENT) {
149 return val1;
150 } else {
151 return mv_error();
152 }
153 }
154
rval_evaluator_b_bb_xor_func(void * pvstate,variables_t * pvars)155 static mv_t rval_evaluator_b_bb_xor_func(void* pvstate, variables_t* pvars) {
156 rval_evaluator_b_bb_state_t* pstate = pvstate;
157
158 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
159 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val1);
160 if (val1.type != MT_BOOLEAN && val1.type != MT_ABSENT) {
161 return mv_error();
162 }
163
164 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
165 EMPTY_OR_ERROR_OUT_FOR_NUMBERS(val2);
166 if (val2.type == MT_BOOLEAN) {
167 if (val1.type == MT_BOOLEAN)
168 return mv_from_bool(val1.u.boolv ^ val2.u.boolv);
169 else
170 return val2;
171 } else if (val2.type == MT_ABSENT) {
172 return val1;
173 } else {
174 return mv_error();
175 }
176 }
177
rval_evaluator_b_bb_free(rval_evaluator_t * pevaluator)178 static void rval_evaluator_b_bb_free(rval_evaluator_t* pevaluator) {
179 rval_evaluator_b_bb_state_t* pstate = pevaluator->pvstate;
180 pstate->parg1->pfree_func(pstate->parg1);
181 pstate->parg2->pfree_func(pstate->parg2);
182 free(pstate);
183 free(pevaluator);
184 }
185
rval_evaluator_alloc_from_b_bb_and_func(rval_evaluator_t * parg1,rval_evaluator_t * parg2)186 rval_evaluator_t* rval_evaluator_alloc_from_b_bb_and_func(rval_evaluator_t* parg1, rval_evaluator_t* parg2) {
187 rval_evaluator_b_bb_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_b_bb_state_t));
188 pstate->parg1 = parg1;
189 pstate->parg2 = parg2;
190
191 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
192 pevaluator->pvstate = pstate;
193 pevaluator->pprocess_func = rval_evaluator_b_bb_and_func;
194 pevaluator->pfree_func = rval_evaluator_b_bb_free;
195
196 return pevaluator;
197 }
198
rval_evaluator_alloc_from_b_bb_or_func(rval_evaluator_t * parg1,rval_evaluator_t * parg2)199 rval_evaluator_t* rval_evaluator_alloc_from_b_bb_or_func(rval_evaluator_t* parg1, rval_evaluator_t* parg2) {
200 rval_evaluator_b_bb_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_b_bb_state_t));
201 pstate->parg1 = parg1;
202 pstate->parg2 = parg2;
203
204 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
205 pevaluator->pvstate = pstate;
206 pevaluator->pprocess_func = rval_evaluator_b_bb_or_func;
207 pevaluator->pfree_func = rval_evaluator_b_bb_free;
208
209 return pevaluator;
210 }
211
rval_evaluator_alloc_from_b_bb_xor_func(rval_evaluator_t * parg1,rval_evaluator_t * parg2)212 rval_evaluator_t* rval_evaluator_alloc_from_b_bb_xor_func(rval_evaluator_t* parg1, rval_evaluator_t* parg2) {
213 rval_evaluator_b_bb_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_b_bb_state_t));
214 pstate->parg1 = parg1;
215 pstate->parg2 = parg2;
216
217 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
218 pevaluator->pvstate = pstate;
219 pevaluator->pprocess_func = rval_evaluator_b_bb_xor_func;
220 pevaluator->pfree_func = rval_evaluator_b_bb_free;
221
222 return pevaluator;
223 }
224
225 // ----------------------------------------------------------------
226 typedef struct _rval_evaluator_x_z_state_t {
227 mv_zary_func_t* pfunc;
228 } rval_evaluator_x_z_state_t;
229
rval_evaluator_x_z_func(void * pvstate,variables_t * pvars)230 static mv_t rval_evaluator_x_z_func(void* pvstate, variables_t* pvars) {
231 rval_evaluator_x_z_state_t* pstate = pvstate;
232 return pstate->pfunc();
233 }
rval_evaluator_x_z_free(rval_evaluator_t * pevaluator)234 static void rval_evaluator_x_z_free(rval_evaluator_t* pevaluator) {
235 free(pevaluator);
236 }
237
rval_evaluator_alloc_from_x_z_func(mv_zary_func_t * pfunc)238 rval_evaluator_t* rval_evaluator_alloc_from_x_z_func(mv_zary_func_t* pfunc) {
239 rval_evaluator_x_z_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_z_state_t));
240 pstate->pfunc = pfunc;
241
242 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
243 pevaluator->pvstate = pstate;
244 pevaluator->pprocess_func = rval_evaluator_x_z_func;
245 pevaluator->pfree_func = rval_evaluator_x_z_free;
246
247 return pevaluator;
248 }
249
250 // ----------------------------------------------------------------
251 typedef struct _rval_evaluator_f_f_state_t {
252 mv_unary_func_t* pfunc;
253 rval_evaluator_t* parg1;
254 } rval_evaluator_f_f_state_t;
255
rval_evaluator_f_f_func(void * pvstate,variables_t * pvars)256 static mv_t rval_evaluator_f_f_func(void* pvstate, variables_t* pvars) {
257 rval_evaluator_f_f_state_t* pstate = pvstate;
258 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
259
260 mv_set_float_nullable(&val1);
261 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
262 if (val1.type != MT_FLOAT)
263 return mv_error();
264
265 return pstate->pfunc(&val1);
266 }
rval_evaluator_f_f_free(rval_evaluator_t * pevaluator)267 static void rval_evaluator_f_f_free(rval_evaluator_t* pevaluator) {
268 rval_evaluator_f_f_state_t* pstate = pevaluator->pvstate;
269 pstate->parg1->pfree_func(pstate->parg1);
270 free(pstate);
271 free(pevaluator);
272 }
273
rval_evaluator_alloc_from_f_f_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)274 rval_evaluator_t* rval_evaluator_alloc_from_f_f_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
275 rval_evaluator_f_f_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_f_f_state_t));
276 pstate->pfunc = pfunc;
277 pstate->parg1 = parg1;
278
279 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
280 pevaluator->pvstate = pstate;
281 pevaluator->pprocess_func = rval_evaluator_f_f_func;
282 pevaluator->pfree_func = rval_evaluator_f_f_free;
283
284 return pevaluator;
285 }
286
287 // ----------------------------------------------------------------
288 typedef struct _rval_evaluator_x_n_state_t {
289 mv_unary_func_t* pfunc;
290 rval_evaluator_t* parg1;
291 } rval_evaluator_x_n_state_t;
292
rval_evaluator_x_n_func(void * pvstate,variables_t * pvars)293 static mv_t rval_evaluator_x_n_func(void* pvstate, variables_t* pvars) {
294 rval_evaluator_x_n_state_t* pstate = pvstate;
295
296 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
297 mv_set_number_nullable(&val1);
298 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
299
300 return pstate->pfunc(&val1);
301 }
rval_evaluator_x_n_free(rval_evaluator_t * pevaluator)302 static void rval_evaluator_x_n_free(rval_evaluator_t* pevaluator) {
303 rval_evaluator_x_n_state_t* pstate = pevaluator->pvstate;
304 pstate->parg1->pfree_func(pstate->parg1);
305 free(pstate);
306 free(pevaluator);
307 }
308
rval_evaluator_alloc_from_x_n_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)309 rval_evaluator_t* rval_evaluator_alloc_from_x_n_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
310 rval_evaluator_x_n_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_n_state_t));
311 pstate->pfunc = pfunc;
312 pstate->parg1 = parg1;
313
314 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
315 pevaluator->pvstate = pstate;
316 pevaluator->pprocess_func = rval_evaluator_x_n_func;
317 pevaluator->pfree_func = rval_evaluator_x_n_free;
318
319 return pevaluator;
320 }
321
322 // ----------------------------------------------------------------
323 typedef struct _rval_evaluator_i_i_state_t {
324 mv_unary_func_t* pfunc;
325 rval_evaluator_t* parg1;
326 } rval_evaluator_i_i_state_t;
327
rval_evaluator_i_i_func(void * pvstate,variables_t * pvars)328 static mv_t rval_evaluator_i_i_func(void* pvstate, variables_t* pvars) {
329 rval_evaluator_i_i_state_t* pstate = pvstate;
330 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
331
332 mv_set_int_nullable(&val1);
333 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
334
335 return pstate->pfunc(&val1);
336 }
rval_evaluator_i_i_free(rval_evaluator_t * pevaluator)337 static void rval_evaluator_i_i_free(rval_evaluator_t* pevaluator) {
338 rval_evaluator_i_i_state_t* pstate = pevaluator->pvstate;
339 pstate->parg1->pfree_func(pstate->parg1);
340 free(pstate);
341 free(pevaluator);
342 }
343
rval_evaluator_alloc_from_i_i_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)344 rval_evaluator_t* rval_evaluator_alloc_from_i_i_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
345 rval_evaluator_i_i_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_i_i_state_t));
346 pstate->pfunc = pfunc;
347 pstate->parg1 = parg1;
348
349 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
350 pevaluator->pvstate = pstate;
351 pevaluator->pprocess_func = rval_evaluator_i_i_func;
352 pevaluator->pfree_func = rval_evaluator_i_i_free;
353
354 return pevaluator;
355 }
356
357 // ----------------------------------------------------------------
358 typedef struct _rval_evaluator_f_ff_state_t {
359 mv_binary_func_t* pfunc;
360 rval_evaluator_t* parg1;
361 rval_evaluator_t* parg2;
362 } rval_evaluator_f_ff_state_t;
363
rval_evaluator_f_ff_func(void * pvstate,variables_t * pvars)364 static mv_t rval_evaluator_f_ff_func(void* pvstate, variables_t* pvars) {
365 rval_evaluator_f_ff_state_t* pstate = pvstate;
366 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
367 mv_set_float_nullable(&val1);
368 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
369
370 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
371 mv_set_float_nullable(&val2);
372 NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
373
374 return pstate->pfunc(&val1, &val2);
375 }
rval_evaluator_f_ff_free(rval_evaluator_t * pevaluator)376 static void rval_evaluator_f_ff_free(rval_evaluator_t* pevaluator) {
377 rval_evaluator_f_ff_state_t* pstate = pevaluator->pvstate;
378 pstate->parg1->pfree_func(pstate->parg1);
379 pstate->parg2->pfree_func(pstate->parg2);
380 free(pstate);
381 free(pevaluator);
382 }
383
rval_evaluator_alloc_from_f_ff_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)384 rval_evaluator_t* rval_evaluator_alloc_from_f_ff_func(mv_binary_func_t* pfunc,
385 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
386 {
387 rval_evaluator_f_ff_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_f_ff_state_t));
388 pstate->pfunc = pfunc;
389 pstate->parg1 = parg1;
390 pstate->parg2 = parg2;
391
392 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
393 pevaluator->pvstate = pstate;
394 pevaluator->pprocess_func = rval_evaluator_f_ff_func;
395 pevaluator->pfree_func = rval_evaluator_f_ff_free;
396
397 return pevaluator;
398 }
399
400 // ----------------------------------------------------------------
401 typedef struct _rval_evaluator_x_xx_state_t {
402 mv_binary_func_t* pfunc;
403 rval_evaluator_t* parg1;
404 rval_evaluator_t* parg2;
405 } rval_evaluator_x_xx_state_t;
406
rval_evaluator_x_xx_func(void * pvstate,variables_t * pvars)407 static mv_t rval_evaluator_x_xx_func(void* pvstate, variables_t* pvars) {
408 rval_evaluator_x_xx_state_t* pstate = pvstate;
409 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
410 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
411
412 // nullities handled by full disposition matrices
413 return pstate->pfunc(&val1, &val2);
414 }
rval_evaluator_x_xx_free(rval_evaluator_t * pevaluator)415 static void rval_evaluator_x_xx_free(rval_evaluator_t* pevaluator) {
416 rval_evaluator_x_xx_state_t* pstate = pevaluator->pvstate;
417 pstate->parg1->pfree_func(pstate->parg1);
418 pstate->parg2->pfree_func(pstate->parg2);
419 free(pstate);
420 free(pevaluator);
421 }
422
rval_evaluator_alloc_from_x_xx_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)423 rval_evaluator_t* rval_evaluator_alloc_from_x_xx_func(mv_binary_func_t* pfunc,
424 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
425 {
426 rval_evaluator_x_xx_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_xx_state_t));
427 pstate->pfunc = pfunc;
428 pstate->parg1 = parg1;
429 pstate->parg2 = parg2;
430
431 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
432 pevaluator->pvstate = pstate;
433 pevaluator->pprocess_func = rval_evaluator_x_xx_func;
434 pevaluator->pfree_func = rval_evaluator_x_xx_free;
435
436 return pevaluator;
437 }
438
439 // ----------------------------------------------------------------
440 // This is for min/max which can return non-null when one argument is null --
441 // in comparison to other functions which return null if *any* argument is
442 // null.
443
444 typedef struct _rval_evaluator_x_xx_nullable_state_t {
445 mv_binary_func_t* pfunc;
446 rval_evaluator_t* parg1;
447 rval_evaluator_t* parg2;
448 } rval_evaluator_x_xx_nullable_state_t;
449
rval_evaluator_x_xx_nullable_func(void * pvstate,variables_t * pvars)450 static mv_t rval_evaluator_x_xx_nullable_func(void* pvstate, variables_t* pvars) {
451 rval_evaluator_x_xx_nullable_state_t* pstate = pvstate;
452 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
453 mv_set_number_nullable(&val1);
454
455 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
456 mv_set_number_nullable(&val2);
457
458 return pstate->pfunc(&val1, &val2);
459 }
rval_evaluator_x_xx_nullable_free(rval_evaluator_t * pevaluator)460 static void rval_evaluator_x_xx_nullable_free(rval_evaluator_t* pevaluator) {
461 rval_evaluator_x_xx_nullable_state_t* pstate = pevaluator->pvstate;
462 pstate->parg1->pfree_func(pstate->parg1);
463 pstate->parg2->pfree_func(pstate->parg2);
464 free(pstate);
465 free(pevaluator);
466 }
467
rval_evaluator_alloc_from_x_xx_nullable_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)468 rval_evaluator_t* rval_evaluator_alloc_from_x_xx_nullable_func(mv_binary_func_t* pfunc,
469 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
470 {
471 rval_evaluator_x_xx_nullable_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_xx_nullable_state_t));
472 pstate->pfunc = pfunc;
473 pstate->parg1 = parg1;
474 pstate->parg2 = parg2;
475
476 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
477 pevaluator->pvstate = pstate;
478 pevaluator->pprocess_func = rval_evaluator_x_xx_nullable_func;
479 pevaluator->pfree_func = rval_evaluator_x_xx_nullable_free;
480
481 return pevaluator;
482 }
483
484 // ----------------------------------------------------------------
485 typedef struct _rval_evaluator_f_fff_state_t {
486 mv_ternary_func_t* pfunc;
487 rval_evaluator_t* parg1;
488 rval_evaluator_t* parg2;
489 rval_evaluator_t* parg3;
490 } rval_evaluator_f_fff_state_t;
491
rval_evaluator_f_fff_func(void * pvstate,variables_t * pvars)492 static mv_t rval_evaluator_f_fff_func(void* pvstate, variables_t* pvars) {
493 rval_evaluator_f_fff_state_t* pstate = pvstate;
494 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
495 mv_set_float_nullable(&val1);
496 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
497
498 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
499 mv_set_float_nullable(&val2);
500 NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
501
502 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
503 mv_set_float_nullable(&val3);
504 NULL_OR_ERROR_OUT_FOR_NUMBERS(val3);
505
506 return pstate->pfunc(&val1, &val2, &val3);
507 }
rval_evaluator_f_fff_free(rval_evaluator_t * pevaluator)508 static void rval_evaluator_f_fff_free(rval_evaluator_t* pevaluator) {
509 rval_evaluator_f_fff_state_t* pstate = pevaluator->pvstate;
510 pstate->parg1->pfree_func(pstate->parg1);
511 pstate->parg2->pfree_func(pstate->parg2);
512 pstate->parg3->pfree_func(pstate->parg3);
513 free(pstate);
514 free(pevaluator);
515 }
516
rval_evaluator_alloc_from_f_fff_func(mv_ternary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2,rval_evaluator_t * parg3)517 rval_evaluator_t* rval_evaluator_alloc_from_f_fff_func(mv_ternary_func_t* pfunc,
518 rval_evaluator_t* parg1, rval_evaluator_t* parg2, rval_evaluator_t* parg3)
519 {
520 rval_evaluator_f_fff_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_f_fff_state_t));
521 pstate->pfunc = pfunc;
522 pstate->parg1 = parg1;
523 pstate->parg2 = parg2;
524 pstate->parg3 = parg3;
525
526 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
527 pevaluator->pvstate = pstate;
528 pevaluator->pprocess_func = rval_evaluator_f_fff_func;
529 pevaluator->pfree_func = rval_evaluator_f_fff_free;
530
531 return pevaluator;
532 }
533
534 // ----------------------------------------------------------------
535 typedef struct _rval_evaluator_i_ii_state_t {
536 mv_binary_func_t* pfunc;
537 rval_evaluator_t* parg1;
538 rval_evaluator_t* parg2;
539 } rval_evaluator_i_ii_state_t;
540
rval_evaluator_i_ii_func(void * pvstate,variables_t * pvars)541 static mv_t rval_evaluator_i_ii_func(void* pvstate, variables_t* pvars) {
542 rval_evaluator_i_ii_state_t* pstate = pvstate;
543 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
544 mv_set_int_nullable(&val1);
545 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
546 if (val1.type != MT_INT)
547 return mv_error();
548
549 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
550 mv_set_int_nullable(&val2);
551 NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
552 if (val2.type != MT_INT)
553 return mv_error();
554
555 return pstate->pfunc(&val1, &val2);
556 }
rval_evaluator_i_ii_free(rval_evaluator_t * pevaluator)557 static void rval_evaluator_i_ii_free(rval_evaluator_t* pevaluator) {
558 rval_evaluator_i_ii_state_t* pstate = pevaluator->pvstate;
559 pstate->parg1->pfree_func(pstate->parg1);
560 pstate->parg2->pfree_func(pstate->parg2);
561 free(pstate);
562 free(pevaluator);
563 }
564
rval_evaluator_alloc_from_i_ii_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)565 rval_evaluator_t* rval_evaluator_alloc_from_i_ii_func(mv_binary_func_t* pfunc,
566 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
567 {
568 rval_evaluator_i_ii_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_i_ii_state_t));
569 pstate->pfunc = pfunc;
570 pstate->parg1 = parg1;
571 pstate->parg2 = parg2;
572
573 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
574 pevaluator->pvstate = pstate;
575 pevaluator->pprocess_func = rval_evaluator_i_ii_func;
576 pevaluator->pfree_func = rval_evaluator_i_ii_free;
577
578 return pevaluator;
579 }
580
581 // ----------------------------------------------------------------
582 typedef struct _rval_evaluator_i_iii_state_t {
583 mv_ternary_func_t* pfunc;
584 rval_evaluator_t* parg1;
585 rval_evaluator_t* parg2;
586 rval_evaluator_t* parg3;
587 } rval_evaluator_i_iii_state_t;
588
rval_evaluator_i_iii_func(void * pvstate,variables_t * pvars)589 static mv_t rval_evaluator_i_iii_func(void* pvstate, variables_t* pvars) {
590 rval_evaluator_i_iii_state_t* pstate = pvstate;
591 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
592 mv_set_int_nullable(&val1);
593 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
594 if (val1.type != MT_INT)
595 return mv_error();
596
597 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
598 mv_set_int_nullable(&val2);
599 NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
600 if (val2.type != MT_INT)
601 return mv_error();
602
603 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
604 mv_set_int_nullable(&val3);
605 NULL_OR_ERROR_OUT_FOR_NUMBERS(val3);
606 if (val3.type != MT_INT)
607 return mv_error();
608
609 return pstate->pfunc(&val1, &val2, &val3);
610 }
rval_evaluator_i_iii_free(rval_evaluator_t * pevaluator)611 static void rval_evaluator_i_iii_free(rval_evaluator_t* pevaluator) {
612 rval_evaluator_i_iii_state_t* pstate = pevaluator->pvstate;
613 pstate->parg1->pfree_func(pstate->parg1);
614 pstate->parg2->pfree_func(pstate->parg2);
615 pstate->parg3->pfree_func(pstate->parg3);
616 free(pstate);
617 free(pevaluator);
618 }
619
rval_evaluator_alloc_from_i_iii_func(mv_ternary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2,rval_evaluator_t * parg3)620 rval_evaluator_t* rval_evaluator_alloc_from_i_iii_func(mv_ternary_func_t* pfunc,
621 rval_evaluator_t* parg1, rval_evaluator_t* parg2, rval_evaluator_t* parg3)
622 {
623 rval_evaluator_i_iii_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_i_iii_state_t));
624 pstate->pfunc = pfunc;
625 pstate->parg1 = parg1;
626 pstate->parg2 = parg2;
627 pstate->parg3 = parg3;
628
629 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
630 pevaluator->pvstate = pstate;
631 pevaluator->pprocess_func = rval_evaluator_i_iii_func;
632 pevaluator->pfree_func = rval_evaluator_i_iii_free;
633
634 return pevaluator;
635 }
636
637 // ----------------------------------------------------------------
638 typedef struct _rval_evaluator_ternop_state_t {
639 rval_evaluator_t* parg1;
640 rval_evaluator_t* parg2;
641 rval_evaluator_t* parg3;
642 } rval_evaluator_ternop_state_t;
643
rval_evaluator_ternop_func(void * pvstate,variables_t * pvars)644 static mv_t rval_evaluator_ternop_func(void* pvstate, variables_t* pvars) {
645 rval_evaluator_ternop_state_t* pstate = pvstate;
646 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
647 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
648 mv_set_boolean_strict(&val1);
649
650 return val1.u.boolv
651 ? pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars)
652 : pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
653 }
rval_evaluator_ternop_free(rval_evaluator_t * pevaluator)654 static void rval_evaluator_ternop_free(rval_evaluator_t* pevaluator) {
655 rval_evaluator_ternop_state_t* pstate = pevaluator->pvstate;
656 pstate->parg1->pfree_func(pstate->parg1);
657 pstate->parg2->pfree_func(pstate->parg2);
658 pstate->parg3->pfree_func(pstate->parg3);
659 free(pstate);
660 free(pevaluator);
661 }
662
rval_evaluator_alloc_from_ternop(rval_evaluator_t * parg1,rval_evaluator_t * parg2,rval_evaluator_t * parg3)663 rval_evaluator_t* rval_evaluator_alloc_from_ternop(rval_evaluator_t* parg1, rval_evaluator_t* parg2, rval_evaluator_t* parg3)
664 {
665 rval_evaluator_ternop_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_ternop_state_t));
666 pstate->parg1 = parg1;
667 pstate->parg2 = parg2;
668 pstate->parg3 = parg3;
669
670 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
671 pevaluator->pvstate = pstate;
672 pevaluator->pprocess_func = rval_evaluator_ternop_func;
673 pevaluator->pfree_func = rval_evaluator_ternop_free;
674
675 return pevaluator;
676 }
677
678 // ----------------------------------------------------------------
679 typedef struct _rval_evaluator_s_s_state_t {
680 mv_unary_func_t* pfunc;
681 rval_evaluator_t* parg1;
682 } rval_evaluator_s_s_state_t;
683
rval_evaluator_s_s_func(void * pvstate,variables_t * pvars)684 static mv_t rval_evaluator_s_s_func(void* pvstate, variables_t* pvars) {
685 rval_evaluator_s_s_state_t* pstate = pvstate;
686 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
687 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
688 if (!mv_is_string_or_empty(&val1))
689 return mv_error();
690
691 return pstate->pfunc(&val1);
692 }
rval_evaluator_s_s_free(rval_evaluator_t * pevaluator)693 static void rval_evaluator_s_s_free(rval_evaluator_t* pevaluator) {
694 rval_evaluator_s_s_state_t* pstate = pevaluator->pvstate;
695 pstate->parg1->pfree_func(pstate->parg1);
696 free(pstate);
697 free(pevaluator);
698 }
699
rval_evaluator_alloc_from_s_s_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)700 rval_evaluator_t* rval_evaluator_alloc_from_s_s_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
701 rval_evaluator_s_s_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_s_state_t));
702 pstate->pfunc = pfunc;
703 pstate->parg1 = parg1;
704
705 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
706 pevaluator->pvstate = pstate;
707 pevaluator->pprocess_func = rval_evaluator_s_s_func;
708 pevaluator->pfree_func = rval_evaluator_s_s_free;
709
710 return pevaluator;
711 }
712
713 // ----------------------------------------------------------------
714 typedef struct _rval_evaluator_s_sii_state_t {
715 mv_ternary_func_t* pfunc;
716 rval_evaluator_t* parg1;
717 rval_evaluator_t* parg2;
718 rval_evaluator_t* parg3;
719 } rval_evaluator_s_sii_state_t;
720
rval_evaluator_s_sii_func(void * pvstate,variables_t * pvars)721 static mv_t rval_evaluator_s_sii_func(void* pvstate, variables_t* pvars) {
722 rval_evaluator_s_sii_state_t* pstate = pvstate;
723
724 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
725 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
726 if (!mv_is_string_or_empty(&val1))
727 return mv_error();
728
729 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
730 mv_set_int_nullable(&val2);
731 NULL_OR_ERROR_OUT_FOR_NUMBERS(val2);
732
733 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
734 mv_set_int_nullable(&val3);
735 NULL_OR_ERROR_OUT_FOR_NUMBERS(val3);
736
737 return pstate->pfunc(&val1, &val2, &val3);
738 }
rval_evaluator_s_sii_free(rval_evaluator_t * pevaluator)739 static void rval_evaluator_s_sii_free(rval_evaluator_t* pevaluator) {
740 rval_evaluator_s_sii_state_t* pstate = pevaluator->pvstate;
741 pstate->parg1->pfree_func(pstate->parg1);
742 pstate->parg2->pfree_func(pstate->parg2);
743 pstate->parg3->pfree_func(pstate->parg3);
744 free(pstate);
745 free(pevaluator);
746 }
747
rval_evaluator_alloc_from_s_sii_func(mv_ternary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2,rval_evaluator_t * parg3)748 rval_evaluator_t* rval_evaluator_alloc_from_s_sii_func(mv_ternary_func_t* pfunc,
749 rval_evaluator_t* parg1, rval_evaluator_t* parg2, rval_evaluator_t* parg3)
750 {
751 rval_evaluator_s_sii_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_sii_state_t));
752 pstate->pfunc = pfunc;
753 pstate->parg1 = parg1;
754 pstate->parg2 = parg2;
755 pstate->parg3 = parg3;
756
757 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
758 pevaluator->pvstate = pstate;
759 pevaluator->pprocess_func = rval_evaluator_s_sii_func;
760 pevaluator->pfree_func = rval_evaluator_s_sii_free;
761
762 return pevaluator;
763 }
764
765 // ----------------------------------------------------------------
766 typedef struct _rval_evaluator_s_f_state_t {
767 mv_unary_func_t* pfunc;
768 rval_evaluator_t* parg1;
769 } rval_evaluator_s_f_state_t;
770
rval_evaluator_s_f_func(void * pvstate,variables_t * pvars)771 static mv_t rval_evaluator_s_f_func(void* pvstate, variables_t* pvars) {
772 rval_evaluator_s_f_state_t* pstate = pvstate;
773 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
774
775 mv_set_float_nullable(&val1);
776 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
777
778 return pstate->pfunc(&val1);
779 }
rval_evaluator_s_f_free(rval_evaluator_t * pevaluator)780 static void rval_evaluator_s_f_free(rval_evaluator_t* pevaluator) {
781 rval_evaluator_s_f_state_t* pstate = pevaluator->pvstate;
782 pstate->parg1->pfree_func(pstate->parg1);
783 free(pstate);
784 free(pevaluator);
785 }
786
rval_evaluator_alloc_from_s_f_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)787 rval_evaluator_t* rval_evaluator_alloc_from_s_f_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
788 rval_evaluator_s_f_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_f_state_t));
789 pstate->pfunc = pfunc;
790 pstate->parg1 = parg1;
791
792 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
793 pevaluator->pvstate = pstate;
794 pevaluator->pprocess_func = rval_evaluator_s_f_func;
795 pevaluator->pfree_func = rval_evaluator_s_f_free;
796
797 return pevaluator;
798 }
799
800 // ----------------------------------------------------------------
801 typedef struct _rval_evaluator_s_i_state_t {
802 mv_unary_func_t* pfunc;
803 rval_evaluator_t* parg1;
804 } rval_evaluator_s_i_state_t;
805
rval_evaluator_s_i_func(void * pvstate,variables_t * pvars)806 static mv_t rval_evaluator_s_i_func(void* pvstate, variables_t* pvars) {
807 rval_evaluator_s_i_state_t* pstate = pvstate;
808 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
809
810 mv_set_int_nullable(&val1);
811 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
812
813 return pstate->pfunc(&val1);
814 }
rval_evaluator_s_i_free(rval_evaluator_t * pevaluator)815 static void rval_evaluator_s_i_free(rval_evaluator_t* pevaluator) {
816 rval_evaluator_s_i_state_t* pstate = pevaluator->pvstate;
817 pstate->parg1->pfree_func(pstate->parg1);
818 free(pstate);
819 free(pevaluator);
820 }
821
rval_evaluator_alloc_from_s_i_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)822 rval_evaluator_t* rval_evaluator_alloc_from_s_i_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
823 rval_evaluator_s_i_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_i_state_t));
824 pstate->pfunc = pfunc;
825 pstate->parg1 = parg1;
826
827 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
828 pevaluator->pvstate = pstate;
829 pevaluator->pprocess_func = rval_evaluator_s_i_func;
830 pevaluator->pfree_func = rval_evaluator_s_i_free;
831
832 return pevaluator;
833 }
834
835 // ----------------------------------------------------------------
836 typedef struct _rval_evaluator_f_s_state_t {
837 mv_unary_func_t* pfunc;
838 rval_evaluator_t* parg1;
839 } rval_evaluator_f_s_state_t;
840
rval_evaluator_f_s_func(void * pvstate,variables_t * pvars)841 static mv_t rval_evaluator_f_s_func(void* pvstate, variables_t* pvars) {
842 rval_evaluator_f_s_state_t* pstate = pvstate;
843 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
844 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
845 if (!mv_is_string_or_empty(&val1))
846 return mv_error();
847
848 return pstate->pfunc(&val1);
849 }
rval_evaluator_f_s_free(rval_evaluator_t * pevaluator)850 static void rval_evaluator_f_s_free(rval_evaluator_t* pevaluator) {
851 rval_evaluator_f_s_state_t* pstate = pevaluator->pvstate;
852 pstate->parg1->pfree_func(pstate->parg1);
853 free(pstate);
854 free(pevaluator);
855 }
856
rval_evaluator_alloc_from_f_s_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)857 rval_evaluator_t* rval_evaluator_alloc_from_f_s_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
858 rval_evaluator_f_s_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_f_s_state_t));
859 pstate->pfunc = pfunc;
860 pstate->parg1 = parg1;
861
862 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
863 pevaluator->pvstate = pstate;
864 pevaluator->pprocess_func = rval_evaluator_f_s_func;
865 pevaluator->pfree_func = rval_evaluator_f_s_free;
866
867 return pevaluator;
868 }
869
870 // ----------------------------------------------------------------
871 typedef struct _rval_evaluator_i_s_state_t {
872 mv_unary_func_t* pfunc;
873 rval_evaluator_t* parg1;
874 } rval_evaluator_i_s_state_t;
875
rval_evaluator_i_s_func(void * pvstate,variables_t * pvars)876 static mv_t rval_evaluator_i_s_func(void* pvstate, variables_t* pvars) {
877 rval_evaluator_i_s_state_t* pstate = pvstate;
878 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
879 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
880 if (!mv_is_string_or_empty(&val1))
881 return mv_error();
882
883 return pstate->pfunc(&val1);
884 }
rval_evaluator_i_s_free(rval_evaluator_t * pevaluator)885 static void rval_evaluator_i_s_free(rval_evaluator_t* pevaluator) {
886 rval_evaluator_i_s_state_t* pstate = pevaluator->pvstate;
887 pstate->parg1->pfree_func(pstate->parg1);
888 free(pstate);
889 free(pevaluator);
890 }
891
rval_evaluator_alloc_from_i_s_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)892 rval_evaluator_t* rval_evaluator_alloc_from_i_s_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
893 rval_evaluator_i_s_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_i_s_state_t));
894 pstate->pfunc = pfunc;
895 pstate->parg1 = parg1;
896
897 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
898 pevaluator->pvstate = pstate;
899 pevaluator->pprocess_func = rval_evaluator_i_s_func;
900 pevaluator->pfree_func = rval_evaluator_i_s_free;
901
902 return pevaluator;
903 }
904
905 // ----------------------------------------------------------------
906 typedef struct _rval_evaluator_x_x_state_t {
907 mv_unary_func_t* pfunc;
908 rval_evaluator_t* parg1;
909 } rval_evaluator_x_x_state_t;
910
rval_evaluator_x_x_func(void * pvstate,variables_t * pvars)911 static mv_t rval_evaluator_x_x_func(void* pvstate, variables_t* pvars) {
912 rval_evaluator_x_x_state_t* pstate = pvstate;
913 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
914
915 // nullity handled by full disposition matrices
916 return pstate->pfunc(&val1);
917 }
rval_evaluator_x_x_free(rval_evaluator_t * pevaluator)918 static void rval_evaluator_x_x_free(rval_evaluator_t* pevaluator) {
919 rval_evaluator_x_x_state_t* pstate = pevaluator->pvstate;
920 pstate->parg1->pfree_func(pstate->parg1);
921 free(pstate);
922 free(pevaluator);
923 }
924
rval_evaluator_alloc_from_x_x_func(mv_unary_func_t * pfunc,rval_evaluator_t * parg1)925 rval_evaluator_t* rval_evaluator_alloc_from_x_x_func(mv_unary_func_t* pfunc, rval_evaluator_t* parg1) {
926 rval_evaluator_x_x_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_x_state_t));
927 pstate->pfunc = pfunc;
928 pstate->parg1 = parg1;
929
930 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
931 pevaluator->pvstate = pstate;
932 pevaluator->pprocess_func = rval_evaluator_x_x_func;
933 pevaluator->pfree_func = rval_evaluator_x_x_free;
934
935 return pevaluator;
936 }
937
938 // ----------------------------------------------------------------
939 typedef struct _rval_evaluator_x_xi_state_t {
940 mv_binary_func_t* pfunc;
941 rval_evaluator_t* parg1;
942 rval_evaluator_t* parg2;
943 } rval_evaluator_x_xi_state_t;
944
rval_evaluator_x_xi_func(void * pvstate,variables_t * pvars)945 static mv_t rval_evaluator_x_xi_func(void* pvstate, variables_t* pvars) {
946 rval_evaluator_x_xi_state_t* pstate = pvstate;
947 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
948 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
949
950 if (val2.type != MT_INT) {
951 return mv_error();
952 }
953
954 // nullity of 1st argument handled by full disposition matrices
955 return pstate->pfunc(&val1, &val2);
956 }
rval_evaluator_x_xi_free(rval_evaluator_t * pevaluator)957 static void rval_evaluator_x_xi_free(rval_evaluator_t* pevaluator) {
958 rval_evaluator_x_xi_state_t* pstate = pevaluator->pvstate;
959 pstate->parg1->pfree_func(pstate->parg1);
960 pstate->parg2->pfree_func(pstate->parg2);
961 free(pstate);
962 free(pevaluator);
963 }
964
rval_evaluator_alloc_from_x_xi_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)965 rval_evaluator_t* rval_evaluator_alloc_from_x_xi_func(mv_binary_func_t* pfunc,
966 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
967 {
968 rval_evaluator_x_xi_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_xi_state_t));
969 pstate->pfunc = pfunc;
970 pstate->parg1 = parg1;
971 pstate->parg2 = parg2;
972
973 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
974 pevaluator->pvstate = pstate;
975 pevaluator->pprocess_func = rval_evaluator_x_xi_func;
976 pevaluator->pfree_func = rval_evaluator_x_xi_free;
977
978 return pevaluator;
979 }
980
981 // ----------------------------------------------------------------
982 typedef struct _rval_evaluator_s_si_state_t {
983 mv_binary_func_t* pfunc;
984 rval_evaluator_t* parg1;
985 rval_evaluator_t* parg2;
986 } rval_evaluator_s_si_state_t;
987
rval_evaluator_s_si_func(void * pvstate,variables_t * pvars)988 static mv_t rval_evaluator_s_si_func(void* pvstate, variables_t* pvars) {
989 rval_evaluator_s_si_state_t* pstate = pvstate;
990 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
991 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
992
993 if (val1.type != MT_EMPTY && val1.type != MT_STRING) {
994 return mv_error();
995 }
996 if (val2.type != MT_INT) {
997 return mv_error();
998 }
999
1000 // nullity of 1st argument handled by full disposition matrices
1001 return pstate->pfunc(&val1, &val2);
1002 }
rval_evaluator_s_si_free(rval_evaluator_t * pevaluator)1003 static void rval_evaluator_s_si_free(rval_evaluator_t* pevaluator) {
1004 rval_evaluator_s_si_state_t* pstate = pevaluator->pvstate;
1005 pstate->parg1->pfree_func(pstate->parg1);
1006 pstate->parg2->pfree_func(pstate->parg2);
1007 free(pstate);
1008 free(pevaluator);
1009 }
1010
rval_evaluator_alloc_from_s_si_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)1011 rval_evaluator_t* rval_evaluator_alloc_from_s_si_func(mv_binary_func_t* pfunc,
1012 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
1013 {
1014 rval_evaluator_s_si_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_si_state_t));
1015 pstate->pfunc = pfunc;
1016 pstate->parg1 = parg1;
1017 pstate->parg2 = parg2;
1018
1019 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1020 pevaluator->pvstate = pstate;
1021 pevaluator->pprocess_func = rval_evaluator_s_si_func;
1022 pevaluator->pfree_func = rval_evaluator_s_si_free;
1023
1024 return pevaluator;
1025 }
1026
1027 // ----------------------------------------------------------------
1028 typedef struct _rval_evaluator_x_ns_state_t {
1029 mv_binary_func_t* pfunc;
1030 rval_evaluator_t* parg1;
1031 rval_evaluator_t* parg2;
1032 } rval_evaluator_x_ns_state_t;
1033
rval_evaluator_x_ns_func(void * pvstate,variables_t * pvars)1034 static mv_t rval_evaluator_x_ns_func(void* pvstate, variables_t* pvars) {
1035 rval_evaluator_x_ns_state_t* pstate = pvstate;
1036 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1037 mv_set_number_nullable(&val1);
1038 NULL_OR_ERROR_OUT_FOR_NUMBERS(val1);
1039
1040 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
1041 NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
1042 if (!mv_is_string_or_empty(&val2)) {
1043 mv_free(&val1);
1044 return mv_error();
1045 }
1046
1047 return pstate->pfunc(&val1, &val2);
1048 }
rval_evaluator_x_ns_free(rval_evaluator_t * pevaluator)1049 static void rval_evaluator_x_ns_free(rval_evaluator_t* pevaluator) {
1050 rval_evaluator_x_ns_state_t* pstate = pevaluator->pvstate;
1051 pstate->parg1->pfree_func(pstate->parg1);
1052 pstate->parg2->pfree_func(pstate->parg2);
1053 free(pstate);
1054 free(pevaluator);
1055 }
1056
rval_evaluator_alloc_from_x_ns_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)1057 rval_evaluator_t* rval_evaluator_alloc_from_x_ns_func(mv_binary_func_t* pfunc,
1058 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
1059 {
1060 rval_evaluator_x_ns_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_ns_state_t));
1061 pstate->pfunc = pfunc;
1062 pstate->parg1 = parg1;
1063 pstate->parg2 = parg2;
1064
1065 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1066 pevaluator->pvstate = pstate;
1067 pevaluator->pprocess_func = rval_evaluator_x_ns_func;
1068 pevaluator->pfree_func = rval_evaluator_x_ns_free;
1069
1070 return pevaluator;
1071 }
1072
1073 // ----------------------------------------------------------------
1074 typedef struct _rval_evaluator_x_ss_state_t {
1075 mv_binary_func_t* pfunc;
1076 rval_evaluator_t* parg1;
1077 rval_evaluator_t* parg2;
1078 } rval_evaluator_x_ss_state_t;
1079
rval_evaluator_x_ss_func(void * pvstate,variables_t * pvars)1080 static mv_t rval_evaluator_x_ss_func(void* pvstate, variables_t* pvars) {
1081 rval_evaluator_x_ss_state_t* pstate = pvstate;
1082 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1083 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1084 if (!mv_is_string_or_empty(&val1))
1085 return mv_error();
1086
1087 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
1088 NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
1089 if (!mv_is_string_or_empty(&val2))
1090 return mv_error();
1091
1092 return pstate->pfunc(&val1, &val2);
1093 }
rval_evaluator_x_ss_free(rval_evaluator_t * pevaluator)1094 static void rval_evaluator_x_ss_free(rval_evaluator_t* pevaluator) {
1095 rval_evaluator_x_ss_state_t* pstate = pevaluator->pvstate;
1096 pstate->parg1->pfree_func(pstate->parg1);
1097 pstate->parg2->pfree_func(pstate->parg2);
1098 free(pstate);
1099 free(pevaluator);
1100 }
1101
rval_evaluator_alloc_from_x_ss_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)1102 rval_evaluator_t* rval_evaluator_alloc_from_x_ss_func(mv_binary_func_t* pfunc,
1103 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
1104 {
1105 rval_evaluator_x_ss_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_ss_state_t));
1106 pstate->pfunc = pfunc;
1107 pstate->parg1 = parg1;
1108 pstate->parg2 = parg2;
1109
1110 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1111 pevaluator->pvstate = pstate;
1112 pevaluator->pprocess_func = rval_evaluator_x_ss_func;
1113 pevaluator->pfree_func = rval_evaluator_x_ss_free;
1114
1115 return pevaluator;
1116 }
1117
1118 // ----------------------------------------------------------------
1119 typedef struct _rval_evaluator_x_ssc_state_t {
1120 mv_binary_arg3_capture_func_t* pfunc;
1121 rval_evaluator_t* parg1;
1122 rval_evaluator_t* parg2;
1123 } rval_evaluator_x_ssc_state_t;
1124
rval_evaluator_x_ssc_func(void * pvstate,variables_t * pvars)1125 static mv_t rval_evaluator_x_ssc_func(void* pvstate, variables_t* pvars) {
1126 rval_evaluator_x_ssc_state_t* pstate = pvstate;
1127 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1128 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1129 if (!mv_is_string_or_empty(&val1))
1130 return mv_error();
1131
1132 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
1133 NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
1134 if (!mv_is_string_or_empty(&val2))
1135 return mv_error();
1136 return pstate->pfunc(&val1, &val2, pvars->ppregex_captures);
1137 }
rval_evaluator_x_ssc_free(rval_evaluator_t * pevaluator)1138 static void rval_evaluator_x_ssc_free(rval_evaluator_t* pevaluator) {
1139 rval_evaluator_x_ssc_state_t* pstate = pevaluator->pvstate;
1140 pstate->parg1->pfree_func(pstate->parg1);
1141 pstate->parg2->pfree_func(pstate->parg2);
1142 free(pstate);
1143 free(pevaluator);
1144 }
1145
rval_evaluator_alloc_from_x_ssc_func(mv_binary_arg3_capture_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)1146 rval_evaluator_t* rval_evaluator_alloc_from_x_ssc_func(mv_binary_arg3_capture_func_t* pfunc,
1147 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
1148 {
1149 rval_evaluator_x_ssc_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_ssc_state_t));
1150 pstate->pfunc = pfunc;
1151 pstate->parg1 = parg1;
1152 pstate->parg2 = parg2;
1153
1154 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1155 pevaluator->pvstate = pstate;
1156 pevaluator->pprocess_func = rval_evaluator_x_ssc_func;
1157 pevaluator->pfree_func = rval_evaluator_x_ssc_free;
1158
1159 return pevaluator;
1160 }
1161
1162 // ----------------------------------------------------------------
1163 typedef struct _rval_evaluator_x_sr_state_t {
1164 mv_binary_arg2_regex_func_t* pfunc;
1165 rval_evaluator_t* parg1;
1166 regex_t regex;
1167 string_builder_t* psb;
1168 } rval_evaluator_x_sr_state_t;
1169
rval_evaluator_x_sr_func(void * pvstate,variables_t * pvars)1170 static mv_t rval_evaluator_x_sr_func(void* pvstate, variables_t* pvars) {
1171 rval_evaluator_x_sr_state_t* pstate = pvstate;
1172 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1173
1174 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1175 if (!mv_is_string_or_empty(&val1))
1176 return mv_error();
1177
1178 return pstate->pfunc(&val1, &pstate->regex, pstate->psb, pvars->ppregex_captures);
1179 }
rval_evaluator_x_sr_free(rval_evaluator_t * pevaluator)1180 static void rval_evaluator_x_sr_free(rval_evaluator_t* pevaluator) {
1181 rval_evaluator_x_sr_state_t* pstate = pevaluator->pvstate;
1182 pstate->parg1->pfree_func(pstate->parg1);
1183 regfree(&pstate->regex);
1184 sb_free(pstate->psb);
1185 free(pstate);
1186 free(pevaluator);
1187 }
1188
rval_evaluator_alloc_from_x_sr_func(mv_binary_arg2_regex_func_t * pfunc,rval_evaluator_t * parg1,char * regex_string,int ignore_case)1189 rval_evaluator_t* rval_evaluator_alloc_from_x_sr_func(mv_binary_arg2_regex_func_t* pfunc,
1190 rval_evaluator_t* parg1, char* regex_string, int ignore_case)
1191 {
1192 rval_evaluator_x_sr_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_sr_state_t));
1193 pstate->pfunc = pfunc;
1194 pstate->parg1 = parg1;
1195
1196 int cflags = ignore_case ? REG_ICASE : 0;
1197 regcomp_or_die(&pstate->regex, regex_string, cflags);
1198 pstate->psb = sb_alloc(MV_SB_ALLOC_LENGTH);
1199
1200 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1201 pevaluator->pvstate = pstate;
1202 pevaluator->pprocess_func = rval_evaluator_x_sr_func;
1203 pevaluator->pfree_func = rval_evaluator_x_sr_free;
1204
1205 return pevaluator;
1206 }
1207
1208 // ----------------------------------------------------------------
1209 typedef struct _rval_evaluator_x_se_state_t {
1210 mv_binary_arg2_regextract_func_t* pfunc;
1211 rval_evaluator_t* parg1;
1212 regex_t regex;
1213 } rval_evaluator_x_se_state_t;
1214
rval_evaluator_x_se_func(void * pvstate,variables_t * pvars)1215 static mv_t rval_evaluator_x_se_func(void* pvstate, variables_t* pvars) {
1216 rval_evaluator_x_se_state_t* pstate = pvstate;
1217 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1218
1219 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1220 if (!mv_is_string_or_empty(&val1))
1221 return mv_error();
1222
1223 return pstate->pfunc(&val1, &pstate->regex);
1224 }
1225
rval_evaluator_x_se_free(rval_evaluator_t * pevaluator)1226 static void rval_evaluator_x_se_free(rval_evaluator_t* pevaluator) {
1227 rval_evaluator_x_se_state_t* pstate = pevaluator->pvstate;
1228 pstate->parg1->pfree_func(pstate->parg1);
1229 regfree(&pstate->regex);
1230 free(pstate);
1231 free(pevaluator);
1232 }
1233
rval_evaluator_alloc_from_x_se_func(mv_binary_arg2_regextract_func_t * pfunc,rval_evaluator_t * parg1,char * regex_string,int ignore_case)1234 rval_evaluator_t* rval_evaluator_alloc_from_x_se_func(mv_binary_arg2_regextract_func_t* pfunc,
1235 rval_evaluator_t* parg1, char* regex_string, int ignore_case)
1236 {
1237 rval_evaluator_x_se_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_se_state_t));
1238 pstate->pfunc = pfunc;
1239 pstate->parg1 = parg1;
1240
1241 int cflags = ignore_case ? REG_ICASE : 0;
1242 regcomp_or_die(&pstate->regex, regex_string, cflags);
1243
1244 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1245 pevaluator->pvstate = pstate;
1246 pevaluator->pprocess_func = rval_evaluator_x_se_func;
1247 pevaluator->pfree_func = rval_evaluator_x_se_free;
1248
1249 return pevaluator;
1250 }
1251
1252 // ----------------------------------------------------------------
1253 typedef struct _rval_evaluator_s_xs_state_t {
1254 mv_binary_func_t* pfunc;
1255 rval_evaluator_t* parg1;
1256 rval_evaluator_t* parg2;
1257 } rval_evaluator_s_xs_state_t;
1258
rval_evaluator_s_xs_func(void * pvstate,variables_t * pvars)1259 static mv_t rval_evaluator_s_xs_func(void* pvstate, variables_t* pvars) {
1260 rval_evaluator_s_xs_state_t* pstate = pvstate;
1261 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1262 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
1263 NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
1264 if (!mv_is_string_or_empty(&val2))
1265 return mv_error();
1266
1267 return pstate->pfunc(&val1, &val2);
1268 }
rval_evaluator_s_xs_free(rval_evaluator_t * pevaluator)1269 static void rval_evaluator_s_xs_free(rval_evaluator_t* pevaluator) {
1270 rval_evaluator_s_xs_state_t* pstate = pevaluator->pvstate;
1271 pstate->parg1->pfree_func(pstate->parg1);
1272 pstate->parg2->pfree_func(pstate->parg2);
1273 free(pstate);
1274 free(pevaluator);
1275 }
1276
rval_evaluator_alloc_from_s_xs_func(mv_binary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2)1277 rval_evaluator_t* rval_evaluator_alloc_from_s_xs_func(mv_binary_func_t* pfunc,
1278 rval_evaluator_t* parg1, rval_evaluator_t* parg2)
1279 {
1280 rval_evaluator_s_xs_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_xs_state_t));
1281 pstate->pfunc = pfunc;
1282 pstate->parg1 = parg1;
1283 pstate->parg2 = parg2;
1284
1285 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1286 pevaluator->pvstate = pstate;
1287 pevaluator->pprocess_func = rval_evaluator_s_xs_func;
1288 pevaluator->pfree_func = rval_evaluator_s_xs_free;
1289
1290 return pevaluator;
1291 }
1292
1293 // ----------------------------------------------------------------
1294 typedef struct _rval_evaluator_s_sss_state_t {
1295 mv_ternary_func_t* pfunc;
1296 rval_evaluator_t* parg1;
1297 rval_evaluator_t* parg2;
1298 rval_evaluator_t* parg3;
1299 } rval_evaluator_s_sss_state_t;
1300
rval_evaluator_s_sss_func(void * pvstate,variables_t * pvars)1301 static mv_t rval_evaluator_s_sss_func(void* pvstate, variables_t* pvars) {
1302 rval_evaluator_s_sss_state_t* pstate = pvstate;
1303 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1304 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1305 if (!mv_is_string_or_empty(&val1))
1306 return mv_error();
1307
1308 mv_t val2 = pstate->parg2->pprocess_func(pstate->parg2->pvstate, pvars);
1309 NULL_OR_ERROR_OUT_FOR_STRINGS(val2);
1310 if (!mv_is_string_or_empty(&val2)) {
1311 mv_free(&val1);
1312 return mv_error();
1313 }
1314
1315 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
1316 NULL_OR_ERROR_OUT_FOR_STRINGS(val3);
1317 if (!mv_is_string_or_empty(&val3)) {
1318 mv_free(&val1);
1319 mv_free(&val2);
1320 return mv_error();
1321 }
1322
1323 return pstate->pfunc(&val1, &val2, &val3);
1324 }
rval_evaluator_s_sss_free(rval_evaluator_t * pevaluator)1325 static void rval_evaluator_s_sss_free(rval_evaluator_t* pevaluator) {
1326 rval_evaluator_s_sss_state_t* pstate = pevaluator->pvstate;
1327 pstate->parg1->pfree_func(pstate->parg1);
1328 pstate->parg2->pfree_func(pstate->parg2);
1329 pstate->parg3->pfree_func(pstate->parg3);
1330 free(pstate);
1331 free(pevaluator);
1332 }
1333
rval_evaluator_alloc_from_s_sss_func(mv_ternary_func_t * pfunc,rval_evaluator_t * parg1,rval_evaluator_t * parg2,rval_evaluator_t * parg3)1334 rval_evaluator_t* rval_evaluator_alloc_from_s_sss_func(mv_ternary_func_t* pfunc,
1335 rval_evaluator_t* parg1, rval_evaluator_t* parg2, rval_evaluator_t* parg3)
1336 {
1337 rval_evaluator_s_sss_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_s_sss_state_t));
1338 pstate->pfunc = pfunc;
1339 pstate->parg1 = parg1;
1340 pstate->parg2 = parg2;
1341 pstate->parg3 = parg3;
1342
1343 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1344 pevaluator->pvstate = pstate;
1345 pevaluator->pprocess_func = rval_evaluator_s_sss_func;
1346 pevaluator->pfree_func = rval_evaluator_s_sss_free;
1347
1348 return pevaluator;
1349 }
1350
1351 // ----------------------------------------------------------------
1352 typedef struct _rval_evaluator_x_srs_state_t {
1353 mv_ternary_arg2_regex_func_t* pfunc;
1354 rval_evaluator_t* parg1;
1355 regex_t regex;
1356 rval_evaluator_t* parg3;
1357 string_builder_t* psb;
1358 } rval_evaluator_x_srs_state_t;
1359
rval_evaluator_x_srs_func(void * pvstate,variables_t * pvars)1360 static mv_t rval_evaluator_x_srs_func(void* pvstate, variables_t* pvars) {
1361 rval_evaluator_x_srs_state_t* pstate = pvstate;
1362
1363 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1364 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1365 if (!mv_is_string_or_empty(&val1))
1366 return mv_error();
1367
1368 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
1369 NULL_OR_ERROR_OUT_FOR_STRINGS(val3);
1370 if (!mv_is_string_or_empty(&val3)) {
1371 mv_free(&val3);
1372 return mv_error();
1373 }
1374
1375 return pstate->pfunc(&val1, &pstate->regex, pstate->psb, &val3);
1376 }
rval_evaluator_x_srs_free(rval_evaluator_t * pevaluator)1377 static void rval_evaluator_x_srs_free(rval_evaluator_t* pevaluator) {
1378 rval_evaluator_x_srs_state_t* pstate = pevaluator->pvstate;
1379 pstate->parg1->pfree_func(pstate->parg1);
1380 regfree(&pstate->regex);
1381 pstate->parg3->pfree_func(pstate->parg3);
1382 sb_free(pstate->psb);
1383 free(pstate);
1384 free(pevaluator);
1385 }
1386
rval_evaluator_alloc_from_x_srs_func(mv_ternary_arg2_regex_func_t * pfunc,rval_evaluator_t * parg1,char * regex_string,int ignore_case,rval_evaluator_t * parg3)1387 rval_evaluator_t* rval_evaluator_alloc_from_x_srs_func(mv_ternary_arg2_regex_func_t* pfunc,
1388 rval_evaluator_t* parg1, char* regex_string, int ignore_case, rval_evaluator_t* parg3)
1389 {
1390 rval_evaluator_x_srs_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_srs_state_t));
1391 pstate->pfunc = pfunc;
1392
1393 pstate->parg1 = parg1;
1394
1395 int cflags = ignore_case ? REG_ICASE : 0;
1396 regcomp_or_die(&pstate->regex, regex_string, cflags);
1397 pstate->psb = sb_alloc(MV_SB_ALLOC_LENGTH);
1398
1399 pstate->parg3 = parg3;
1400
1401 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1402 pevaluator->pvstate = pstate;
1403 pevaluator->pprocess_func = rval_evaluator_x_srs_func;
1404 pevaluator->pfree_func = rval_evaluator_x_srs_free;
1405
1406 return pevaluator;
1407 }
1408
1409 // ----------------------------------------------------------------
1410 typedef struct _rval_evaluator_x_ses_state_t {
1411 mv_ternary_arg2_regextract_func_t* pfunc;
1412 rval_evaluator_t* parg1;
1413 regex_t regex;
1414 rval_evaluator_t* parg3;
1415 } rval_evaluator_x_ses_state_t;
1416
rval_evaluator_x_ses_func(void * pvstate,variables_t * pvars)1417 static mv_t rval_evaluator_x_ses_func(void* pvstate, variables_t* pvars) {
1418 rval_evaluator_x_ses_state_t* pstate = pvstate;
1419
1420 mv_t val1 = pstate->parg1->pprocess_func(pstate->parg1->pvstate, pvars);
1421 NULL_OR_ERROR_OUT_FOR_STRINGS(val1);
1422 if (!mv_is_string_or_empty(&val1))
1423 return mv_error();
1424
1425 mv_t val3 = pstate->parg3->pprocess_func(pstate->parg3->pvstate, pvars);
1426 NULL_OR_ERROR_OUT_FOR_STRINGS(val3);
1427 if (!mv_is_string_or_empty(&val3)) {
1428 mv_free(&val3);
1429 return mv_error();
1430 }
1431
1432 return pstate->pfunc(&val1, &pstate->regex, &val3);
1433 }
1434
rval_evaluator_x_ses_free(rval_evaluator_t * pevaluator)1435 static void rval_evaluator_x_ses_free(rval_evaluator_t* pevaluator) {
1436 rval_evaluator_x_ses_state_t* pstate = pevaluator->pvstate;
1437 pstate->parg1->pfree_func(pstate->parg1);
1438 regfree(&pstate->regex);
1439 pstate->parg3->pfree_func(pstate->parg3);
1440 free(pstate);
1441 free(pevaluator);
1442 }
1443
rval_evaluator_alloc_from_x_ses_func(mv_ternary_arg2_regextract_func_t * pfunc,rval_evaluator_t * parg1,char * regex_string,int ignore_case,rval_evaluator_t * parg3)1444 rval_evaluator_t* rval_evaluator_alloc_from_x_ses_func(mv_ternary_arg2_regextract_func_t* pfunc,
1445 rval_evaluator_t* parg1, char* regex_string, int ignore_case, rval_evaluator_t* parg3)
1446 {
1447 rval_evaluator_x_ses_state_t* pstate = mlr_malloc_or_die(sizeof(rval_evaluator_x_ses_state_t));
1448 pstate->pfunc = pfunc;
1449
1450 pstate->parg1 = parg1;
1451
1452 int cflags = ignore_case ? REG_ICASE : 0;
1453 regcomp_or_die(&pstate->regex, regex_string, cflags);
1454
1455 pstate->parg3 = parg3;
1456
1457 rval_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(rval_evaluator_t));
1458 pevaluator->pvstate = pstate;
1459 pevaluator->pprocess_func = rval_evaluator_x_ses_func;
1460 pevaluator->pfree_func = rval_evaluator_x_ses_free;
1461
1462 return pevaluator;
1463 }
1464