Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-08-02 04:22:59 +00:00
Code Issues Projects Releases Wiki Activity

rename ma,mb,mc -> input1,input2,input3 in mlrval functions

Browse source
This commit is contained in:
John Kerl 2021-02-20 19:07:55 -05:00
parent cc4c10526b
commit 05c7cf1d2a
14 changed files with 937 additions and 937 deletions
Download patch file Download diff file Expand all files Collapse all files

24
go/src/types/mlrval_function_hashing.go
View file

@ -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)),
),
)
}

402
go/src/types/mlrval_functions_arithmetic.go
View file

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

40
go/src/types/mlrval_functions_base.go
View file

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

66
go/src/types/mlrval_functions_bits.go
View file

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

256
go/src/types/mlrval_functions_booleans.go
View file

@ -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()
}

280
go/src/types/mlrval_functions_collections.go
View file

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

6
go/src/types/mlrval_functions_math.go
View file

@ -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()
}

144
go/src/types/mlrval_functions_mathlib.go
View file

@ -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()
}

32
go/src/types/mlrval_functions_random.go
View file

@ -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()
}

114
go/src/types/mlrval_functions_regex.go
View file

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

60
go/src/types/mlrval_functions_sort.go
View file

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

170
go/src/types/mlrval_functions_strings.go
View file

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

26
go/src/types/mlrval_functions_time.go
View file

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

254
go/src/types/mlrval_functions_types.go
View file

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