From 05c7cf1d2ae2cb7dfcf884ce6d97e6329078520c Mon Sep 17 00:00:00 2001 From: John Kerl Date: Sat, 20 Feb 2021 19:07:55 -0500 Subject: [PATCH] rename ma,mb,mc -> input1,input2,input3 in mlrval functions --- go/src/types/mlrval_function_hashing.go | 24 +- go/src/types/mlrval_functions_arithmetic.go | 402 +++++++++---------- go/src/types/mlrval_functions_base.go | 40 +- go/src/types/mlrval_functions_bits.go | 66 +-- go/src/types/mlrval_functions_booleans.go | 256 ++++++------ go/src/types/mlrval_functions_collections.go | 280 ++++++------- go/src/types/mlrval_functions_math.go | 6 +- go/src/types/mlrval_functions_mathlib.go | 144 +++---- go/src/types/mlrval_functions_random.go | 32 +- go/src/types/mlrval_functions_regex.go | 114 +++--- go/src/types/mlrval_functions_sort.go | 60 +-- go/src/types/mlrval_functions_strings.go | 170 ++++---- go/src/types/mlrval_functions_time.go | 26 +- go/src/types/mlrval_functions_types.go | 254 ++++++------ 14 files changed, 937 insertions(+), 937 deletions(-) diff --git a/go/src/types/mlrval_function_hashing.go b/go/src/types/mlrval_function_hashing.go index 934fed5cb..31a0ff808 100644 --- a/go/src/types/mlrval_function_hashing.go +++ b/go/src/types/mlrval_function_hashing.go @@ -8,50 +8,50 @@ import ( "fmt" ) -func MlrvalMD5(ma *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { +func MlrvalMD5(input1 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { return MlrvalFromError() } return MlrvalFromString( fmt.Sprintf( "%x", - md5.Sum([]byte(ma.printrep)), + md5.Sum([]byte(input1.printrep)), ), ) } -func MlrvalSHA1(ma *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { +func MlrvalSHA1(input1 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { return MlrvalFromError() } return MlrvalFromString( fmt.Sprintf( "%x", - sha1.Sum([]byte(ma.printrep)), + sha1.Sum([]byte(input1.printrep)), ), ) } -func MlrvalSHA256(ma *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { +func MlrvalSHA256(input1 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { return MlrvalFromError() } return MlrvalFromString( fmt.Sprintf( "%x", - sha256.Sum256([]byte(ma.printrep)), + sha256.Sum256([]byte(input1.printrep)), ), ) } -func MlrvalSHA512(ma *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { +func MlrvalSHA512(input1 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { return MlrvalFromError() } return MlrvalFromString( fmt.Sprintf( "%x", - sha512.Sum512([]byte(ma.printrep)), + sha512.Sum512([]byte(input1.printrep)), ), ) } diff --git a/go/src/types/mlrval_functions_arithmetic.go b/go/src/types/mlrval_functions_arithmetic.go index 461159465..06c47fc85 100644 --- a/go/src/types/mlrval_functions_arithmetic.go +++ b/go/src/types/mlrval_functions_arithmetic.go @@ -19,19 +19,19 @@ var upos_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _absn1, } -func MlrvalUnaryPlus(ma *Mlrval) Mlrval { - return upos_dispositions[ma.mvtype](ma) +func MlrvalUnaryPlus(input1 *Mlrval) Mlrval { + return upos_dispositions[input1.mvtype](input1) } // ================================================================ // Unary minus operator -func uneg_i_i(ma *Mlrval) Mlrval { - return MlrvalFromInt(-ma.intval) +func uneg_i_i(input1 *Mlrval) Mlrval { + return MlrvalFromInt(-input1.intval) } -func uneg_f_f(ma *Mlrval) Mlrval { - return MlrvalFromFloat64(-ma.floatval) +func uneg_f_f(input1 *Mlrval) Mlrval { + return MlrvalFromFloat64(-input1.floatval) } var uneg_dispositions = [MT_DIM]UnaryFunc{ @@ -46,16 +46,16 @@ var uneg_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _absn1, } -func MlrvalUnaryMinus(ma *Mlrval) Mlrval { - return uneg_dispositions[ma.mvtype](ma) +func MlrvalUnaryMinus(input1 *Mlrval) Mlrval { + return uneg_dispositions[input1.mvtype](input1) } // ================================================================ // Logical NOT operator -func MlrvalLogicalNOT(ma *Mlrval) Mlrval { - if ma.mvtype == MT_BOOL { - return MlrvalFromBool(!ma.boolval) +func MlrvalLogicalNOT(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_BOOL { + return MlrvalFromBool(!input1.boolval) } else { return MlrvalFromError() } @@ -67,9 +67,9 @@ func MlrvalLogicalNOT(ma *Mlrval) Mlrval { // Auto-overflows up to float. Additions & subtractions overflow by at most // one bit so it suffices to check sign-changes. -func plus_n_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func plus_n_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval c := a + b overflowed := false @@ -90,14 +90,14 @@ func plus_n_ii(ma, mb *Mlrval) Mlrval { } } -func plus_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) + mb.floatval) +func plus_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) + input2.floatval) } -func plus_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval + float64(mb.intval)) +func plus_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval + float64(input2.intval)) } -func plus_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval + mb.floatval) +func plus_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval + input2.floatval) } var plus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -113,8 +113,8 @@ var plus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBinaryPlus(ma, mb *Mlrval) Mlrval { - return plus_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalBinaryPlus(input1, input2 *Mlrval) Mlrval { + return plus_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ @@ -123,9 +123,9 @@ func MlrvalBinaryPlus(ma, mb *Mlrval) Mlrval { // Adds & subtracts overflow by at most one bit so it suffices to check // sign-changes. -func minus_n_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func minus_n_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval c := a - b overflowed := false @@ -146,14 +146,14 @@ func minus_n_ii(ma, mb *Mlrval) Mlrval { } } -func minus_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) - mb.floatval) +func minus_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) - input2.floatval) } -func minus_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval - float64(mb.intval)) +func minus_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval - float64(input2.intval)) } -func minus_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval - mb.floatval) +func minus_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval - input2.floatval) } var minus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -169,8 +169,8 @@ var minus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBinaryMinus(ma, mb *Mlrval) Mlrval { - return minus_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalBinaryMinus(input1, input2 *Mlrval) Mlrval { + return minus_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ @@ -206,9 +206,9 @@ func MlrvalBinaryMinus(ma, mb *Mlrval) Mlrval { // double less than 2**63. (An alterative would be to do all integer multiplies // using handcrafted multi-word 128-bit arithmetic). -func times_n_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func times_n_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval c := float64(a) * float64(b) if math.Abs(c) > 9223372036854774784.0 { @@ -218,14 +218,14 @@ func times_n_ii(ma, mb *Mlrval) Mlrval { } } -func times_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) * mb.floatval) +func times_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) * input2.floatval) } -func times_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval * float64(mb.intval)) +func times_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval * float64(input2.intval)) } -func times_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval * mb.floatval) +func times_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval * input2.floatval) } var times_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -241,8 +241,8 @@ var times_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalTimes(ma, mb *Mlrval) Mlrval { - return times_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalTimes(input1, input2 *Mlrval) Mlrval { + return times_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ @@ -262,9 +262,9 @@ func MlrvalTimes(ma, mb *Mlrval) Mlrval { // $ echo 'x=1e-300,y=1e300' | mlr put '$z=$y/$x' // x=1e-300,y=1e300,z=+Inf -func divide_n_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func divide_n_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval if b == 0 { // Compute inf/nan as with floats rather than fatal runtime FPE on integer divide by zero @@ -287,14 +287,14 @@ func divide_n_ii(ma, mb *Mlrval) Mlrval { } } -func divide_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) / mb.floatval) +func divide_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) / input2.floatval) } -func divide_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval / float64(mb.intval)) +func divide_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval / float64(input2.intval)) } -func divide_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval / mb.floatval) +func divide_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval / input2.floatval) } var divide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -310,17 +310,17 @@ var divide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDivide(ma, mb *Mlrval) Mlrval { - return divide_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDivide(input1, input2 *Mlrval) Mlrval { + return divide_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ // Integer division: DSL operator '//' as in Python. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func int_divide_n_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func int_divide_n_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval if b == 0 { // Compute inf/nan as with floats rather than fatal runtime FPE on integer divide by zero @@ -346,14 +346,14 @@ func int_divide_n_ii(ma, mb *Mlrval) Mlrval { return MlrvalFromInt(q) } -func int_divide_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(float64(ma.intval) / mb.floatval)) +func int_divide_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(float64(input1.intval) / input2.floatval)) } -func int_divide_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(ma.floatval / float64(mb.intval))) +func int_divide_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(input1.floatval / float64(input2.intval))) } -func int_divide_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(ma.floatval / mb.floatval)) +func int_divide_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(input1.floatval / input2.floatval)) } var int_divide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -369,25 +369,25 @@ var int_divide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalIntDivide(ma, mb *Mlrval) Mlrval { - return int_divide_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalIntDivide(input1, input2 *Mlrval) Mlrval { + return int_divide_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ // Non-auto-overflowing addition: DSL operator '.+'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func dotplus_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval + mb.intval) +func dotplus_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval + input2.intval) } -func dotplus_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) + mb.floatval) +func dotplus_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) + input2.floatval) } -func dotplus_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval + float64(mb.intval)) +func dotplus_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval + float64(input2.intval)) } -func dotplus_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval + mb.floatval) +func dotplus_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval + input2.floatval) } var dot_plus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -403,25 +403,25 @@ var dot_plus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDotPlus(ma, mb *Mlrval) Mlrval { - return dot_plus_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDotPlus(input1, input2 *Mlrval) Mlrval { + return dot_plus_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ // Non-auto-overflowing subtraction: DSL operator '.-'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func dotminus_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval - mb.intval) +func dotminus_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval - input2.intval) } -func dotminus_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) - mb.floatval) +func dotminus_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) - input2.floatval) } -func dotminus_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval - float64(mb.intval)) +func dotminus_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval - float64(input2.intval)) } -func dotminus_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval - mb.floatval) +func dotminus_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval - input2.floatval) } var dotminus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -437,25 +437,25 @@ var dotminus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDotMinus(ma, mb *Mlrval) Mlrval { - return dotminus_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDotMinus(input1, input2 *Mlrval) Mlrval { + return dotminus_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Non-auto-overflowing multiplication: DSL operator '.*'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func dottimes_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval * mb.intval) +func dottimes_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval * input2.intval) } -func dottimes_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) * mb.floatval) +func dottimes_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) * input2.floatval) } -func dottimes_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval * float64(mb.intval)) +func dottimes_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval * float64(input2.intval)) } -func dottimes_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval * mb.floatval) +func dottimes_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval * input2.floatval) } var dottimes_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -471,25 +471,25 @@ var dottimes_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDotTimes(ma, mb *Mlrval) Mlrval { - return dottimes_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDotTimes(input1, input2 *Mlrval) Mlrval { + return dottimes_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // 64-bit integer division: DSL operator './'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func dotdivide_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval / mb.intval) +func dotdivide_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval / input2.intval) } -func dotdivide_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval) / mb.floatval) +func dotdivide_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval) / input2.floatval) } -func dotdivide_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval / float64(mb.intval)) +func dotdivide_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval / float64(input2.intval)) } -func dotdivide_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(ma.floatval / mb.floatval) +func dotdivide_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(input1.floatval / input2.floatval) } var dotdivide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -505,17 +505,17 @@ var dotdivide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDotDivide(ma, mb *Mlrval) Mlrval { - return dotdivide_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDotDivide(input1, input2 *Mlrval) Mlrval { + return dotdivide_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // 64-bit integer division: DSL operator './/'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func dotidivide_i_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func dotidivide_i_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval if b == 0 { // Compute inf/nan as with floats rather than fatal runtime FPE on integer divide by zero @@ -541,14 +541,14 @@ func dotidivide_i_ii(ma, mb *Mlrval) Mlrval { return MlrvalFromInt(q) } -func dotidivide_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(float64(ma.intval) / mb.floatval)) +func dotidivide_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(float64(input1.intval) / input2.floatval)) } -func dotidivide_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(ma.floatval / float64(mb.intval))) +func dotidivide_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(input1.floatval / float64(input2.intval))) } -func dotidivide_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Floor(ma.floatval / mb.floatval)) +func dotidivide_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Floor(input1.floatval / input2.floatval)) } var dotidivide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -564,16 +564,16 @@ var dotidivide_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalDotIntDivide(ma, mb *Mlrval) Mlrval { - return dotidivide_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDotIntDivide(input1, input2 *Mlrval) Mlrval { + return dotidivide_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Modulus -func modulus_i_ii(ma, mb *Mlrval) Mlrval { - a := ma.intval - b := mb.intval +func modulus_i_ii(input1, input2 *Mlrval) Mlrval { + a := input1.intval + b := input2.intval if b == 0 { // Compute inf/nan as with floats rather than fatal runtime FPE on integer divide by zero @@ -595,21 +595,21 @@ func modulus_i_ii(ma, mb *Mlrval) Mlrval { return MlrvalFromInt(m) } -func modulus_f_fi(ma, mb *Mlrval) Mlrval { - a := ma.floatval - b := float64(mb.intval) +func modulus_f_fi(input1, input2 *Mlrval) Mlrval { + a := input1.floatval + b := float64(input2.intval) return MlrvalFromFloat64(a - b*math.Floor(a/b)) } -func modulus_f_if(ma, mb *Mlrval) Mlrval { - a := float64(ma.intval) - b := mb.floatval +func modulus_f_if(input1, input2 *Mlrval) Mlrval { + a := float64(input1.intval) + b := input2.floatval return MlrvalFromFloat64(a - b*math.Floor(a/b)) } -func modulus_f_ff(ma, mb *Mlrval) Mlrval { - a := ma.floatval - b := mb.floatval +func modulus_f_ff(input1, input2 *Mlrval) Mlrval { + a := input1.floatval + b := input2.floatval return MlrvalFromFloat64(a - b*math.Floor(a/b)) } @@ -626,8 +626,8 @@ var modulus_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalModulus(ma, mb *Mlrval) Mlrval { - return modulus_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalModulus(input1, input2 *Mlrval) Mlrval { + return modulus_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ @@ -675,47 +675,47 @@ func imodexp(a, e, m int) int { return c } -func imodop(ma, mb, mc *Mlrval, iop i_iii_func) Mlrval { - if !ma.IsLegit() { - return *ma +func imodop(input1, input2, input3 *Mlrval, iop i_iii_func) Mlrval { + if !input1.IsLegit() { + return *input1 } - if !mb.IsLegit() { - return *mb + if !input2.IsLegit() { + return *input2 } - if !mc.IsLegit() { - return *mc + if !input3.IsLegit() { + return *input3 } - if !ma.IsInt() { + if !input1.IsInt() { return MlrvalFromError() } - if !mb.IsInt() { + if !input2.IsInt() { return MlrvalFromError() } - if !mc.IsInt() { + if !input3.IsInt() { return MlrvalFromError() } - return MlrvalFromInt(iop(ma.intval, mb.intval, mc.intval)) + return MlrvalFromInt(iop(input1.intval, input2.intval, input3.intval)) } -func MlrvalModAdd(ma, mb, mc *Mlrval) Mlrval { - return imodop(ma, mb, mc, imodadd) +func MlrvalModAdd(input1, input2, input3 *Mlrval) Mlrval { + return imodop(input1, input2, input3, imodadd) } -func MlrvalModSub(ma, mb, mc *Mlrval) Mlrval { - return imodop(ma, mb, mc, imodsub) +func MlrvalModSub(input1, input2, input3 *Mlrval) Mlrval { + return imodop(input1, input2, input3, imodsub) } -func MlrvalModMul(ma, mb, mc *Mlrval) Mlrval { - return imodop(ma, mb, mc, imodmul) +func MlrvalModMul(input1, input2, input3 *Mlrval) Mlrval { + return imodop(input1, input2, input3, imodmul) } -func MlrvalModExp(ma, mb, mc *Mlrval) Mlrval { +func MlrvalModExp(input1, input2, input3 *Mlrval) Mlrval { // Pre-check for negative exponent - if mb.mvtype == MT_INT && mb.intval < 0 { + if input2.mvtype == MT_INT && input2.intval < 0 { return MlrvalFromError() } - return imodop(ma, mb, mc, imodexp) + return imodop(input1, input2, input3, imodexp) } // ================================================================ @@ -733,31 +733,31 @@ func MlrvalModExp(ma, mb, mc *Mlrval) Mlrval { // * empty-null always loses against numbers // ---------------------------------------------------------------- -func min_f_ff(ma, mb *Mlrval) Mlrval { - var a float64 = ma.floatval - var b float64 = mb.floatval +func min_f_ff(input1, input2 *Mlrval) Mlrval { + var a float64 = input1.floatval + var b float64 = input2.floatval return MlrvalFromFloat64(math.Min(a, b)) } -func min_f_fi(ma, mb *Mlrval) Mlrval { - var a float64 = ma.floatval - var b float64 = float64(mb.intval) +func min_f_fi(input1, input2 *Mlrval) Mlrval { + var a float64 = input1.floatval + var b float64 = float64(input2.intval) return MlrvalFromFloat64(math.Min(a, b)) } -func min_f_if(ma, mb *Mlrval) Mlrval { - var a float64 = float64(ma.intval) - var b float64 = mb.floatval +func min_f_if(input1, input2 *Mlrval) Mlrval { + var a float64 = float64(input1.intval) + var b float64 = input2.floatval return MlrvalFromFloat64(math.Min(a, b)) } -func min_i_ii(ma, mb *Mlrval) Mlrval { - var a int = ma.intval - var b int = mb.intval +func min_i_ii(input1, input2 *Mlrval) Mlrval { + var a int = input1.intval + var b int = input2.intval if a < b { - return *ma + return *input1 } else { - return *mb + return *input2 } } @@ -765,21 +765,21 @@ func min_i_ii(ma, mb *Mlrval) Mlrval { // --- + ----- ----- // a=F | min=a min=a // a=T | min=b min=b -func min_b_bb(ma, mb *Mlrval) Mlrval { - if ma.boolval == false { - return *ma +func min_b_bb(input1, input2 *Mlrval) Mlrval { + if input1.boolval == false { + return *input1 } else { - return *mb + return *input2 } } -func min_s_ss(ma, mb *Mlrval) Mlrval { - var a string = ma.printrep - var b string = mb.printrep +func min_s_ss(input1, input2 *Mlrval) Mlrval { + var a string = input1.printrep + var b string = input2.printrep if a < b { - return *ma + return *input1 } else { - return *mb + return *input2 } } @@ -796,8 +796,8 @@ var min_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBinaryMin(ma, mb *Mlrval) Mlrval { - return (min_dispositions[ma.mvtype][mb.mvtype])(ma, mb) +func MlrvalBinaryMin(input1, input2 *Mlrval) Mlrval { + return (min_dispositions[input1.mvtype][input2.mvtype])(input1, input2) } func MlrvalVariadicMin(mlrvals []*Mlrval) Mlrval { @@ -813,31 +813,31 @@ func MlrvalVariadicMin(mlrvals []*Mlrval) Mlrval { } // ---------------------------------------------------------------- -func max_f_ff(ma, mb *Mlrval) Mlrval { - var a float64 = ma.floatval - var b float64 = mb.floatval +func max_f_ff(input1, input2 *Mlrval) Mlrval { + var a float64 = input1.floatval + var b float64 = input2.floatval return MlrvalFromFloat64(math.Max(a, b)) } -func max_f_fi(ma, mb *Mlrval) Mlrval { - var a float64 = ma.floatval - var b float64 = float64(mb.intval) +func max_f_fi(input1, input2 *Mlrval) Mlrval { + var a float64 = input1.floatval + var b float64 = float64(input2.intval) return MlrvalFromFloat64(math.Max(a, b)) } -func max_f_if(ma, mb *Mlrval) Mlrval { - var a float64 = float64(ma.intval) - var b float64 = mb.floatval +func max_f_if(input1, input2 *Mlrval) Mlrval { + var a float64 = float64(input1.intval) + var b float64 = input2.floatval return MlrvalFromFloat64(math.Max(a, b)) } -func max_i_ii(ma, mb *Mlrval) Mlrval { - var a int = ma.intval - var b int = mb.intval +func max_i_ii(input1, input2 *Mlrval) Mlrval { + var a int = input1.intval + var b int = input2.intval if a > b { - return *ma + return *input1 } else { - return *mb + return *input2 } } @@ -845,21 +845,21 @@ func max_i_ii(ma, mb *Mlrval) Mlrval { // --- + ----- ----- // a=F | max=a max=b // a=T | max=a max=b -func max_b_bb(ma, mb *Mlrval) Mlrval { - if mb.boolval == false { - return *ma +func max_b_bb(input1, input2 *Mlrval) Mlrval { + if input2.boolval == false { + return *input1 } else { - return *mb + return *input2 } } -func max_s_ss(ma, mb *Mlrval) Mlrval { - var a string = ma.printrep - var b string = mb.printrep +func max_s_ss(input1, input2 *Mlrval) Mlrval { + var a string = input1.printrep + var b string = input2.printrep if a > b { - return *ma + return *input1 } else { - return *mb + return *input2 } } @@ -876,8 +876,8 @@ var max_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBinaryMax(ma, mb *Mlrval) Mlrval { - return (max_dispositions[ma.mvtype][mb.mvtype])(ma, mb) +func MlrvalBinaryMax(input1, input2 *Mlrval) Mlrval { + return (max_dispositions[input1.mvtype][input2.mvtype])(input1, input2) } func MlrvalVariadicMax(mlrvals []*Mlrval) Mlrval { diff --git a/go/src/types/mlrval_functions_base.go b/go/src/types/mlrval_functions_base.go index aee607c85..667db69cd 100644 --- a/go/src/types/mlrval_functions_base.go +++ b/go/src/types/mlrval_functions_base.go @@ -82,77 +82,77 @@ type ComparatorFunc func(*Mlrval, *Mlrval) int // ---------------------------------------------------------------- // Return error (unary) -func _erro1(ma *Mlrval) Mlrval { +func _erro1(input1 *Mlrval) Mlrval { return MlrvalFromError() } // Return absent (unary) -func _absn1(ma *Mlrval) Mlrval { +func _absn1(input1 *Mlrval) Mlrval { return MlrvalFromAbsent() } // Return void (unary) -func _void1(ma *Mlrval) Mlrval { +func _void1(input1 *Mlrval) Mlrval { return MlrvalFromAbsent() } // Return argument (unary) -func _1u___(ma *Mlrval) Mlrval { - return *ma +func _1u___(input1 *Mlrval) Mlrval { + return *input1 } // ---------------------------------------------------------------- // Return error (binary) -func _erro(ma, mb *Mlrval) Mlrval { +func _erro(input1, input2 *Mlrval) Mlrval { return MlrvalFromError() } // Return absent (binary) -func _absn(ma, mb *Mlrval) Mlrval { +func _absn(input1, input2 *Mlrval) Mlrval { return MlrvalFromAbsent() } // Return void (binary) -func _void(ma, mb *Mlrval) Mlrval { +func _void(input1, input2 *Mlrval) Mlrval { return MlrvalFromVoid() } // Return first argument (binary) -func _1___(ma, mb *Mlrval) Mlrval { - return *ma +func _1___(input1, input2 *Mlrval) Mlrval { + return *input1 } // Return second argument (binary) -func _2___(ma, mb *Mlrval) Mlrval { - return *mb +func _2___(input1, input2 *Mlrval) Mlrval { + return *input2 } // Return first argument, as string (binary) -func _s1__(ma, mb *Mlrval) Mlrval { - return MlrvalFromString(ma.String()) +func _s1__(input1, input2 *Mlrval) Mlrval { + return MlrvalFromString(input1.String()) } // Return second argument, as string (binary) -func _s2__(ma, mb *Mlrval) Mlrval { - return MlrvalFromString(mb.String()) +func _s2__(input1, input2 *Mlrval) Mlrval { + return MlrvalFromString(input2.String()) } // Return integer zero (binary) -func _i0__(ma, mb *Mlrval) Mlrval { +func _i0__(input1, input2 *Mlrval) Mlrval { return MlrvalFromInt(0) } // Return float zero (binary) -func _f0__(ma, mb *Mlrval) Mlrval { +func _f0__(input1, input2 *Mlrval) Mlrval { return MlrvalFromFloat64(0.0) } // Return boolean true (binary) -func _true(ma, mb *Mlrval) Mlrval { +func _true(input1, input2 *Mlrval) Mlrval { return MlrvalFromBool(true) } // Return boolean false (binary) -func _fals(ma, mb *Mlrval) Mlrval { +func _fals(input1, input2 *Mlrval) Mlrval { return MlrvalFromBool(false) } diff --git a/go/src/types/mlrval_functions_bits.go b/go/src/types/mlrval_functions_bits.go index 620a9e805..989100dfe 100644 --- a/go/src/types/mlrval_functions_bits.go +++ b/go/src/types/mlrval_functions_bits.go @@ -3,8 +3,8 @@ package types // ================================================================ // Bitwise NOT -func bitwise_not_i_i(ma *Mlrval) Mlrval { - return MlrvalFromInt(^ma.intval) +func bitwise_not_i_i(input1 *Mlrval) Mlrval { + return MlrvalFromInt(^input1.intval) } var bitwise_not_dispositions = [MT_DIM]UnaryFunc{ @@ -19,8 +19,8 @@ var bitwise_not_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _absn1, } -func MlrvalBitwiseNOT(ma *Mlrval) Mlrval { - return bitwise_not_dispositions[ma.mvtype](ma) +func MlrvalBitwiseNOT(input1 *Mlrval) Mlrval { + return bitwise_not_dispositions[input1.mvtype](input1) } // ================================================================ @@ -34,8 +34,8 @@ const _m08 uint64 = 0x00ff00ff00ff00ff const _m16 uint64 = 0x0000ffff0000ffff const _m32 uint64 = 0x00000000ffffffff -func bitcount_i_i(ma *Mlrval) Mlrval { - a := uint64(ma.intval) +func bitcount_i_i(input1 *Mlrval) Mlrval { + a := uint64(input1.intval) a = (a & _m01) + ((a >> 1) & _m01) a = (a & _m02) + ((a >> 2) & _m02) a = (a & _m04) + ((a >> 4) & _m04) @@ -57,15 +57,15 @@ var bitcount_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _absn1, } -func MlrvalBitCount(ma *Mlrval) Mlrval { - return bitcount_dispositions[ma.mvtype](ma) +func MlrvalBitCount(input1 *Mlrval) Mlrval { + return bitcount_dispositions[input1.mvtype](input1) } // ================================================================ // Bitwise AND -func bitwise_and_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval & mb.intval) +func bitwise_and_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval & input2.intval) } var bitwise_and_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -81,15 +81,15 @@ var bitwise_and_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBitwiseAND(ma, mb *Mlrval) Mlrval { - return bitwise_and_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalBitwiseAND(input1, input2 *Mlrval) Mlrval { + return bitwise_and_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Bitwise OR -func bitwise_or_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval | mb.intval) +func bitwise_or_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval | input2.intval) } var bitwise_or_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -105,15 +105,15 @@ var bitwise_or_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBitwiseOR(ma, mb *Mlrval) Mlrval { - return bitwise_or_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalBitwiseOR(input1, input2 *Mlrval) Mlrval { + return bitwise_or_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Bitwise XOR -func bitwise_xor_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval ^ mb.intval) +func bitwise_xor_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval ^ input2.intval) } var bitwise_xor_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -129,15 +129,15 @@ var bitwise_xor_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalBitwiseXOR(ma, mb *Mlrval) Mlrval { - return bitwise_xor_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalBitwiseXOR(input1, input2 *Mlrval) Mlrval { + return bitwise_xor_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Left shift -func lsh_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval << uint64(mb.intval)) +func lsh_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval << uint64(input2.intval)) } var left_shift_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -153,15 +153,15 @@ var left_shift_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalLeftShift(ma, mb *Mlrval) Mlrval { - return left_shift_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalLeftShift(input1, input2 *Mlrval) Mlrval { + return left_shift_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Signed right shift -func srsh_i_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromInt(ma.intval >> uint64(mb.intval)) +func srsh_i_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromInt(input1.intval >> uint64(input2.intval)) } var signed_right_shift_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -177,16 +177,16 @@ var signed_right_shift_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalSignedRightShift(ma, mb *Mlrval) Mlrval { - return signed_right_shift_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalSignedRightShift(input1, input2 *Mlrval) Mlrval { + return signed_right_shift_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ---------------------------------------------------------------- // Unsigned right shift -func ursh_i_ii(ma, mb *Mlrval) Mlrval { - var ua uint64 = uint64(ma.intval) - var ub uint64 = uint64(mb.intval) +func ursh_i_ii(input1, input2 *Mlrval) Mlrval { + var ua uint64 = uint64(input1.intval) + var ub uint64 = uint64(input2.intval) var uc = ua >> ub return MlrvalFromInt(int(uc)) } @@ -204,6 +204,6 @@ var unsigned_right_shift_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalUnsignedRightShift(ma, mb *Mlrval) Mlrval { - return unsigned_right_shift_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalUnsignedRightShift(input1, input2 *Mlrval) Mlrval { + return unsigned_right_shift_dispositions[input1.mvtype][input2.mvtype](input1, input2) } diff --git a/go/src/types/mlrval_functions_booleans.go b/go/src/types/mlrval_functions_booleans.go index 5d461f346..3b1f280db 100644 --- a/go/src/types/mlrval_functions_booleans.go +++ b/go/src/types/mlrval_functions_booleans.go @@ -9,173 +9,173 @@ import ( ) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_ss(ma *Mlrval, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep == mb.printrep) +func eq_b_ss(input1 *Mlrval, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep == input2.printrep) } -func ne_b_ss(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep != mb.printrep) +func ne_b_ss(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep != input2.printrep) } -func gt_b_ss(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep > mb.printrep) +func gt_b_ss(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep > input2.printrep) } -func ge_b_ss(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep >= mb.printrep) +func ge_b_ss(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep >= input2.printrep) } -func lt_b_ss(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep < mb.printrep) +func lt_b_ss(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep < input2.printrep) } -func le_b_ss(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep <= mb.printrep) +func le_b_ss(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep <= input2.printrep) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() == mb.printrep) +func eq_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() == input2.printrep) } -func ne_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() != mb.printrep) +func ne_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() != input2.printrep) } -func gt_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() > mb.printrep) +func gt_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() > input2.printrep) } -func ge_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() >= mb.printrep) +func ge_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() >= input2.printrep) } -func lt_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() < mb.printrep) +func lt_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() < input2.printrep) } -func le_b_xs(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.String() <= mb.printrep) +func le_b_xs(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.String() <= input2.printrep) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep == mb.String()) +func eq_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep == input2.String()) } -func ne_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep != mb.String()) +func ne_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep != input2.String()) } -func gt_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep > mb.String()) +func gt_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep > input2.String()) } -func ge_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep >= mb.String()) +func ge_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep >= input2.String()) } -func lt_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep < mb.String()) +func lt_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep < input2.String()) } -func le_b_sx(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.printrep <= mb.String()) +func le_b_sx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.printrep <= input2.String()) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval == mb.intval) +func eq_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval == input2.intval) } -func ne_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval != mb.intval) +func ne_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval != input2.intval) } -func gt_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval > mb.intval) +func gt_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval > input2.intval) } -func ge_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval >= mb.intval) +func ge_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval >= input2.intval) } -func lt_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval < mb.intval) +func lt_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval < input2.intval) } -func le_b_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval <= mb.intval) +func le_b_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval <= input2.intval) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) == mb.floatval) +func eq_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) == input2.floatval) } -func ne_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) != mb.floatval) +func ne_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) != input2.floatval) } -func gt_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) > mb.floatval) +func gt_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) > input2.floatval) } -func ge_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) >= mb.floatval) +func ge_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) >= input2.floatval) } -func lt_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) < mb.floatval) +func lt_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) < input2.floatval) } -func le_b_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(float64(ma.intval) <= mb.floatval) +func le_b_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(float64(input1.intval) <= input2.floatval) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval == float64(mb.intval)) +func eq_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval == float64(input2.intval)) } -func ne_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval != float64(mb.intval)) +func ne_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval != float64(input2.intval)) } -func gt_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval > float64(mb.intval)) +func gt_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval > float64(input2.intval)) } -func ge_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval >= float64(mb.intval)) +func ge_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval >= float64(input2.intval)) } -func lt_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval < float64(mb.intval)) +func lt_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval < float64(input2.intval)) } -func le_b_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval <= float64(mb.intval)) +func le_b_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval <= float64(input2.intval)) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval == mb.floatval) +func eq_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval == input2.floatval) } -func ne_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval != mb.floatval) +func ne_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval != input2.floatval) } -func gt_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval > mb.floatval) +func gt_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval > input2.floatval) } -func ge_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval >= mb.floatval) +func ge_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval >= input2.floatval) } -func lt_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval < mb.floatval) +func lt_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval < input2.floatval) } -func le_b_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval <= mb.floatval) +func le_b_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval <= input2.floatval) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.boolval == mb.boolval) +func eq_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.boolval == input2.boolval) } -func ne_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.boolval != mb.boolval) +func ne_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.boolval != input2.boolval) } // We could say ordering on bool is error, but, Miller allows // sorting on bool so it should allow ordering on bool. -func gt_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(lib.BoolToInt(ma.boolval) > lib.BoolToInt(mb.boolval)) +func gt_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(lib.BoolToInt(input1.boolval) > lib.BoolToInt(input2.boolval)) } -func ge_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(lib.BoolToInt(ma.boolval) >= lib.BoolToInt(mb.boolval)) +func ge_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(lib.BoolToInt(input1.boolval) >= lib.BoolToInt(input2.boolval)) } -func lt_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(lib.BoolToInt(ma.boolval) < lib.BoolToInt(mb.boolval)) +func lt_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(lib.BoolToInt(input1.boolval) < lib.BoolToInt(input2.boolval)) } -func le_b_bb(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(lib.BoolToInt(ma.boolval) <= lib.BoolToInt(mb.boolval)) +func le_b_bb(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(lib.BoolToInt(input1.boolval) <= lib.BoolToInt(input2.boolval)) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_aa(ma, mb *Mlrval) Mlrval { - a := ma.arrayval - b := mb.arrayval +func eq_b_aa(input1, input2 *Mlrval) Mlrval { + a := input1.arrayval + b := input2.arrayval // Different-length arrays are not equal if len(a) != len(b) { @@ -192,17 +192,17 @@ func eq_b_aa(ma, mb *Mlrval) Mlrval { return MlrvalFromBool(true) } -func ne_b_aa(ma, mb *Mlrval) Mlrval { - eq := eq_b_aa(ma, mb) +func ne_b_aa(input1, input2 *Mlrval) Mlrval { + eq := eq_b_aa(input1, input2) return MlrvalFromBool(!eq.boolval) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -func eq_b_mm(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(ma.mapval.Equals(mb.mapval)) +func eq_b_mm(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mapval.Equals(input2.mapval)) } -func ne_b_mm(ma, mb *Mlrval) Mlrval { - return MlrvalFromBool(!ma.mapval.Equals(mb.mapval)) +func ne_b_mm(input1, input2 *Mlrval) Mlrval { + return MlrvalFromBool(!input1.mapval.Equals(input2.mapval)) } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -303,53 +303,53 @@ var le_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_erro, _absn, _fals, _fals, _fals, _fals, _fals, _fals, _erro}, } -func MlrvalEquals(ma, mb *Mlrval) Mlrval { - return eq_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalEquals(input1, input2 *Mlrval) Mlrval { + return eq_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func MlrvalNotEquals(ma, mb *Mlrval) Mlrval { - return ne_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalNotEquals(input1, input2 *Mlrval) Mlrval { + return ne_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func MlrvalGreaterThan(ma, mb *Mlrval) Mlrval { - return gt_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalGreaterThan(input1, input2 *Mlrval) Mlrval { + return gt_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func MlrvalGreaterThanOrEquals(ma, mb *Mlrval) Mlrval { - return ge_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalGreaterThanOrEquals(input1, input2 *Mlrval) Mlrval { + return ge_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func MlrvalLessThan(ma, mb *Mlrval) Mlrval { - return lt_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalLessThan(input1, input2 *Mlrval) Mlrval { + return lt_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func MlrvalLessThanOrEquals(ma, mb *Mlrval) Mlrval { - return le_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalLessThanOrEquals(input1, input2 *Mlrval) Mlrval { + return le_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // For Go's sort.Slice -func MlrvalLessThanForSort(ma, mb *Mlrval) bool { - mretval := lt_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalLessThanForSort(input1, input2 *Mlrval) bool { + mretval := lt_dispositions[input1.mvtype][input2.mvtype](input1, input2) retval, ok := mretval.GetBoolValue() lib.InternalCodingErrorIf(!ok) return retval } // ---------------------------------------------------------------- -func MlrvalLogicalAND(ma, mb *Mlrval) Mlrval { - if ma.mvtype == MT_BOOL && mb.mvtype == MT_BOOL { - return MlrvalFromBool(ma.boolval && mb.boolval) +func MlrvalLogicalAND(input1, input2 *Mlrval) Mlrval { + if input1.mvtype == MT_BOOL && input2.mvtype == MT_BOOL { + return MlrvalFromBool(input1.boolval && input2.boolval) } else { return MlrvalFromError() } } -func MlrvalLogicalOR(ma, mb *Mlrval) Mlrval { - if ma.mvtype == MT_BOOL && mb.mvtype == MT_BOOL { - return MlrvalFromBool(ma.boolval || mb.boolval) +func MlrvalLogicalOR(input1, input2 *Mlrval) Mlrval { + if input1.mvtype == MT_BOOL && input2.mvtype == MT_BOOL { + return MlrvalFromBool(input1.boolval || input2.boolval) } else { return MlrvalFromError() } } -func MlrvalLogicalXOR(ma, mb *Mlrval) Mlrval { - if ma.mvtype == MT_BOOL && mb.mvtype == MT_BOOL { - return MlrvalFromBool(ma.boolval != mb.boolval) +func MlrvalLogicalXOR(input1, input2 *Mlrval) Mlrval { + if input1.mvtype == MT_BOOL && input2.mvtype == MT_BOOL { + return MlrvalFromBool(input1.boolval != input2.boolval) } else { return MlrvalFromError() } diff --git a/go/src/types/mlrval_functions_collections.go b/go/src/types/mlrval_functions_collections.go index 64f1372ad..f129af9bc 100644 --- a/go/src/types/mlrval_functions_collections.go +++ b/go/src/types/mlrval_functions_collections.go @@ -10,8 +10,8 @@ import ( // ================================================================ // Map/array count. Scalars (including strings) have length 1. -func MlrvalLength(ma *Mlrval) Mlrval { - switch ma.mvtype { +func MlrvalLength(input1 *Mlrval) Mlrval { + switch input1.mvtype { case MT_ERROR: return MlrvalFromInt(0) break @@ -19,19 +19,19 @@ func MlrvalLength(ma *Mlrval) Mlrval { return MlrvalFromInt(0) break case MT_ARRAY: - return MlrvalFromInt(int(len(ma.arrayval))) + return MlrvalFromInt(int(len(input1.arrayval))) break case MT_MAP: - return MlrvalFromInt(int(ma.mapval.FieldCount)) + return MlrvalFromInt(int(input1.mapval.FieldCount)) break } return MlrvalFromInt(1) } // ================================================================ -func depth_from_array(ma *Mlrval) Mlrval { +func depth_from_array(input1 *Mlrval) Mlrval { maxChildDepth := 0 - for _, child := range ma.arrayval { + for _, child := range input1.arrayval { childDepth := MlrvalDepth(&child) iChildDepth := int(childDepth.intval) if iChildDepth > maxChildDepth { @@ -41,9 +41,9 @@ func depth_from_array(ma *Mlrval) Mlrval { return MlrvalFromInt(int(1 + maxChildDepth)) } -func depth_from_map(ma *Mlrval) Mlrval { +func depth_from_map(input1 *Mlrval) Mlrval { maxChildDepth := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { child := pe.Value childDepth := MlrvalDepth(child) iChildDepth := int(childDepth.intval) @@ -54,7 +54,7 @@ func depth_from_map(ma *Mlrval) Mlrval { return MlrvalFromInt(int(1 + maxChildDepth)) } -func depth_from_scalar(ma *Mlrval) Mlrval { +func depth_from_scalar(input1 *Mlrval) Mlrval { return MlrvalFromInt(0) } @@ -76,14 +76,14 @@ func init() { } } -func MlrvalDepth(ma *Mlrval) Mlrval { - return depth_dispositions[ma.mvtype](ma) +func MlrvalDepth(input1 *Mlrval) Mlrval { + return depth_dispositions[input1.mvtype](input1) } // ================================================================ -func leafcount_from_array(ma *Mlrval) Mlrval { +func leafcount_from_array(input1 *Mlrval) Mlrval { sumChildLeafCount := 0 - for _, child := range ma.arrayval { + for _, child := range input1.arrayval { // Golang initialization loop if we do this :( // childLeafCount := MlrvalLeafCount(&child) @@ -100,9 +100,9 @@ func leafcount_from_array(ma *Mlrval) Mlrval { return MlrvalFromInt(int(sumChildLeafCount)) } -func leafcount_from_map(ma *Mlrval) Mlrval { +func leafcount_from_map(input1 *Mlrval) Mlrval { sumChildLeafCount := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { child := pe.Value // Golang initialization loop if we do this :( @@ -121,7 +121,7 @@ func leafcount_from_map(ma *Mlrval) Mlrval { return MlrvalFromInt(int(sumChildLeafCount)) } -func leafcount_from_scalar(ma *Mlrval) Mlrval { +func leafcount_from_scalar(input1 *Mlrval) Mlrval { return MlrvalFromInt(1) } @@ -137,35 +137,35 @@ var leafcount_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ leafcount_from_map, } -func MlrvalLeafCount(ma *Mlrval) Mlrval { - return leafcount_dispositions[ma.mvtype](ma) +func MlrvalLeafCount(input1 *Mlrval) Mlrval { + return leafcount_dispositions[input1.mvtype](input1) } // ---------------------------------------------------------------- -func has_key_in_array(ma, mb *Mlrval) Mlrval { - if mb.mvtype == MT_STRING { +func has_key_in_array(input1, input2 *Mlrval) Mlrval { + if input2.mvtype == MT_STRING { return MlrvalFromFalse() } - if mb.mvtype != MT_INT { + if input2.mvtype != MT_INT { return MlrvalFromError() } - _, ok := UnaliasArrayIndex(&ma.arrayval, mb.intval) + _, ok := UnaliasArrayIndex(&input1.arrayval, input2.intval) return MlrvalFromBool(ok) } -func has_key_in_map(ma, mb *Mlrval) Mlrval { - if mb.mvtype == MT_STRING || mb.mvtype == MT_INT { - return MlrvalFromBool(ma.mapval.Has(mb.String())) +func has_key_in_map(input1, input2 *Mlrval) Mlrval { + if input2.mvtype == MT_STRING || input2.mvtype == MT_INT { + return MlrvalFromBool(input1.mapval.Has(input2.String())) } else { return MlrvalFromError() } } -func MlrvalHasKey(ma, mb *Mlrval) Mlrval { - if ma.mvtype == MT_ARRAY { - return has_key_in_array(ma, mb) - } else if ma.mvtype == MT_MAP { - return has_key_in_map(ma, mb) +func MlrvalHasKey(input1, input2 *Mlrval) Mlrval { + if input1.mvtype == MT_ARRAY { + return has_key_in_array(input1, input2) + } else if input1.mvtype == MT_MAP { + return has_key_in_map(input1, input2) } else { return MlrvalFromError() } @@ -294,15 +294,15 @@ func MlrvalMapDiff(mlrvals []*Mlrval) Mlrval { // ================================================================ // joink([1,2,3], ",") -> "1,2,3" // joink({"a":3,"b":4,"c":5}, ",") -> "a,b,c" -func MlrvalJoinK(ma, mb *Mlrval) Mlrval { - if mb.mvtype != MT_STRING { +func MlrvalJoinK(input1, input2 *Mlrval) Mlrval { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mb.printrep - if ma.mvtype == MT_MAP { + fieldSeparator := input2.printrep + if input1.mvtype == MT_MAP { var buffer bytes.Buffer - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { buffer.WriteString(pe.Key) if pe.Next != nil { buffer.WriteString(fieldSeparator) @@ -310,10 +310,10 @@ func MlrvalJoinK(ma, mb *Mlrval) Mlrval { } return MlrvalFromString(buffer.String()) - } else if ma.mvtype == MT_ARRAY { + } else if input1.mvtype == MT_ARRAY { var buffer bytes.Buffer - for i, _ := range ma.arrayval { + for i, _ := range input1.arrayval { if i > 0 { buffer.WriteString(fieldSeparator) } @@ -330,16 +330,16 @@ func MlrvalJoinK(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // joinv([3,4,5], ",") -> "3,4,5" // joinv({"a":3,"b":4,"c":5}, ",") -> "3,4,5" -func MlrvalJoinV(ma, mb *Mlrval) Mlrval { - if mb.mvtype != MT_STRING { +func MlrvalJoinV(input1, input2 *Mlrval) Mlrval { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mb.printrep + fieldSeparator := input2.printrep - if ma.mvtype == MT_MAP { + if input1.mvtype == MT_MAP { var buffer bytes.Buffer - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { buffer.WriteString(pe.Value.String()) if pe.Next != nil { buffer.WriteString(fieldSeparator) @@ -347,10 +347,10 @@ func MlrvalJoinV(ma, mb *Mlrval) Mlrval { } return MlrvalFromString(buffer.String()) - } else if ma.mvtype == MT_ARRAY { + } else if input1.mvtype == MT_ARRAY { var buffer bytes.Buffer - for i, element := range ma.arrayval { + for i, element := range input1.arrayval { if i > 0 { buffer.WriteString(fieldSeparator) } @@ -366,20 +366,20 @@ func MlrvalJoinV(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // joinkv([3,4,5], "=", ",") -> "1=3,2=4,3=5" // joinkv({"a":3,"b":4,"c":5}, "=", ",") -> "a=3,b=4,c=5" -func MlrvalJoinKV(ma, mb, mc *Mlrval) Mlrval { - if mb.mvtype != MT_STRING { +func MlrvalJoinKV(input1, input2, input3 *Mlrval) Mlrval { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - pairSeparator := mb.printrep - if mc.mvtype != MT_STRING { + pairSeparator := input2.printrep + if input3.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mc.printrep + fieldSeparator := input3.printrep - if ma.mvtype == MT_MAP { + if input1.mvtype == MT_MAP { var buffer bytes.Buffer - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { buffer.WriteString(pe.Key) buffer.WriteString(pairSeparator) buffer.WriteString(pe.Value.String()) @@ -389,10 +389,10 @@ func MlrvalJoinKV(ma, mb, mc *Mlrval) Mlrval { } return MlrvalFromString(buffer.String()) - } else if ma.mvtype == MT_ARRAY { + } else if input1.mvtype == MT_ARRAY { var buffer bytes.Buffer - for i, element := range ma.arrayval { + for i, element := range input1.arrayval { if i > 0 { buffer.WriteString(fieldSeparator) } @@ -410,22 +410,22 @@ func MlrvalJoinKV(ma, mb, mc *Mlrval) Mlrval { // ================================================================ // splitkv("a=3,b=4,c=5", "=", ",") -> {"a":3,"b":4,"c":5} -func MlrvalSplitKV(ma, mb, mc *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitKV(input1, input2, input3 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - pairSeparator := mb.printrep - if mc.mvtype != MT_STRING { + pairSeparator := input2.printrep + if input3.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mc.printrep + fieldSeparator := input3.printrep retval := MlrvalEmptyMap() - fields := lib.SplitString(ma.printrep, fieldSeparator) + fields := lib.SplitString(input1.printrep, fieldSeparator) for i, field := range fields { pair := strings.SplitN(field, pairSeparator, 2) if len(pair) == 1 { @@ -446,22 +446,22 @@ func MlrvalSplitKV(ma, mb, mc *Mlrval) Mlrval { // ---------------------------------------------------------------- // splitkvx("a=3,b=4,c=5", "=", ",") -> {"a":"3","b":"4","c":"5"} -func MlrvalSplitKVX(ma, mb, mc *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitKVX(input1, input2, input3 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - pairSeparator := mb.printrep - if mc.mvtype != MT_STRING { + pairSeparator := input2.printrep + if input3.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mc.printrep + fieldSeparator := input3.printrep retval := MlrvalEmptyMap() - fields := lib.SplitString(ma.printrep, fieldSeparator) + fields := lib.SplitString(input1.printrep, fieldSeparator) for i, field := range fields { pair := strings.SplitN(field, pairSeparator, 2) if len(pair) == 1 { @@ -482,17 +482,17 @@ func MlrvalSplitKVX(ma, mb, mc *Mlrval) Mlrval { // ---------------------------------------------------------------- // splitnv("a,b,c", ",") -> {"1":"a","2":"b","3":"c"} -func MlrvalSplitNV(ma, mb *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitNV(input1, input2 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } retval := MlrvalEmptyMap() - fields := lib.SplitString(ma.printrep, mb.printrep) + fields := lib.SplitString(input1.printrep, input2.printrep) for i, field := range fields { key := strconv.Itoa(i + 1) // Miller user-space indices are 1-up value := MlrvalFromInferredType(field) @@ -504,17 +504,17 @@ func MlrvalSplitNV(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // splitnvx("3,4,5", ",") -> {"1":"3","2":"4","3":"5"} -func MlrvalSplitNVX(ma, mb *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitNVX(input1, input2 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } retval := MlrvalEmptyMap() - fields := lib.SplitString(ma.printrep, mb.printrep) + fields := lib.SplitString(input1.printrep, input2.printrep) for i, field := range fields { key := strconv.Itoa(i + 1) // Miller user-space indices are 1-up value := MlrvalFromString(field) @@ -526,16 +526,16 @@ func MlrvalSplitNVX(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // splita("3,4,5", ",") -> [3,4,5] -func MlrvalSplitA(ma, mb *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitA(input1, input2 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - fieldSeparator := mb.printrep + fieldSeparator := input2.printrep - fields := lib.SplitString(ma.printrep, fieldSeparator) + fields := lib.SplitString(input1.printrep, fieldSeparator) retval := NewSizedMlrvalArray(int(len(fields))) @@ -550,15 +550,15 @@ func MlrvalSplitA(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // splitax("3,4,5", ",") -> ["3","4","5"] -func MlrvalSplitAX(ma, mb *Mlrval) Mlrval { - if ma.mvtype != MT_STRING { +func MlrvalSplitAX(input1, input2 *Mlrval) Mlrval { + if input1.mvtype != MT_STRING { return MlrvalFromError() } - if mb.mvtype != MT_STRING { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - input := ma.printrep - fieldSeparator := mb.printrep + input := input1.printrep + fieldSeparator := input2.printrep return *mlrvalSplitAXHelper(input, fieldSeparator) } @@ -578,19 +578,19 @@ func mlrvalSplitAXHelper(input string, separator string) *Mlrval { } // ---------------------------------------------------------------- -func MlrvalGetKeys(ma *Mlrval) Mlrval { - if ma.mvtype == MT_MAP { - retval := NewSizedMlrvalArray(ma.mapval.FieldCount) +func MlrvalGetKeys(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_MAP { + retval := NewSizedMlrvalArray(input1.mapval.FieldCount) i := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { retval.arrayval[i] = MlrvalFromString(pe.Key) i++ } return *retval - } else if ma.mvtype == MT_ARRAY { - retval := NewSizedMlrvalArray(int(len(ma.arrayval))) - for i, _ := range ma.arrayval { + } else if input1.mvtype == MT_ARRAY { + retval := NewSizedMlrvalArray(int(len(input1.arrayval))) + for i, _ := range input1.arrayval { retval.arrayval[i] = MlrvalFromInt(int(i + 1)) // Miller user-space indices are 1-up } return *retval @@ -601,19 +601,19 @@ func MlrvalGetKeys(ma *Mlrval) Mlrval { } // ---------------------------------------------------------------- -func MlrvalGetValues(ma *Mlrval) Mlrval { - if ma.mvtype == MT_MAP { - retval := NewSizedMlrvalArray(ma.mapval.FieldCount) +func MlrvalGetValues(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_MAP { + retval := NewSizedMlrvalArray(input1.mapval.FieldCount) i := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { retval.arrayval[i] = *pe.Value.Copy() i++ } return *retval - } else if ma.mvtype == MT_ARRAY { - retval := NewSizedMlrvalArray(int(len(ma.arrayval))) - for i, value := range ma.arrayval { + } else if input1.mvtype == MT_ARRAY { + retval := NewSizedMlrvalArray(int(len(input1.arrayval))) + for i, value := range input1.arrayval { retval.arrayval[i] = *value.Copy() } return *retval @@ -624,13 +624,13 @@ func MlrvalGetValues(ma *Mlrval) Mlrval { } // ---------------------------------------------------------------- -func MlrvalAppend(ma, mb *Mlrval) Mlrval { - if ma.mvtype != MT_ARRAY { +func MlrvalAppend(input1, input2 *Mlrval) Mlrval { + if input1.mvtype != MT_ARRAY { return MlrvalFromError() } - macopy := ma.Copy() - mbcopy := mb.Copy() + macopy := input1.Copy() + mbcopy := input2.Copy() macopy.ArrayAppend(mbcopy) return *macopy } @@ -641,41 +641,41 @@ func MlrvalAppend(ma, mb *Mlrval) Mlrval { // Third argument is map or array. // flatten("a", ".", {"b": { "c": 4 }}) is {"a.b.c" : 4}. // flatten("", ".", {"a": { "b": 3 }}) is {"a.b" : 3}. -func MlrvalFlatten(ma, mb, mc *Mlrval) Mlrval { - if mc.mvtype == MT_MAP || mc.mvtype == MT_ARRAY { - if ma.mvtype != MT_STRING && ma.mvtype != MT_VOID { +func MlrvalFlatten(input1, input2, input3 *Mlrval) Mlrval { + if input3.mvtype == MT_MAP || input3.mvtype == MT_ARRAY { + if input1.mvtype != MT_STRING && input1.mvtype != MT_VOID { return MlrvalFromError() } - prefix := ma.printrep - if mb.mvtype != MT_STRING { + prefix := input1.printrep + if input2.mvtype != MT_STRING { return MlrvalFromError() } - delimiter := mb.printrep + delimiter := input2.printrep - return mc.FlattenToMap(prefix, delimiter) + return input3.FlattenToMap(prefix, delimiter) } else { - return *mc + return *input3 } } // flatten($*, ".") is the same as flatten("", ".", $*) -func MlrvalFlattenBinary(ma, mb *Mlrval) Mlrval { - return MlrvalFlatten(MlrvalPointerFromVoid(), mb, ma) +func MlrvalFlattenBinary(input1, input2 *Mlrval) Mlrval { + return MlrvalFlatten(MlrvalPointerFromVoid(), input2, input1) } // ---------------------------------------------------------------- // First argument is a map. // Second argument is a delimiter string. // unflatten({"a.b.c", ".") is {"a": { "b": { "c": 4}}}. -func MlrvalUnflatten(ma, mb *Mlrval) Mlrval { - if mb.mvtype != MT_STRING { +func MlrvalUnflatten(input1, input2 *Mlrval) Mlrval { + if input2.mvtype != MT_STRING { return MlrvalFromError() } - if ma.mvtype != MT_MAP { - return *ma + if input1.mvtype != MT_MAP { + return *input1 } - oldmap := ma.mapval - separator := mb.printrep + oldmap := input1.mapval + separator := input2.printrep newmap := NewMlrmap() for pe := oldmap.Head; pe != nil; pe = pe.Next { @@ -688,11 +688,11 @@ func MlrvalUnflatten(ma, mb *Mlrval) Mlrval { // ---------------------------------------------------------------- // Converts maps with "1", "2", ... keys into arrays. Recurses nested data structures. -func MlrvalArrayify(ma *Mlrval) Mlrval { - if ma.mvtype == MT_MAP { +func MlrvalArrayify(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_MAP { convertible := true i := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { sval := strconv.Itoa(i + 1) // Miller user-space indices are 1-up i++ if pe.Key != sval { @@ -703,38 +703,38 @@ func MlrvalArrayify(ma *Mlrval) Mlrval { } if convertible { - arrayval := make([]Mlrval, ma.mapval.FieldCount) + arrayval := make([]Mlrval, input1.mapval.FieldCount) i := 0 - for pe := ma.mapval.Head; pe != nil; pe = pe.Next { + for pe := input1.mapval.Head; pe != nil; pe = pe.Next { arrayval[i] = *pe.Value.Copy() i++ } return MlrvalFromArrayLiteralReference(arrayval) } else { - return *ma + return *input1 } - } else if ma.mvtype == MT_ARRAY { - for i, _ := range ma.arrayval { - ma.arrayval[i] = MlrvalArrayify(&ma.arrayval[i]) + } else if input1.mvtype == MT_ARRAY { + for i, _ := range input1.arrayval { + input1.arrayval[i] = MlrvalArrayify(&input1.arrayval[i]) } - return *ma + return *input1 } else { - return *ma + return *input1 } } // ---------------------------------------------------------------- -func MlrvalJSONParse(ma *Mlrval) Mlrval { - if ma.mvtype == MT_VOID { - return *ma - } else if ma.mvtype != MT_STRING { +func MlrvalJSONParse(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_VOID { + return *input1 + } else if input1.mvtype != MT_STRING { return MlrvalFromError() } else { output := MlrvalFromPending() - err := output.UnmarshalJSON([]byte(ma.printrep)) + err := output.UnmarshalJSON([]byte(input1.printrep)) if err == nil { return output } else { @@ -743,8 +743,8 @@ func MlrvalJSONParse(ma *Mlrval) Mlrval { } } -func MlrvalJSONStringifyUnary(ma *Mlrval) Mlrval { - outputBytes, err := ma.MarshalJSON(JSON_SINGLE_LINE) +func MlrvalJSONStringifyUnary(input1 *Mlrval) Mlrval { + outputBytes, err := input1.MarshalJSON(JSON_SINGLE_LINE) if err != nil { return MlrvalFromError() } else { @@ -752,9 +752,9 @@ func MlrvalJSONStringifyUnary(ma *Mlrval) Mlrval { } } -func MlrvalJSONStringifyBinary(ma, mb *Mlrval) Mlrval { +func MlrvalJSONStringifyBinary(input1, input2 *Mlrval) Mlrval { var jsonFormatting TJSONFormatting = JSON_SINGLE_LINE - useMultiline, ok := mb.GetBoolValue() + useMultiline, ok := input2.GetBoolValue() if !ok { return MlrvalFromError() } @@ -762,7 +762,7 @@ func MlrvalJSONStringifyBinary(ma, mb *Mlrval) Mlrval { jsonFormatting = JSON_MULTILINE } - outputBytes, err := ma.MarshalJSON(jsonFormatting) + outputBytes, err := input1.MarshalJSON(jsonFormatting) if err != nil { return MlrvalFromError() } else { diff --git a/go/src/types/mlrval_functions_math.go b/go/src/types/mlrval_functions_math.go index 5de48bd7c..b91d48119 100644 --- a/go/src/types/mlrval_functions_math.go +++ b/go/src/types/mlrval_functions_math.go @@ -1,16 +1,16 @@ package types // Return error (unary math-library func) -func _math_unary_erro1(ma *Mlrval, f mathLibUnaryFunc) Mlrval { +func _math_unary_erro1(input1 *Mlrval, f mathLibUnaryFunc) Mlrval { return MlrvalFromError() } // Return absent (unary math-library func) -func _math_unary_absn1(ma *Mlrval, f mathLibUnaryFunc) Mlrval { +func _math_unary_absn1(input1 *Mlrval, f mathLibUnaryFunc) Mlrval { return MlrvalFromAbsent() } // Return void (unary math-library func) -func _math_unary_void1(ma *Mlrval, f mathLibUnaryFunc) Mlrval { +func _math_unary_void1(input1 *Mlrval, f mathLibUnaryFunc) Mlrval { return MlrvalFromAbsent() } diff --git a/go/src/types/mlrval_functions_mathlib.go b/go/src/types/mlrval_functions_mathlib.go index 048535eab..4d73e21ea 100644 --- a/go/src/types/mlrval_functions_mathlib.go +++ b/go/src/types/mlrval_functions_mathlib.go @@ -90,11 +90,11 @@ func mlrInvqnorm(x float64) float64 { } // ---------------------------------------------------------------- -func math_unary_f_i(ma *Mlrval, f mathLibUnaryFunc) Mlrval { - return MlrvalFromFloat64(f(float64(ma.intval))) +func math_unary_f_i(input1 *Mlrval, f mathLibUnaryFunc) Mlrval { + return MlrvalFromFloat64(f(float64(input1.intval))) } -func math_unary_f_f(ma *Mlrval, f mathLibUnaryFunc) Mlrval { - return MlrvalFromFloat64(f(ma.floatval)) +func math_unary_f_f(input1 *Mlrval, f mathLibUnaryFunc) Mlrval { + return MlrvalFromFloat64(f(input1.floatval)) } // Disposition vector for unary mathlib functions @@ -110,50 +110,50 @@ var mudispo = [MT_DIM]mathLibUnaryFuncWrapper{ /*MAP */ _math_unary_absn1, } -func MlrvalAbs(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Abs) } -func MlrvalAcos(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Acos) } -func MlrvalAcosh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Acosh) } -func MlrvalAsin(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Asin) } -func MlrvalAsinh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Asinh) } -func MlrvalAtan(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Atan) } -func MlrvalAtanh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Atanh) } -func MlrvalCbrt(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Cbrt) } -func MlrvalCeil(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Ceil) } -func MlrvalCos(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Cos) } -func MlrvalCosh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Cosh) } -func MlrvalErf(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Erf) } -func MlrvalErfc(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Erfc) } -func MlrvalExp(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Exp) } -func MlrvalExpm1(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Expm1) } -func MlrvalFloor(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Floor) } -func MlrvalInvqnorm(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, mlrInvqnorm) } -func MlrvalLog(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Log) } -func MlrvalLog10(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Log10) } -func MlrvalLog1p(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Log1p) } -func MlrvalQnorm(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, mlrQnorm) } -func MlrvalRound(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Round) } -func MlrvalSgn(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, mlrSgn) } -func MlrvalSin(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Sin) } -func MlrvalSinh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Sinh) } -func MlrvalSqrt(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Sqrt) } -func MlrvalTan(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Tan) } -func MlrvalTanh(ma *Mlrval) Mlrval { return mudispo[ma.mvtype](ma, math.Tanh) } +func MlrvalAbs(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Abs) } +func MlrvalAcos(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Acos) } +func MlrvalAcosh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Acosh) } +func MlrvalAsin(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Asin) } +func MlrvalAsinh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Asinh) } +func MlrvalAtan(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Atan) } +func MlrvalAtanh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Atanh) } +func MlrvalCbrt(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Cbrt) } +func MlrvalCeil(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Ceil) } +func MlrvalCos(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Cos) } +func MlrvalCosh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Cosh) } +func MlrvalErf(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Erf) } +func MlrvalErfc(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Erfc) } +func MlrvalExp(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Exp) } +func MlrvalExpm1(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Expm1) } +func MlrvalFloor(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Floor) } +func MlrvalInvqnorm(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, mlrInvqnorm) } +func MlrvalLog(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Log) } +func MlrvalLog10(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Log10) } +func MlrvalLog1p(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Log1p) } +func MlrvalQnorm(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, mlrQnorm) } +func MlrvalRound(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Round) } +func MlrvalSgn(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, mlrSgn) } +func MlrvalSin(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Sin) } +func MlrvalSinh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Sinh) } +func MlrvalSqrt(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Sqrt) } +func MlrvalTan(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Tan) } +func MlrvalTanh(input1 *Mlrval) Mlrval { return mudispo[input1.mvtype](input1, math.Tanh) } // ================================================================ // Exponentiation: DSL operator '**'. See also // http://johnkerl.org/miller/doc/reference.html#Arithmetic. -func pow_f_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Pow(float64(ma.intval), float64(mb.intval))) +func pow_f_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Pow(float64(input1.intval), float64(input2.intval))) } -func pow_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Pow(float64(ma.intval), mb.floatval)) +func pow_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Pow(float64(input1.intval), input2.floatval)) } -func pow_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Pow(ma.floatval, float64(mb.intval))) +func pow_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Pow(input1.floatval, float64(input2.intval))) } -func pow_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Pow(ma.floatval, mb.floatval)) +func pow_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Pow(input1.floatval, input2.floatval)) } var pow_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -169,22 +169,22 @@ var pow_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalPow(ma, mb *Mlrval) Mlrval { - return pow_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalPow(input1, input2 *Mlrval) Mlrval { + return pow_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ -func atan2_f_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Atan2(float64(ma.intval), float64(mb.intval))) +func atan2_f_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Atan2(float64(input1.intval), float64(input2.intval))) } -func atan2_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Atan2(float64(ma.intval), mb.floatval)) +func atan2_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Atan2(float64(input1.intval), input2.floatval)) } -func atan2_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Atan2(ma.floatval, float64(mb.intval))) +func atan2_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Atan2(input1.floatval, float64(input2.intval))) } -func atan2_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(math.Atan2(ma.floatval, mb.floatval)) +func atan2_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(math.Atan2(input1.floatval, input2.floatval)) } var atan2_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -200,8 +200,8 @@ var atan2_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalAtan2(ma, mb *Mlrval) Mlrval { - return atan2_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalAtan2(input1, input2 *Mlrval) Mlrval { + return atan2_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ @@ -209,17 +209,17 @@ func mlr_roundm(x, m float64) float64 { return math.Round(x/m) * m } -func roundm_f_ii(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(mlr_roundm(float64(ma.intval), float64(mb.intval))) +func roundm_f_ii(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(mlr_roundm(float64(input1.intval), float64(input2.intval))) } -func roundm_f_if(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(mlr_roundm(float64(ma.intval), mb.floatval)) +func roundm_f_if(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(mlr_roundm(float64(input1.intval), input2.floatval)) } -func roundm_f_fi(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(mlr_roundm(ma.floatval, float64(mb.intval))) +func roundm_f_fi(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(mlr_roundm(input1.floatval, float64(input2.intval))) } -func roundm_f_ff(ma, mb *Mlrval) Mlrval { - return MlrvalFromFloat64(mlr_roundm(ma.floatval, mb.floatval)) +func roundm_f_ff(input1, input2 *Mlrval) Mlrval { + return MlrvalFromFloat64(mlr_roundm(input1.floatval, input2.floatval)) } var roundm_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -235,32 +235,32 @@ var roundm_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn, _absn}, } -func MlrvalRoundm(ma, mb *Mlrval) Mlrval { - return roundm_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalRoundm(input1, input2 *Mlrval) Mlrval { + return roundm_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ -func MlrvalLogifit(ma, mb, mc *Mlrval) Mlrval { - if !ma.IsLegit() { - return *ma +func MlrvalLogifit(input1, input2, input3 *Mlrval) Mlrval { + if !input1.IsLegit() { + return *input1 } - if !mb.IsLegit() { - return *mb + if !input2.IsLegit() { + return *input2 } - if !mc.IsLegit() { - return *mc + if !input3.IsLegit() { + return *input3 } // int/float OK; rest not - x, xok := ma.GetNumericToFloatValue() + x, xok := input1.GetNumericToFloatValue() if !xok { return MlrvalFromError() } - m, mok := mb.GetNumericToFloatValue() + m, mok := input2.GetNumericToFloatValue() if !mok { return MlrvalFromError() } - b, bok := mc.GetNumericToFloatValue() + b, bok := input3.GetNumericToFloatValue() if !bok { return MlrvalFromError() } diff --git a/go/src/types/mlrval_functions_random.go b/go/src/types/mlrval_functions_random.go index efce8d07f..ae26757bf 100644 --- a/go/src/types/mlrval_functions_random.go +++ b/go/src/types/mlrval_functions_random.go @@ -21,22 +21,22 @@ func MlrvalUrand32() Mlrval { } // TODO: use a disposition matrix -func MlrvalUrandInt(ma, mb *Mlrval) Mlrval { - if !ma.IsLegit() { - return *ma +func MlrvalUrandInt(input1, input2 *Mlrval) Mlrval { + if !input1.IsLegit() { + return *input1 } - if !mb.IsLegit() { - return *mb + if !input2.IsLegit() { + return *input2 } - if !ma.IsInt() { + if !input1.IsInt() { return MlrvalFromError() } - if !mb.IsInt() { + if !input2.IsInt() { return MlrvalFromError() } - a := ma.intval - b := mb.intval + a := input1.intval + b := input2.intval var lo int = 0 var hi int = 0 @@ -51,15 +51,15 @@ func MlrvalUrandInt(ma, mb *Mlrval) Mlrval { return MlrvalFromInt(u) } -func MlrvalUrandRange(ma, mb *Mlrval) Mlrval { - if !ma.IsLegit() { - return *ma +func MlrvalUrandRange(input1, input2 *Mlrval) Mlrval { + if !input1.IsLegit() { + return *input1 } - if !mb.IsLegit() { - return *mb + if !input2.IsLegit() { + return *input2 } - a, aok := ma.GetNumericToFloatValue() - b, bok := mb.GetNumericToFloatValue() + a, aok := input1.GetNumericToFloatValue() + b, bok := input2.GetNumericToFloatValue() if !aok { return MlrvalFromError() } diff --git a/go/src/types/mlrval_functions_regex.go b/go/src/types/mlrval_functions_regex.go index 58c4e6219..d1768fedf 100644 --- a/go/src/types/mlrval_functions_regex.go +++ b/go/src/types/mlrval_functions_regex.go @@ -7,56 +7,56 @@ import ( ) // ================================================================ -func MlrvalSsub(ma, mb, mc *Mlrval) Mlrval { - if ma.IsErrorOrAbsent() { - return *ma +func MlrvalSsub(input1, input2, input3 *Mlrval) Mlrval { + if input1.IsErrorOrAbsent() { + return *input1 } - if mb.IsErrorOrAbsent() { - return *mb + if input2.IsErrorOrAbsent() { + return *input2 } - if mc.IsErrorOrAbsent() { - return *mc + if input3.IsErrorOrAbsent() { + return *input3 } - if !ma.IsStringOrVoid() { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - if !mb.IsStringOrVoid() { + if !input2.IsStringOrVoid() { return MlrvalFromError() } - if !mc.IsStringOrVoid() { + if !input3.IsStringOrVoid() { return MlrvalFromError() } return MlrvalFromString( - strings.Replace(ma.printrep, mb.printrep, mc.printrep, 1), + strings.Replace(input1.printrep, input2.printrep, input3.printrep, 1), ) } // ================================================================ // TODO: make a variant which allows compiling the regexp once and reusing it // on each record -func MlrvalSub(ma, mb, mc *Mlrval) Mlrval { - if ma.IsErrorOrAbsent() { - return *ma +func MlrvalSub(input1, input2, input3 *Mlrval) Mlrval { + if input1.IsErrorOrAbsent() { + return *input1 } - if mb.IsErrorOrAbsent() { - return *mb + if input2.IsErrorOrAbsent() { + return *input2 } - if mc.IsErrorOrAbsent() { - return *mc + if input3.IsErrorOrAbsent() { + return *input3 } - if !ma.IsStringOrVoid() { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - if !mb.IsStringOrVoid() { + if !input2.IsStringOrVoid() { return MlrvalFromError() } - if !mc.IsStringOrVoid() { + if !input3.IsStringOrVoid() { return MlrvalFromError() } // TODO: better exception-handling - re := lib.CompileMillerRegexOrDie(mb.printrep) + re := lib.CompileMillerRegexOrDie(input2.printrep) - output := lib.RegexReplaceOnce(re, ma.printrep, mc.printrep) + output := lib.RegexReplaceOnce(re, input1.printrep, input3.printrep) return MlrvalFromString(output) } @@ -64,57 +64,57 @@ func MlrvalSub(ma, mb, mc *Mlrval) Mlrval { // ================================================================ // TODO: make a variant which allows compiling the regexp once and reusing it // on each record -func MlrvalGsub(ma, mb, mc *Mlrval) Mlrval { - if ma.IsErrorOrAbsent() { - return *ma +func MlrvalGsub(input1, input2, input3 *Mlrval) Mlrval { + if input1.IsErrorOrAbsent() { + return *input1 } - if mb.IsErrorOrAbsent() { - return *mb + if input2.IsErrorOrAbsent() { + return *input2 } - if mc.IsErrorOrAbsent() { - return *mc + if input3.IsErrorOrAbsent() { + return *input3 } - if !ma.IsStringOrVoid() { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - if !mb.IsStringOrVoid() { + if !input2.IsStringOrVoid() { return MlrvalFromError() } - if !mc.IsStringOrVoid() { + if !input3.IsStringOrVoid() { return MlrvalFromError() } // TODO: better exception-handling - re := lib.CompileMillerRegexOrDie(mb.printrep) + re := lib.CompileMillerRegexOrDie(input2.printrep) return MlrvalFromString( - re.ReplaceAllString(ma.printrep, mc.printrep), + re.ReplaceAllString(input1.printrep, input3.printrep), ) } // ================================================================ // TODO: make a variant which allows compiling the regexp once and reusing it // on each record -func MlrvalStringMatchesRegexp(ma, mb *Mlrval) Mlrval { - if !ma.IsLegit() { - return *ma +func MlrvalStringMatchesRegexp(input1, input2 *Mlrval) Mlrval { + if !input1.IsLegit() { + return *input1 } - if !mb.IsLegit() { - return *mb + if !input2.IsLegit() { + return *input2 } - if !ma.IsStringOrVoid() { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - if !mb.IsStringOrVoid() { + if !input2.IsStringOrVoid() { return MlrvalFromError() } // TODO: better exception-handling - re := lib.CompileMillerRegexOrDie(mb.printrep) + re := lib.CompileMillerRegexOrDie(input2.printrep) return MlrvalFromBool( - re.MatchString(ma.printrep), + re.MatchString(input1.printrep), ) } -func MlrvalStringDoesNotMatchRegexp(ma, mb *Mlrval) Mlrval { - matches := MlrvalStringMatchesRegexp(ma, mb) +func MlrvalStringDoesNotMatchRegexp(input1, input2 *Mlrval) Mlrval { + matches := MlrvalStringMatchesRegexp(input1, input2) if matches.mvtype == MT_BOOL { return MlrvalFromBool(!matches.boolval) } else { @@ -123,16 +123,16 @@ func MlrvalStringDoesNotMatchRegexp(ma, mb *Mlrval) Mlrval { } // TODO: find a way to keep and stash a precompiled regex, somewhere in the CST ... -func MlrvalRegextract(ma, mb *Mlrval) Mlrval { - if !ma.IsString() { +func MlrvalRegextract(input1, input2 *Mlrval) Mlrval { + if !input1.IsString() { return MlrvalFromError() } - if !mb.IsString() { + if !input2.IsString() { return MlrvalFromError() } - regex := lib.CompileMillerRegexOrDie(mb.printrep) + regex := lib.CompileMillerRegexOrDie(input2.printrep) // TODO: See if we need FindStringIndex or FindStringSubmatch to distinguish from matching "". - output := regex.FindString(ma.printrep) + output := regex.FindString(input1.printrep) if output != "" { return MlrvalFromString(output) } else { @@ -140,19 +140,19 @@ func MlrvalRegextract(ma, mb *Mlrval) Mlrval { } } -func MlrvalRegextractOrElse(ma, mb, mc *Mlrval) Mlrval { - if !ma.IsString() { +func MlrvalRegextractOrElse(input1, input2, input3 *Mlrval) Mlrval { + if !input1.IsString() { return MlrvalFromError() } - if !mb.IsString() { + if !input2.IsString() { return MlrvalFromError() } - regex := lib.CompileMillerRegexOrDie(mb.printrep) + regex := lib.CompileMillerRegexOrDie(input2.printrep) // TODO: See if we need FindStringIndex or FindStringSubmatch to distinguish from matching "". - output := regex.FindString(ma.printrep) + output := regex.FindString(input1.printrep) if output != "" { return MlrvalFromString(output) } else { - return *mc + return *input3 } } diff --git a/go/src/types/mlrval_functions_sort.go b/go/src/types/mlrval_functions_sort.go index 4d420a46e..91ab5c84f 100644 --- a/go/src/types/mlrval_functions_sort.go +++ b/go/src/types/mlrval_functions_sort.go @@ -5,9 +5,9 @@ package types // Lexical sort: just stringify everything. -func LexicalAscendingComparator(ma *Mlrval, mb *Mlrval) int { - sa := ma.String() - sb := mb.String() +func LexicalAscendingComparator(input1 *Mlrval, input2 *Mlrval) int { + sa := input1.String() + sb := input2.String() if sa < sb { return -1 } else if sa > sb { @@ -16,8 +16,8 @@ func LexicalAscendingComparator(ma *Mlrval, mb *Mlrval) int { return 0 } } -func LexicalDescendingComparator(ma *Mlrval, mb *Mlrval) int { - return LexicalAscendingComparator(mb, ma) +func LexicalDescendingComparator(input1 *Mlrval, input2 *Mlrval) int { + return LexicalAscendingComparator(input2, input1) } // ---------------------------------------------------------------- @@ -29,29 +29,29 @@ func LexicalDescendingComparator(ma *Mlrval, mb *Mlrval) int { // * numeric compares on numbers // * false < true -func _neg1(ma, mb *Mlrval) int { +func _neg1(input1, input2 *Mlrval) int { return -1 } -func _zero(ma, mb *Mlrval) int { +func _zero(input1, input2 *Mlrval) int { return 0 } -func _pos1(ma, mb *Mlrval) int { +func _pos1(input1, input2 *Mlrval) int { return 1 } -func _scmp(ma, mb *Mlrval) int { - if ma.printrep < mb.printrep { +func _scmp(input1, input2 *Mlrval) int { + if input1.printrep < input2.printrep { return -1 - } else if ma.printrep > mb.printrep { + } else if input1.printrep > input2.printrep { return 1 } else { return 0 } } -func iicmp(ma, mb *Mlrval) int { - ca := ma.intval - cb := mb.intval +func iicmp(input1, input2 *Mlrval) int { + ca := input1.intval + cb := input2.intval if ca < cb { return -1 } else if ca > cb { @@ -60,9 +60,9 @@ func iicmp(ma, mb *Mlrval) int { return 0 } } -func ifcmp(ma, mb *Mlrval) int { - ca := float64(ma.intval) - cb := mb.floatval +func ifcmp(input1, input2 *Mlrval) int { + ca := float64(input1.intval) + cb := input2.floatval if ca < cb { return -1 } else if ca > cb { @@ -71,9 +71,9 @@ func ifcmp(ma, mb *Mlrval) int { return 0 } } -func ficmp(ma, mb *Mlrval) int { - ca := ma.floatval - cb := float64(mb.intval) +func ficmp(input1, input2 *Mlrval) int { + ca := input1.floatval + cb := float64(input2.intval) if ca < cb { return -1 } else if ca > cb { @@ -82,9 +82,9 @@ func ficmp(ma, mb *Mlrval) int { return 0 } } -func ffcmp(ma, mb *Mlrval) int { - ca := ma.floatval - cb := mb.floatval +func ffcmp(input1, input2 *Mlrval) int { + ca := input1.floatval + cb := input2.floatval if ca < cb { return -1 } else if ca > cb { @@ -94,9 +94,9 @@ func ffcmp(ma, mb *Mlrval) int { } } -func bbcmp(ma, mb *Mlrval) int { - a := ma.boolval - b := mb.boolval +func bbcmp(input1, input2 *Mlrval) int { + a := input1.boolval + b := input2.boolval if a == false { if b == false { return 0 @@ -134,9 +134,9 @@ var num_cmp_dispositions = [MT_DIM][MT_DIM]ComparatorFunc{ /*MAP */ {_zero, _zero, _zero, _zero, _zero, _zero, _zero, _zero, _zero}, } -func NumericAscendingComparator(ma *Mlrval, mb *Mlrval) int { - return num_cmp_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func NumericAscendingComparator(input1 *Mlrval, input2 *Mlrval) int { + return num_cmp_dispositions[input1.mvtype][input2.mvtype](input1, input2) } -func NumericDescendingComparator(ma *Mlrval, mb *Mlrval) int { - return NumericAscendingComparator(mb, ma) +func NumericDescendingComparator(input1 *Mlrval, input2 *Mlrval) int { + return NumericAscendingComparator(input2, input1) } diff --git a/go/src/types/mlrval_functions_strings.go b/go/src/types/mlrval_functions_strings.go index f1ddf180e..739590c40 100644 --- a/go/src/types/mlrval_functions_strings.go +++ b/go/src/types/mlrval_functions_strings.go @@ -11,16 +11,16 @@ import ( ) // ================================================================ -func MlrvalStrlen(ma *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { +func MlrvalStrlen(input1 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - return MlrvalFromInt(int(utf8.RuneCountInString(ma.printrep))) + return MlrvalFromInt(int(utf8.RuneCountInString(input1.printrep))) } // ================================================================ -func MlrvalToString(ma *Mlrval) Mlrval { - return MlrvalFromString(ma.String()) +func MlrvalToString(input1 *Mlrval) Mlrval { + return MlrvalFromString(input1.String()) } // ================================================================ @@ -37,8 +37,8 @@ func MlrvalToString(ma *Mlrval) Mlrval { // should be: always the string concatenation of the string representations of // the two arguments. So, we do the string-cast for the user. -func dot_s_xx(ma, mb *Mlrval) Mlrval { - return MlrvalFromString(ma.String() + mb.String()) +func dot_s_xx(input1, input2 *Mlrval) Mlrval { + return MlrvalFromString(input1.String() + input2.String()) } var dot_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ @@ -54,42 +54,42 @@ var dot_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_absn, _absn, _absn, dot_s_xx, dot_s_xx, dot_s_xx, dot_s_xx, dot_s_xx, dot_s_xx}, } -func MlrvalDot(ma, mb *Mlrval) Mlrval { - return dot_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalDot(input1, input2 *Mlrval) Mlrval { + return dot_dispositions[input1.mvtype][input2.mvtype](input1, input2) } // ================================================================ // substr(s,m,n) gives substring of s from 1-up position m to n inclusive. // Negative indices -len .. -1 alias to 0 .. len-1. -func MlrvalSubstr(ma, mb, mc *Mlrval) Mlrval { - if !ma.IsStringOrVoid() { - if ma.IsNumeric() { +func MlrvalSubstr(input1, input2, input3 *Mlrval) Mlrval { + if !input1.IsStringOrVoid() { + if input1.IsNumeric() { // JIT-stringify, if not already (e.g. intval scanned from string // in input-file data) - ma.setPrintRep() + input1.setPrintRep() } else { return MlrvalFromError() } } // TODO: fix this with regard to UTF-8 and runes. - strlen := int(len(ma.printrep)) + strlen := int(len(input1.printrep)) // For array slices like s[1:2], s[:2], s[1:], when the lower index is // empty in the DSL expression it comes in here as a 1. But when the upper // index is empty in the DSL expression it comes in here as "". - if !mb.IsInt() { + if !input2.IsInt() { return MlrvalFromError() } - lowerMindex := mb.intval + lowerMindex := input2.intval upperMindex := strlen - if mc.IsEmpty() { + if input3.IsEmpty() { // Keep strlen - } else if !mc.IsInt() { + } else if !input3.IsInt() { return MlrvalFromError() } else { - upperMindex = mc.intval + upperMindex = input3.intval } // Convert from negative-aliased 1-up to positive-only 0-up @@ -104,72 +104,72 @@ func MlrvalSubstr(ma, mb, mc *Mlrval) Mlrval { // Note Golang slice indices are 0-up, and the 1st index is inclusive // while the 2nd is exclusive. For Miller, indices are 1-up and both // are inclusive. - return MlrvalFromString(ma.printrep[m : n+1]) + return MlrvalFromString(input1.printrep[m : n+1]) } } // ================================================================ -func MlrvalTruncate(ma, mb *Mlrval) Mlrval { - if ma.IsErrorOrAbsent() { - return *ma +func MlrvalTruncate(input1, input2 *Mlrval) Mlrval { + if input1.IsErrorOrAbsent() { + return *input1 } - if mb.IsErrorOrAbsent() { - return *mb + if input2.IsErrorOrAbsent() { + return *input2 } - if !ma.IsStringOrVoid() { + if !input1.IsStringOrVoid() { return MlrvalFromError() } - if !mb.IsInt() { + if !input2.IsInt() { return MlrvalFromError() } - if mb.intval < 0 { + if input2.intval < 0 { return MlrvalFromError() } - oldLength := int(len(ma.printrep)) - maxLength := mb.intval + oldLength := int(len(input1.printrep)) + maxLength := input2.intval if oldLength <= maxLength { - return *ma + return *input1 } else { - return MlrvalFromString(ma.printrep[0:maxLength]) + return MlrvalFromString(input1.printrep[0:maxLength]) } } // ================================================================ -func MlrvalLStrip(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(strings.TrimLeft(ma.printrep, " \t")) +func MlrvalLStrip(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(strings.TrimLeft(input1.printrep, " \t")) } else { - return *ma + return *input1 } } -func MlrvalRStrip(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(strings.TrimRight(ma.printrep, " \t")) +func MlrvalRStrip(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(strings.TrimRight(input1.printrep, " \t")) } else { - return *ma + return *input1 } } -func MlrvalStrip(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(strings.Trim(ma.printrep, " \t")) +func MlrvalStrip(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(strings.Trim(input1.printrep, " \t")) } else { - return *ma + return *input1 } } // ---------------------------------------------------------------- -func MlrvalCollapseWhitespace(ma *Mlrval) Mlrval { - return MlrvalCollapseWhitespaceRegexp(ma, WhitespaceRegexp()) +func MlrvalCollapseWhitespace(input1 *Mlrval) Mlrval { + return MlrvalCollapseWhitespaceRegexp(input1, WhitespaceRegexp()) } -func MlrvalCollapseWhitespaceRegexp(ma *Mlrval, whitespaceRegexp *regexp.Regexp) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(whitespaceRegexp.ReplaceAllString(ma.printrep, " ")) +func MlrvalCollapseWhitespaceRegexp(input1 *Mlrval, whitespaceRegexp *regexp.Regexp) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(whitespaceRegexp.ReplaceAllString(input1.printrep, " ")) } else { - return *ma + return *input1 } } @@ -178,32 +178,32 @@ func WhitespaceRegexp() *regexp.Regexp { } // ================================================================ -func MlrvalToUpper(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(strings.ToUpper(ma.printrep)) - } else if ma.mvtype == MT_VOID { - return *ma +func MlrvalToUpper(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(strings.ToUpper(input1.printrep)) + } else if input1.mvtype == MT_VOID { + return *input1 } else { - return *ma + return *input1 } } -func MlrvalToLower(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - return MlrvalFromString(strings.ToLower(ma.printrep)) - } else if ma.mvtype == MT_VOID { - return *ma +func MlrvalToLower(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + return MlrvalFromString(strings.ToLower(input1.printrep)) + } else if input1.mvtype == MT_VOID { + return *input1 } else { - return *ma + return *input1 } } -func MlrvalCapitalize(ma *Mlrval) Mlrval { - if ma.mvtype == MT_STRING { - if ma.printrep == "" { - return *ma +func MlrvalCapitalize(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_STRING { + if input1.printrep == "" { + return *input1 } else { - runes := []rune(ma.printrep) + runes := []rune(input1.printrep) rfirst := runes[0] rrest := runes[1:] sfirst := strings.ToUpper(string(rfirst)) @@ -211,49 +211,49 @@ func MlrvalCapitalize(ma *Mlrval) Mlrval { return MlrvalFromString(sfirst + srest) } } else { - return *ma + return *input1 } } // ---------------------------------------------------------------- -func MlrvalCleanWhitespace(ma *Mlrval) Mlrval { - temp := MlrvalCollapseWhitespaceRegexp(ma, WhitespaceRegexp()) +func MlrvalCleanWhitespace(input1 *Mlrval) Mlrval { + temp := MlrvalCollapseWhitespaceRegexp(input1, WhitespaceRegexp()) return MlrvalStrip(&temp) } // ================================================================ -func MlrvalHexfmt(ma *Mlrval) Mlrval { - if ma.mvtype == MT_INT { - return MlrvalFromString("0x" + strconv.FormatUint(uint64(ma.intval), 16)) +func MlrvalHexfmt(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_INT { + return MlrvalFromString("0x" + strconv.FormatUint(uint64(input1.intval), 16)) } else { - return *ma + return *input1 } } // ---------------------------------------------------------------- -func fmtnum_is(ma, mb *Mlrval) Mlrval { +func fmtnum_is(input1, input2 *Mlrval) Mlrval { return MlrvalFromString( fmt.Sprintf( - mb.printrep, - ma.intval, + input2.printrep, + input1.intval, ), ) } -func fmtnum_fs(ma, mb *Mlrval) Mlrval { +func fmtnum_fs(input1, input2 *Mlrval) Mlrval { return MlrvalFromString( fmt.Sprintf( - mb.printrep, - ma.floatval, + input2.printrep, + input1.floatval, ), ) } -func fmtnum_bs(ma, mb *Mlrval) Mlrval { +func fmtnum_bs(input1, input2 *Mlrval) Mlrval { return MlrvalFromString( fmt.Sprintf( - mb.printrep, - lib.BoolToInt(ma.boolval), + input2.printrep, + lib.BoolToInt(input1.boolval), ), ) } @@ -271,6 +271,6 @@ var fmtnum_dispositions = [MT_DIM][MT_DIM]BinaryFunc{ /*MAP */ {_erro, _absn, _erro, _erro, _erro, _erro, _erro, _erro, _erro}, } -func MlrvalFmtNum(ma, mb *Mlrval) Mlrval { - return fmtnum_dispositions[ma.mvtype][mb.mvtype](ma, mb) +func MlrvalFmtNum(input1, input2 *Mlrval) Mlrval { + return fmtnum_dispositions[input1.mvtype][input2.mvtype](input1, input2) } diff --git a/go/src/types/mlrval_functions_time.go b/go/src/types/mlrval_functions_time.go index 6cd4e1269..2f361f0d7 100644 --- a/go/src/types/mlrval_functions_time.go +++ b/go/src/types/mlrval_functions_time.go @@ -28,26 +28,26 @@ func MlrvalUptime() Mlrval { } // ================================================================ -func MlrvalSec2GMTUnary(ma *Mlrval) Mlrval { - if ma.mvtype == MT_FLOAT { - return MlrvalFromString(lib.Sec2GMT(ma.floatval, 0)) - } else if ma.mvtype == MT_INT { - return MlrvalFromString(lib.Sec2GMT(float64(ma.intval), 0)) +func MlrvalSec2GMTUnary(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_FLOAT { + return MlrvalFromString(lib.Sec2GMT(input1.floatval, 0)) + } else if input1.mvtype == MT_INT { + return MlrvalFromString(lib.Sec2GMT(float64(input1.intval), 0)) } else { - return *ma + return *input1 } } // ---------------------------------------------------------------- -func MlrvalSec2GMTBinary(ma, mb *Mlrval) Mlrval { - if mb.mvtype != MT_INT { +func MlrvalSec2GMTBinary(input1, input2 *Mlrval) Mlrval { + if input2.mvtype != MT_INT { return MlrvalFromError() } - if ma.mvtype == MT_FLOAT { - return MlrvalFromString(lib.Sec2GMT(ma.floatval, int(mb.intval))) - } else if ma.mvtype == MT_INT { - return MlrvalFromString(lib.Sec2GMT(float64(ma.intval), int(mb.intval))) + if input1.mvtype == MT_FLOAT { + return MlrvalFromString(lib.Sec2GMT(input1.floatval, int(input2.intval))) + } else if input1.mvtype == MT_INT { + return MlrvalFromString(lib.Sec2GMT(float64(input1.intval), int(input2.intval))) } else { - return *ma + return *input1 } } diff --git a/go/src/types/mlrval_functions_types.go b/go/src/types/mlrval_functions_types.go index 6ec06f8ce..e10b66c6a 100644 --- a/go/src/types/mlrval_functions_types.go +++ b/go/src/types/mlrval_functions_types.go @@ -8,13 +8,13 @@ import ( ) // ================================================================ -func MlrvalTypeof(ma *Mlrval) Mlrval { - return MlrvalFromString(ma.GetTypeName()) +func MlrvalTypeof(input1 *Mlrval) Mlrval { + return MlrvalFromString(input1.GetTypeName()) } // ---------------------------------------------------------------- -func string_to_int(ma *Mlrval) Mlrval { - i, ok := lib.TryIntFromString(ma.printrep) +func string_to_int(input1 *Mlrval) Mlrval { + i, ok := lib.TryIntFromString(input1.printrep) if ok { return MlrvalFromInt(i) } else { @@ -22,12 +22,12 @@ func string_to_int(ma *Mlrval) Mlrval { } } -func float_to_int(ma *Mlrval) Mlrval { - return MlrvalFromInt(int(ma.floatval)) +func float_to_int(input1 *Mlrval) Mlrval { + return MlrvalFromInt(int(input1.floatval)) } -func bool_to_int(ma *Mlrval) Mlrval { - if ma.boolval == true { +func bool_to_int(input1 *Mlrval) Mlrval { + if input1.boolval == true { return MlrvalFromInt(1) } else { return MlrvalFromInt(0) @@ -46,13 +46,13 @@ var to_int_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _erro1, } -func MlrvalToInt(ma *Mlrval) Mlrval { - return to_int_dispositions[ma.mvtype](ma) +func MlrvalToInt(input1 *Mlrval) Mlrval { + return to_int_dispositions[input1.mvtype](input1) } // ---------------------------------------------------------------- -func string_to_float(ma *Mlrval) Mlrval { - f, ok := lib.TryFloat64FromString(ma.printrep) +func string_to_float(input1 *Mlrval) Mlrval { + f, ok := lib.TryFloat64FromString(input1.printrep) if ok { return MlrvalFromFloat64(f) } else { @@ -60,12 +60,12 @@ func string_to_float(ma *Mlrval) Mlrval { } } -func int_to_float(ma *Mlrval) Mlrval { - return MlrvalFromFloat64(float64(ma.intval)) +func int_to_float(input1 *Mlrval) Mlrval { + return MlrvalFromFloat64(float64(input1.intval)) } -func bool_to_float(ma *Mlrval) Mlrval { - if ma.boolval == true { +func bool_to_float(input1 *Mlrval) Mlrval { + if input1.boolval == true { return MlrvalFromFloat64(1.0) } else { return MlrvalFromFloat64(0.0) @@ -84,13 +84,13 @@ var to_float_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _erro1, } -func MlrvalToFloat(ma *Mlrval) Mlrval { - return to_float_dispositions[ma.mvtype](ma) +func MlrvalToFloat(input1 *Mlrval) Mlrval { + return to_float_dispositions[input1.mvtype](input1) } // ---------------------------------------------------------------- -func string_to_boolean(ma *Mlrval) Mlrval { - b, ok := lib.TryBoolFromBoolString(ma.printrep) +func string_to_boolean(input1 *Mlrval) Mlrval { + b, ok := lib.TryBoolFromBoolString(input1.printrep) if ok { return MlrvalFromBool(b) } else { @@ -98,12 +98,12 @@ func string_to_boolean(ma *Mlrval) Mlrval { } } -func int_to_bool(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.intval != 0) +func int_to_bool(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.intval != 0) } -func float_to_bool(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.floatval != 0.0) +func float_to_bool(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.floatval != 0.0) } var to_boolean_dispositions = [MT_DIM]UnaryFunc{ @@ -118,87 +118,87 @@ var to_boolean_dispositions = [MT_DIM]UnaryFunc{ /*MAP */ _erro1, } -func MlrvalToBoolean(ma *Mlrval) Mlrval { - return to_boolean_dispositions[ma.mvtype](ma) +func MlrvalToBoolean(input1 *Mlrval) Mlrval { + return to_boolean_dispositions[input1.mvtype](input1) } // ---------------------------------------------------------------- -func MlrvalIsAbsent(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_ABSENT) +func MlrvalIsAbsent(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_ABSENT) } -func MlrvalIsError(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_ERROR) +func MlrvalIsError(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_ERROR) } -func MlrvalIsBool(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_BOOL) +func MlrvalIsBool(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_BOOL) } -func MlrvalIsBoolean(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_BOOL) +func MlrvalIsBoolean(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_BOOL) } -func MlrvalIsEmpty(ma *Mlrval) Mlrval { - if ma.mvtype == MT_VOID { +func MlrvalIsEmpty(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_VOID { return MlrvalFromTrue() } - if ma.mvtype == MT_STRING { - if ma.printrep == "" { + if input1.mvtype == MT_STRING { + if input1.printrep == "" { return MlrvalFromTrue() } } return MlrvalFromFalse() } -func MlrvalIsEmptyMap(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_MAP && ma.mapval.FieldCount == 0) +func MlrvalIsEmptyMap(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_MAP && input1.mapval.FieldCount == 0) } -func MlrvalIsFloat(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_FLOAT) +func MlrvalIsFloat(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_FLOAT) } -func MlrvalIsInt(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_INT) +func MlrvalIsInt(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_INT) } -func MlrvalIsMap(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_MAP) +func MlrvalIsMap(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_MAP) } -func MlrvalIsArray(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_ARRAY) +func MlrvalIsArray(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_ARRAY) } -func MlrvalIsNonEmptyMap(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_MAP && ma.mapval.FieldCount != 0) +func MlrvalIsNonEmptyMap(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_MAP && input1.mapval.FieldCount != 0) } -func MlrvalIsNotEmpty(ma *Mlrval) Mlrval { - if ma.mvtype == MT_VOID { +func MlrvalIsNotEmpty(input1 *Mlrval) Mlrval { + if input1.mvtype == MT_VOID { return MlrvalFromFalse() } - if ma.mvtype == MT_STRING { - if ma.printrep == "" { + if input1.mvtype == MT_STRING { + if input1.printrep == "" { return MlrvalFromFalse() } } return MlrvalFromTrue() } -func MlrvalIsNotMap(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype != MT_MAP) +func MlrvalIsNotMap(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype != MT_MAP) } -func MlrvalIsNotArray(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype != MT_ARRAY) +func MlrvalIsNotArray(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype != MT_ARRAY) } -func MlrvalIsNotNull(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype != MT_ABSENT && ma.mvtype != MT_VOID) +func MlrvalIsNotNull(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype != MT_ABSENT && input1.mvtype != MT_VOID) } -func MlrvalIsNull(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_ABSENT || ma.mvtype == MT_VOID) +func MlrvalIsNull(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_ABSENT || input1.mvtype == MT_VOID) } -func MlrvalIsNumeric(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_INT || ma.mvtype == MT_FLOAT) +func MlrvalIsNumeric(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_INT || input1.mvtype == MT_FLOAT) } -func MlrvalIsPresent(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype != MT_ABSENT) +func MlrvalIsPresent(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype != MT_ABSENT) } -func MlrvalIsString(ma *Mlrval) Mlrval { - return MlrvalFromBool(ma.mvtype == MT_STRING || ma.mvtype == MT_VOID) +func MlrvalIsString(input1 *Mlrval) Mlrval { + return MlrvalFromBool(input1.mvtype == MT_STRING || input1.mvtype == MT_VOID) } // ---------------------------------------------------------------- -func assertingCommon(ma, check *Mlrval, description string, context *Context) Mlrval { +func assertingCommon(input1, check *Mlrval, description string, context *Context) Mlrval { if check.IsFalse() { // TODO: get context as in the C impl //fprintf(stderr, "%s: %s type-assertion failed at NR=%lld FNR=%lld FILENAME=%s\n", @@ -214,82 +214,82 @@ func assertingCommon(ma, check *Mlrval, description string, context *Context) Ml ) os.Exit(1) } - return *ma + return *input1 } -func MlrvalAssertingAbsent(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsAbsent(ma) - return assertingCommon(ma, &check, "is_absent", context) +func MlrvalAssertingAbsent(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsAbsent(input1) + return assertingCommon(input1, &check, "is_absent", context) } -func MlrvalAssertingError(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsError(ma) - return assertingCommon(ma, &check, "is_error", context) +func MlrvalAssertingError(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsError(input1) + return assertingCommon(input1, &check, "is_error", context) } -func MlrvalAssertingBool(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsBool(ma) - return assertingCommon(ma, &check, "is_bool", context) +func MlrvalAssertingBool(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsBool(input1) + return assertingCommon(input1, &check, "is_bool", context) } -func MlrvalAssertingBoolean(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsBoolean(ma) - return assertingCommon(ma, &check, "is_boolean", context) +func MlrvalAssertingBoolean(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsBoolean(input1) + return assertingCommon(input1, &check, "is_boolean", context) } -func MlrvalAssertingEmpty(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsEmpty(ma) - return assertingCommon(ma, &check, "is_empty", context) +func MlrvalAssertingEmpty(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsEmpty(input1) + return assertingCommon(input1, &check, "is_empty", context) } -func MlrvalAssertingEmptyMap(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsEmptyMap(ma) - return assertingCommon(ma, &check, "is_empty_map", context) +func MlrvalAssertingEmptyMap(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsEmptyMap(input1) + return assertingCommon(input1, &check, "is_empty_map", context) } -func MlrvalAssertingFloat(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsFloat(ma) - return assertingCommon(ma, &check, "is_float", context) +func MlrvalAssertingFloat(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsFloat(input1) + return assertingCommon(input1, &check, "is_float", context) } -func MlrvalAssertingInt(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsInt(ma) - return assertingCommon(ma, &check, "is_int", context) +func MlrvalAssertingInt(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsInt(input1) + return assertingCommon(input1, &check, "is_int", context) } -func MlrvalAssertingMap(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsMap(ma) - return assertingCommon(ma, &check, "is_map", context) +func MlrvalAssertingMap(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsMap(input1) + return assertingCommon(input1, &check, "is_map", context) } -func MlrvalAssertingArray(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsArray(ma) - return assertingCommon(ma, &check, "is_array", context) +func MlrvalAssertingArray(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsArray(input1) + return assertingCommon(input1, &check, "is_array", context) } -func MlrvalAssertingNonEmptyMap(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNonEmptyMap(ma) - return assertingCommon(ma, &check, "is_non_empty_map", context) +func MlrvalAssertingNonEmptyMap(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNonEmptyMap(input1) + return assertingCommon(input1, &check, "is_non_empty_map", context) } -func MlrvalAssertingNotEmpty(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNotEmpty(ma) - return assertingCommon(ma, &check, "is_not_empty", context) +func MlrvalAssertingNotEmpty(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNotEmpty(input1) + return assertingCommon(input1, &check, "is_not_empty", context) } -func MlrvalAssertingNotMap(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNotMap(ma) - return assertingCommon(ma, &check, "is_not_map", context) +func MlrvalAssertingNotMap(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNotMap(input1) + return assertingCommon(input1, &check, "is_not_map", context) } -func MlrvalAssertingNotArray(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNotArray(ma) - return assertingCommon(ma, &check, "is_not_array", context) +func MlrvalAssertingNotArray(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNotArray(input1) + return assertingCommon(input1, &check, "is_not_array", context) } -func MlrvalAssertingNotNull(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNotNull(ma) - return assertingCommon(ma, &check, "is_not_null", context) +func MlrvalAssertingNotNull(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNotNull(input1) + return assertingCommon(input1, &check, "is_not_null", context) } -func MlrvalAssertingNull(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNull(ma) - return assertingCommon(ma, &check, "is_null", context) +func MlrvalAssertingNull(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNull(input1) + return assertingCommon(input1, &check, "is_null", context) } -func MlrvalAssertingNumeric(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsNumeric(ma) - return assertingCommon(ma, &check, "is_numeric", context) +func MlrvalAssertingNumeric(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsNumeric(input1) + return assertingCommon(input1, &check, "is_numeric", context) } -func MlrvalAssertingPresent(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsPresent(ma) - return assertingCommon(ma, &check, "is_present", context) +func MlrvalAssertingPresent(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsPresent(input1) + return assertingCommon(input1, &check, "is_present", context) } -func MlrvalAssertingString(ma *Mlrval, context *Context) Mlrval { - check := MlrvalIsString(ma) - return assertingCommon(ma, &check, "is_string", context) +func MlrvalAssertingString(input1 *Mlrval, context *Context) Mlrval { + check := MlrvalIsString(input1) + return assertingCommon(input1, &check, "is_string", context) }