Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-07-25 17:04:01 +00:00
Code Issues Projects Releases Wiki Activity

will revert

Browse source
This commit is contained in:
John Kerl 2015-05-28 17:08:11 -04:00
parent f5e37c8d4b
commit 6123e8cb6b
4 changed files with 101 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

22
c/mapping/lrec_evaluators.c
View file

@ -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));

4
c/mapping/mapper_filter.c
View file

@ -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);

118
c/mapping/mlr_val.c
View file

@ -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

58
c/mapping/mlr_val.h
View file

@ -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;
}