diff --git a/c/mapping/lrec_evaluators.c b/c/mapping/lrec_evaluators.c index cb79552c6..c918fb47f 100644 --- a/c/mapping/lrec_evaluators.c +++ b/c/mapping/lrec_evaluators.c @@ -401,11 +401,11 @@ mv_t lrec_evaluator_field_name_func(lrec_t* prec, context_t* pctx, void* pvstate lrec_evaluator_field_name_state_t* pstate = pvstate; char* string = lrec_get(prec, pstate->field_name); if (string == NULL) { - return (mv_t) {.type = MT_NULL, .u.int_val = 0}; + return (mv_t) {.type = MT_NULL, .u.ival = 0}; } else { - double double_val; - if (mlr_try_double_from_string(string, &double_val)) { - return (mv_t) {.type = MT_DOUBLE, .u.double_val = double_val}; + double dval; + if (mlr_try_double_from_string(string, &dval)) { + return (mv_t) {.type = MT_DOUBLE, .u.dval = dval}; } else { return (mv_t) {.type = MT_STRING, .u.string_val = strdup(string)}; } @@ -443,9 +443,9 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_literal(char* string) { lrec_evaluator_literal_state_t* pstate = mlr_malloc_or_die(sizeof(lrec_evaluator_literal_state_t)); lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); - double double_val; - if (mlr_try_double_from_string(string, &double_val)) { - pstate->literal = (mv_t) {.type = MT_DOUBLE, .u.double_val = double_val}; + double dval; + if (mlr_try_double_from_string(string, &dval)) { + pstate->literal = (mv_t) {.type = MT_DOUBLE, .u.dval = dval}; pevaluator->pevaluator_func = lrec_evaluator_double_literal_func; } else { pstate->literal = (mv_t) {.type = MT_STRING, .u.string_val = strdup(string)}; @@ -458,7 +458,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_literal(char* string) { // ================================================================ mv_t lrec_evaluator_NF_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_INT, .u.int_val = prec->field_count}; + return (mv_t) {.type = MT_INT, .u.ival = prec->field_count}; } lrec_evaluator_t* lrec_evaluator_alloc_from_NF() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); @@ -469,7 +469,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_NF() { // ---------------------------------------------------------------- mv_t lrec_evaluator_NR_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_INT, .u.int_val = pctx->nr}; + return (mv_t) {.type = MT_INT, .u.ival = pctx->nr}; } lrec_evaluator_t* lrec_evaluator_alloc_from_NR() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); @@ -480,7 +480,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_NR() { // ---------------------------------------------------------------- mv_t lrec_evaluator_FNR_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_INT, .u.int_val = pctx->fnr}; + return (mv_t) {.type = MT_INT, .u.ival = pctx->fnr}; } lrec_evaluator_t* lrec_evaluator_alloc_from_FNR() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); @@ -503,7 +503,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_FILENAME() { // ---------------------------------------------------------------- mv_t lrec_evaluator_FILENUM_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_INT, .u.int_val = pctx->filenum}; + return (mv_t) {.type = MT_INT, .u.ival = pctx->filenum}; } lrec_evaluator_t* lrec_evaluator_alloc_from_FILENUM() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); diff --git a/c/mapping/mapper_filter.c b/c/mapping/mapper_filter.c index 80fd4f168..7392c0a59 100644 --- a/c/mapping/mapper_filter.c +++ b/c/mapping/mapper_filter.c @@ -16,8 +16,8 @@ static sllv_t* mapper_filter_process(lrec_t* pinrec, context_t* pctx, void* pvst if (pinrec != NULL) { mv_t val = pstate->pevaluator->pevaluator_func(pinrec, pctx, pstate->pevaluator->pvstate); - int bool_val = mt_get_boolean_strict(&val); - if (bool_val) { + int bval = mt_get_boolean_strict(&val); + if (bval) { return sllv_single(pinrec); } else { lrec_free(pinrec); diff --git a/c/mapping/mlr_val.c b/c/mapping/mlr_val.c index b921bbaaf..1d2de55a4 100644 --- a/c/mapping/mlr_val.c +++ b/c/mapping/mlr_val.c @@ -7,11 +7,11 @@ // ---------------------------------------------------------------- mv_t MV_NULL = { .type = MT_NULL, - .u.int_val = 0 + .u.ival = 0 }; mv_t MV_ERROR = { .type = MT_ERROR, - .u.int_val = 0 + .u.ival = 0 }; // ---------------------------------------------------------------- @@ -39,18 +39,18 @@ char* mt_format_val(mv_t* pval) { return strdup("(error)"); break; case MT_BOOL: - return strdup(pval->u.bool_val ? "true" : "false"); + return strdup(pval->u.bval ? "true" : "false"); break; case MT_DOUBLE: // xxx what is worst-case here ... string = mlr_malloc_or_die(32); - sprintf(string, MLR_GLOBALS.ofmt, pval->u.double_val); + sprintf(string, MLR_GLOBALS.ofmt, pval->u.dval); return string; break; case MT_INT: // log10(2**64) is < 20 so this is plenty. string = mlr_malloc_or_die(32); - sprintf(string, "%lld", pval->u.int_val); + sprintf(string, "%lld", pval->u.ival); return string; break; case MT_STRING: @@ -81,7 +81,7 @@ int mt_get_boolean_strict(mv_t* pval) { free(desc); exit(1); } - return pval->u.bool_val; + return pval->u.bval; } // ---------------------------------------------------------------- @@ -94,20 +94,20 @@ void mt_get_double_strict(mv_t* pval) { if (pval->type == MT_DOUBLE) return; if (pval->type == MT_STRING) { - double double_val; - if (!mlr_try_double_from_string(pval->u.string_val, &double_val)) { + double dval; + if (!mlr_try_double_from_string(pval->u.string_val, &dval)) { pval->type = MT_ERROR; - pval->u.int_val = 0; + pval->u.ival = 0; } else { pval->type = MT_DOUBLE; - pval->u.double_val = double_val; + pval->u.dval = dval; } } else if (pval->type == MT_INT) { pval ->type = MT_DOUBLE; - pval->u.double_val = (double)pval->u.int_val; + pval->u.dval = (double)pval->u.ival; } else if (pval->type == MT_BOOL) { pval->type = MT_ERROR; - pval->u.int_val = 0; + pval->u.ival = 0; } // xxx else panic } @@ -193,7 +193,7 @@ mv_t s_f_sec2gmt_func(mv_t* pval1) { mt_get_double_strict(pval1); if (pval1->type != MT_DOUBLE) return MV_ERROR; - time_t clock = (time_t) pval1->u.double_val; + time_t clock = (time_t) pval1->u.dval; struct tm tm; struct tm *ptm = gmtime_r(&clock, &tm); // xxx use retval which is size_t @@ -210,130 +210,130 @@ mv_t i_s_gmt2sec_func(mv_t* pval1) { strptime(pval1->u.string_val, "%Y-%m-%dT%H:%M:%SZ", &tm); time_t t = timegm(&tm); - mv_t rv = {.type = MT_INT, .u.int_val = (long long)t}; + mv_t rv = {.type = MT_INT, .u.ival = (long long)t}; return rv; } // ---------------------------------------------------------------- mv_t i_s_strlen_func(mv_t* pval1) { - mv_t rv = {.type = MT_INT, .u.int_val = strlen(pval1->u.string_val)}; + mv_t rv = {.type = MT_INT, .u.ival = strlen(pval1->u.string_val)}; return rv; } // ---------------------------------------------------------------- // xxx cmt us!!!! -static mv_t op_n_xx(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_NULL, .u.int_val = 0}; } -static mv_t op_e_xx(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_ERROR, .u.int_val = 0}; } +static mv_t op_n_xx(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_NULL, .u.ival = 0}; } +static mv_t op_e_xx(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_ERROR, .u.ival = 0}; } -static mv_t eq_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val == pb->u.int_val}; } -static mv_t ne_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val != pb->u.int_val}; } -static mv_t gt_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val > pb->u.int_val}; } -static mv_t ge_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val >= pb->u.int_val}; } -static mv_t lt_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val < pb->u.int_val}; } -static mv_t le_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val <= pb->u.int_val}; } +static mv_t eq_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival == pb->u.ival}; } +static mv_t ne_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival != pb->u.ival}; } +static mv_t gt_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival > pb->u.ival}; } +static mv_t ge_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival >= pb->u.ival}; } +static mv_t lt_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival < pb->u.ival}; } +static mv_t le_b_ii(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival <= pb->u.ival}; } -static mv_t eq_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val == pb->u.double_val}; } -static mv_t ne_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val != pb->u.double_val}; } -static mv_t gt_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val > pb->u.double_val}; } -static mv_t ge_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val >= pb->u.double_val}; } -static mv_t lt_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val < pb->u.double_val}; } -static mv_t le_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val <= pb->u.double_val}; } +static mv_t eq_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval == pb->u.dval}; } +static mv_t ne_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval != pb->u.dval}; } +static mv_t gt_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval > pb->u.dval}; } +static mv_t ge_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval >= pb->u.dval}; } +static mv_t lt_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval < pb->u.dval}; } +static mv_t le_b_ff(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval <= pb->u.dval}; } -static mv_t eq_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val == pb->u.int_val}; } -static mv_t ne_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val != pb->u.int_val}; } -static mv_t gt_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val > pb->u.int_val}; } -static mv_t ge_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val >= pb->u.int_val}; } -static mv_t lt_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val < pb->u.int_val}; } -static mv_t le_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.double_val <= pb->u.int_val}; } +static mv_t eq_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval == pb->u.ival}; } +static mv_t ne_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval != pb->u.ival}; } +static mv_t gt_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval > pb->u.ival}; } +static mv_t ge_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval >= pb->u.ival}; } +static mv_t lt_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval < pb->u.ival}; } +static mv_t le_b_fi(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.dval <= pb->u.ival}; } -static mv_t eq_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val == pb->u.double_val}; } -static mv_t ne_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val != pb->u.double_val}; } -static mv_t gt_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val > pb->u.double_val}; } -static mv_t ge_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val >= pb->u.double_val}; } -static mv_t lt_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val < pb->u.double_val}; } -static mv_t le_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = pa->u.int_val <= pb->u.double_val}; } +static mv_t eq_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival == pb->u.dval}; } +static mv_t ne_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival != pb->u.dval}; } +static mv_t gt_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival > pb->u.dval}; } +static mv_t ge_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival >= pb->u.dval}; } +static mv_t lt_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival < pb->u.dval}; } +static mv_t le_b_if(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = pa->u.ival <= pb->u.dval}; } static mv_t eq_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) == 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) == 0}; free(a); return rv; } static mv_t ne_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) != 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) != 0}; free(a); return rv; } static mv_t gt_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) > 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) > 0}; free(a); return rv; } static mv_t ge_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) >= 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) >= 0}; free(a); return rv; } static mv_t lt_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) < 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) < 0}; free(a); return rv; } static mv_t le_b_xs(mv_t* pa, mv_t* pb) { char* a = mt_format_val(pa); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(a, pb->u.string_val) <= 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(a, pb->u.string_val) <= 0}; free(a); return rv; } static mv_t eq_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) == 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) == 0}; free(b); return rv; } static mv_t ne_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) != 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) != 0}; free(b); return rv; } static mv_t gt_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) > 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) > 0}; free(b); return rv; } static mv_t ge_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) >= 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) >= 0}; free(b); return rv; } static mv_t lt_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) < 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) < 0}; free(b); return rv; } static mv_t le_b_sx(mv_t* pa, mv_t* pb) { char* b = mt_format_val(pb); - mv_t rv = {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, b) <= 0}; + mv_t rv = {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, b) <= 0}; free(b); return rv; } -static mv_t eq_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) == 0}; } -static mv_t ne_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) != 0}; } -static mv_t gt_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) > 0}; } -static mv_t ge_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) >= 0}; } -static mv_t lt_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) < 0}; } -static mv_t le_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bool_val = strcmp(pa->u.string_val, pb->u.string_val) <= 0}; } +static mv_t eq_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) == 0}; } +static mv_t ne_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) != 0}; } +static mv_t gt_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) > 0}; } +static mv_t ge_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) >= 0}; } +static mv_t lt_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) < 0}; } +static mv_t le_b_ss(mv_t* pa, mv_t* pb) { return (mv_t) {.type = MT_BOOL, .u.bval = strcmp(pa->u.string_val, pb->u.string_val) <= 0}; } static mv_binary_func_t* eq_dispositions[MT_MAX][MT_MAX] = { // NULL ERROR BOOL DOUBLE INT STRING diff --git a/c/mapping/mlr_val.h b/c/mapping/mlr_val.h index 7699d0b61..9b137e7eb 100644 --- a/c/mapping/mlr_val.h +++ b/c/mapping/mlr_val.h @@ -24,9 +24,9 @@ typedef struct _mlr_val_t { union { - int bool_val; - double double_val; - long long int_val; + int bval; + double dval; + long long ival; char* string_val; } u; unsigned char type; @@ -61,111 +61,111 @@ typedef mv_t mv_ternary_func_t(mv_t* pval1, mv_t* pval2, mv_t* pval3); // ---------------------------------------------------------------- static inline mv_t b_b_not_func(mv_t* pval1) { - mv_t rv = {.type = MT_BOOL, .u.bool_val = !pval1->u.bool_val}; + mv_t rv = {.type = MT_BOOL, .u.bval = !pval1->u.bval}; return rv; } static inline mv_t b_bb_or_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_BOOL, .u.bool_val = pval1->u.bool_val || pval2->u.bool_val}; + mv_t rv = {.type = MT_BOOL, .u.bval = pval1->u.bval || pval2->u.bval}; return rv; } static inline mv_t b_bb_and_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_BOOL, .u.bool_val = pval1->u.bool_val && pval2->u.bool_val}; + mv_t rv = {.type = MT_BOOL, .u.bval = pval1->u.bval && pval2->u.bval}; return rv; } // ---------------------------------------------------------------- static inline mv_t f_z_urand_func() { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = get_mtrand_double()}; // mtrand.h + mv_t rv = {.type = MT_DOUBLE, .u.dval = get_mtrand_double()}; // mtrand.h return rv; } static inline mv_t f_z_systime_func() { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = get_systime()}; // mlrutil.h + mv_t rv = {.type = MT_DOUBLE, .u.dval = get_systime()}; // mlrutil.h return rv; } // ---------------------------------------------------------------- static inline mv_t f_f_uneg_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = -pval1->u.double_val}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = -pval1->u.dval}; return rv; } static inline mv_t f_f_abs_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = fabs(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = fabs(pval1->u.dval)}; return rv; } static inline mv_t f_f_log_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = log(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = log(pval1->u.dval)}; return rv; } static inline mv_t f_f_log10_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = log10(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = log10(pval1->u.dval)}; return rv; } static inline mv_t f_f_exp_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = exp(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = exp(pval1->u.dval)}; return rv; } static inline mv_t f_f_sin_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = sin(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = sin(pval1->u.dval)}; return rv; } static inline mv_t f_f_cos_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = cos(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = cos(pval1->u.dval)}; return rv; } static inline mv_t f_f_tan_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = tan(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = tan(pval1->u.dval)}; return rv; } static inline mv_t f_f_sqrt_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = sqrt(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = sqrt(pval1->u.dval)}; return rv; } static inline mv_t f_f_round_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = round(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = round(pval1->u.dval)}; return rv; } static inline mv_t f_f_floor_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = floor(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = floor(pval1->u.dval)}; return rv; } static inline mv_t f_f_ceil_func(mv_t* pval1) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = ceil(pval1->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = ceil(pval1->u.dval)}; return rv; } // ---------------------------------------------------------------- static inline mv_t f_ff_plus_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = pval1->u.double_val + pval2->u.double_val}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = pval1->u.dval + pval2->u.dval}; return rv; } static inline mv_t f_ff_minus_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = pval1->u.double_val - pval2->u.double_val}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = pval1->u.dval - pval2->u.dval}; return rv; } static inline mv_t f_ff_times_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = pval1->u.double_val * pval2->u.double_val}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = pval1->u.dval * pval2->u.dval}; return rv; } static inline mv_t f_ff_divide_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = pval1->u.double_val / pval2->u.double_val}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = pval1->u.dval / pval2->u.dval}; return rv; } static inline mv_t f_ff_pow_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = pow(pval1->u.double_val, pval2->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = pow(pval1->u.dval, pval2->u.dval)}; return rv; } static inline mv_t f_ff_mod_func(mv_t* pval1, mv_t* pval2) { - long long i1 = (long long)pval1->u.double_val; - long long i2 = (long long)pval2->u.double_val; + long long i1 = (long long)pval1->u.dval; + long long i2 = (long long)pval2->u.dval; long long i3 = i1 % i2; if (i3 < 0) i3 += i2; // C mod is insane - mv_t rv = {.type = MT_DOUBLE, .u.double_val = (double)i3}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = (double)i3}; return rv; } static inline mv_t f_ff_atan2_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.double_val = atan2(pval1->u.double_val, pval2->u.double_val)}; + mv_t rv = {.type = MT_DOUBLE, .u.dval = atan2(pval1->u.dval, pval2->u.dval)}; return rv; }