summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/d5/tengo/stdlib
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/d5/tengo/stdlib')
-rw-r--r--vendor/github.com/d5/tengo/stdlib/errors.go11
-rw-r--r--vendor/github.com/d5/tengo/stdlib/func_typedefs.go1057
-rw-r--r--vendor/github.com/d5/tengo/stdlib/math.go74
-rw-r--r--vendor/github.com/d5/tengo/stdlib/os.go437
-rw-r--r--vendor/github.com/d5/tengo/stdlib/os_exec.go109
-rw-r--r--vendor/github.com/d5/tengo/stdlib/os_file.go93
-rw-r--r--vendor/github.com/d5/tengo/stdlib/os_process.go60
-rw-r--r--vendor/github.com/d5/tengo/stdlib/rand.go99
-rw-r--r--vendor/github.com/d5/tengo/stdlib/stdlib.go16
-rw-r--r--vendor/github.com/d5/tengo/stdlib/text.go585
-rw-r--r--vendor/github.com/d5/tengo/stdlib/text_regexp.go195
-rw-r--r--vendor/github.com/d5/tengo/stdlib/times.go982
12 files changed, 3718 insertions, 0 deletions
diff --git a/vendor/github.com/d5/tengo/stdlib/errors.go b/vendor/github.com/d5/tengo/stdlib/errors.go
new file mode 100644
index 00000000..a2942bb0
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/errors.go
@@ -0,0 +1,11 @@
+package stdlib
+
+import "github.com/d5/tengo/objects"
+
+func wrapError(err error) objects.Object {
+ if err == nil {
+ return objects.TrueValue
+ }
+
+ return &objects.Error{Value: &objects.String{Value: err.Error()}}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/func_typedefs.go b/vendor/github.com/d5/tengo/stdlib/func_typedefs.go
new file mode 100644
index 00000000..a85619fa
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/func_typedefs.go
@@ -0,0 +1,1057 @@
+package stdlib
+
+import (
+ "fmt"
+
+ "github.com/d5/tengo/objects"
+)
+
+// FuncAR transform a function of 'func()' signature
+// into CallableFunc type.
+func FuncAR(fn func()) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ fn()
+
+ return objects.UndefinedValue, nil
+ }
+}
+
+// FuncARI transform a function of 'func() int' signature
+// into CallableFunc type.
+func FuncARI(fn func() int) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return &objects.Int{Value: int64(fn())}, nil
+ }
+}
+
+// FuncARI64 transform a function of 'func() int64' signature
+// into CallableFunc type.
+func FuncARI64(fn func() int64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return &objects.Int{Value: fn()}, nil
+ }
+}
+
+// FuncAI64RI64 transform a function of 'func(int64) int64' signature
+// into CallableFunc type.
+func FuncAI64RI64(fn func(int64) int64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.Int{Value: fn(i1)}, nil
+ }
+}
+
+// FuncAI64R transform a function of 'func(int64)' signature
+// into CallableFunc type.
+func FuncAI64R(fn func(int64)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ fn(i1)
+
+ return objects.UndefinedValue, nil
+ }
+}
+
+// FuncARB transform a function of 'func() bool' signature
+// into CallableFunc type.
+func FuncARB(fn func() bool) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ if fn() {
+ return objects.TrueValue, nil
+ }
+
+ return objects.FalseValue, nil
+ }
+}
+
+// FuncARE transform a function of 'func() error' signature
+// into CallableFunc type.
+func FuncARE(fn func() error) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return wrapError(fn()), nil
+ }
+}
+
+// FuncARS transform a function of 'func() string' signature
+// into CallableFunc type.
+func FuncARS(fn func() string) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return &objects.String{Value: fn()}, nil
+ }
+}
+
+// FuncARSE transform a function of 'func() (string, error)' signature
+// into CallableFunc type.
+func FuncARSE(fn func() (string, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ res, err := fn()
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.String{Value: res}, nil
+ }
+}
+
+// FuncARYE transform a function of 'func() ([]byte, error)' signature
+// into CallableFunc type.
+func FuncARYE(fn func() ([]byte, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ res, err := fn()
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.Bytes{Value: res}, nil
+ }
+}
+
+// FuncARF transform a function of 'func() float64' signature
+// into CallableFunc type.
+func FuncARF(fn func() float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return &objects.Float{Value: fn()}, nil
+ }
+}
+
+// FuncARSs transform a function of 'func() []string' signature
+// into CallableFunc type.
+func FuncARSs(fn func() []string) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ arr := &objects.Array{}
+ for _, osArg := range fn() {
+ arr.Value = append(arr.Value, &objects.String{Value: osArg})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncARIsE transform a function of 'func() ([]int, error)' signature
+// into CallableFunc type.
+func FuncARIsE(fn func() ([]int, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ res, err := fn()
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ arr := &objects.Array{}
+ for _, v := range res {
+ arr.Value = append(arr.Value, &objects.Int{Value: int64(v)})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncAIRIs transform a function of 'func(int) []int' signature
+// into CallableFunc type.
+func FuncAIRIs(fn func(int) []int) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res := fn(i1)
+
+ arr := &objects.Array{}
+ for _, v := range res {
+ arr.Value = append(arr.Value, &objects.Int{Value: int64(v)})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncAFRF transform a function of 'func(float64) float64' signature
+// into CallableFunc type.
+func FuncAFRF(fn func(float64) float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.Float{Value: fn(f1)}, nil
+ }
+}
+
+// FuncAIR transform a function of 'func(int)' signature
+// into CallableFunc type.
+func FuncAIR(fn func(int)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ fn(i1)
+
+ return objects.UndefinedValue, nil
+ }
+}
+
+// FuncAIRF transform a function of 'func(int) float64' signature
+// into CallableFunc type.
+func FuncAIRF(fn func(int) float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.Float{Value: fn(i1)}, nil
+ }
+}
+
+// FuncAFRI transform a function of 'func(float64) int' signature
+// into CallableFunc type.
+func FuncAFRI(fn func(float64) int) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.Int{Value: int64(fn(f1))}, nil
+ }
+}
+
+// FuncAFFRF transform a function of 'func(float64, float64) float64' signature
+// into CallableFunc type.
+func FuncAFFRF(fn func(float64, float64) float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ f2, ok := objects.ToFloat64(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "float(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.Float{Value: fn(f1, f2)}, nil
+ }
+}
+
+// FuncAIFRF transform a function of 'func(int, float64) float64' signature
+// into CallableFunc type.
+func FuncAIFRF(fn func(int, float64) float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ f2, ok := objects.ToFloat64(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "float(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.Float{Value: fn(i1, f2)}, nil
+ }
+}
+
+// FuncAFIRF transform a function of 'func(float64, int) float64' signature
+// into CallableFunc type.
+func FuncAFIRF(fn func(float64, int) float64) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.Float{Value: fn(f1, i2)}, nil
+ }
+}
+
+// FuncAFIRB transform a function of 'func(float64, int) bool' signature
+// into CallableFunc type.
+func FuncAFIRB(fn func(float64, int) bool) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ if fn(f1, i2) {
+ return objects.TrueValue, nil
+ }
+
+ return objects.FalseValue, nil
+ }
+}
+
+// FuncAFRB transform a function of 'func(float64) bool' signature
+// into CallableFunc type.
+func FuncAFRB(fn func(float64) bool) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ f1, ok := objects.ToFloat64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ if fn(f1) {
+ return objects.TrueValue, nil
+ }
+
+ return objects.FalseValue, nil
+ }
+}
+
+// FuncASRS transform a function of 'func(string) string' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRS(fn func(string) string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.String{Value: fn(s1)}, nil
+ }
+}
+
+// FuncASRSs transform a function of 'func(string) []string' signature into CallableFunc type.
+func FuncASRSs(fn func(string) []string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res := fn(s1)
+
+ arr := &objects.Array{}
+ for _, osArg := range res {
+ arr.Value = append(arr.Value, &objects.String{Value: osArg})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncASRSE transform a function of 'func(string) (string, error)' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRSE(fn func(string) (string, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := fn(s1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.String{Value: res}, nil
+ }
+}
+
+// FuncASRE transform a function of 'func(string) error' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRE(fn func(string) error) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return wrapError(fn(s1)), nil
+ }
+}
+
+// FuncASSRE transform a function of 'func(string, string) error' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASSRE(fn func(string, string) error) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return wrapError(fn(s1, s2)), nil
+ }
+}
+
+// FuncASSRSs transform a function of 'func(string, string) []string' signature into CallableFunc type.
+func FuncASSRSs(fn func(string, string) []string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ arr := &objects.Array{}
+ for _, res := range fn(s1, s2) {
+ arr.Value = append(arr.Value, &objects.String{Value: res})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncASSIRSs transform a function of 'func(string, string, int) []string' signature into CallableFunc type.
+func FuncASSIRSs(fn func(string, string, int) []string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 3 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ }
+
+ arr := &objects.Array{}
+ for _, res := range fn(s1, s2, i3) {
+ arr.Value = append(arr.Value, &objects.String{Value: res})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncASSRI transform a function of 'func(string, string) int' signature into CallableFunc type.
+func FuncASSRI(fn func(string, string) int) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.Int{Value: int64(fn(s1, s2))}, nil
+ }
+}
+
+// FuncASSRS transform a function of 'func(string, string) string' signature into CallableFunc type.
+func FuncASSRS(fn func(string, string) string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.String{Value: fn(s1, s2)}, nil
+ }
+}
+
+// FuncASSRB transform a function of 'func(string, string) bool' signature into CallableFunc type.
+func FuncASSRB(fn func(string, string) bool) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ if fn(s1, s2) {
+ return objects.TrueValue, nil
+ }
+
+ return objects.FalseValue, nil
+ }
+}
+
+// FuncASsSRS transform a function of 'func([]string, string) string' signature into CallableFunc type.
+func FuncASsSRS(fn func([]string, string) string) objects.CallableFunc {
+ return func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ var ss1 []string
+ switch arg0 := args[0].(type) {
+ case *objects.Array:
+ for idx, a := range arg0.Value {
+ as, ok := objects.ToString(a)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: fmt.Sprintf("first[%d]", idx),
+ Expected: "string(compatible)",
+ Found: a.TypeName(),
+ }
+ }
+ ss1 = append(ss1, as)
+ }
+ case *objects.ImmutableArray:
+ for idx, a := range arg0.Value {
+ as, ok := objects.ToString(a)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: fmt.Sprintf("first[%d]", idx),
+ Expected: "string(compatible)",
+ Found: a.TypeName(),
+ }
+ }
+ ss1 = append(ss1, as)
+ }
+ default:
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "array",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.String{Value: fn(ss1, s2)}, nil
+ }
+}
+
+// FuncASI64RE transform a function of 'func(string, int64) error' signature
+// into CallableFunc type.
+func FuncASI64RE(fn func(string, int64) error) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt64(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return wrapError(fn(s1, i2)), nil
+ }
+}
+
+// FuncAIIRE transform a function of 'func(int, int) error' signature
+// into CallableFunc type.
+func FuncAIIRE(fn func(int, int) error) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return wrapError(fn(i1, i2)), nil
+ }
+}
+
+// FuncASIRS transform a function of 'func(string, int) string' signature
+// into CallableFunc type.
+func FuncASIRS(fn func(string, int) string) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return &objects.String{Value: fn(s1, i2)}, nil
+ }
+}
+
+// FuncASIIRE transform a function of 'func(string, int, int) error' signature
+// into CallableFunc type.
+func FuncASIIRE(fn func(string, int, int) error) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 3 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ }
+
+ return wrapError(fn(s1, i2, i3)), nil
+ }
+}
+
+// FuncAYRIE transform a function of 'func([]byte) (int, error)' signature
+// into CallableFunc type.
+func FuncAYRIE(fn func([]byte) (int, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ y1, ok := objects.ToByteSlice(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "bytes(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := fn(y1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.Int{Value: int64(res)}, nil
+ }
+}
+
+// FuncASRIE transform a function of 'func(string) (int, error)' signature
+// into CallableFunc type.
+func FuncASRIE(fn func(string) (int, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := fn(s1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.Int{Value: int64(res)}, nil
+ }
+}
+
+// FuncAIRSsE transform a function of 'func(int) ([]string, error)' signature
+// into CallableFunc type.
+func FuncAIRSsE(fn func(int) ([]string, error)) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := fn(i1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ arr := &objects.Array{}
+ for _, r := range res {
+ arr.Value = append(arr.Value, &objects.String{Value: r})
+ }
+
+ return arr, nil
+ }
+}
+
+// FuncAIRS transform a function of 'func(int) string' signature
+// into CallableFunc type.
+func FuncAIRS(fn func(int) string) objects.CallableFunc {
+ return func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return &objects.String{Value: fn(i1)}, nil
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/math.go b/vendor/github.com/d5/tengo/stdlib/math.go
new file mode 100644
index 00000000..08d82bdf
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/math.go
@@ -0,0 +1,74 @@
+package stdlib
+
+import (
+ "math"
+
+ "github.com/d5/tengo/objects"
+)
+
+var mathModule = map[string]objects.Object{
+ "e": &objects.Float{Value: math.E},
+ "pi": &objects.Float{Value: math.Pi},
+ "phi": &objects.Float{Value: math.Phi},
+ "sqrt2": &objects.Float{Value: math.Sqrt2},
+ "sqrtE": &objects.Float{Value: math.SqrtE},
+ "sqrtPi": &objects.Float{Value: math.SqrtPi},
+ "sqrtPhi": &objects.Float{Value: math.SqrtPhi},
+ "ln2": &objects.Float{Value: math.Ln2},
+ "log2E": &objects.Float{Value: math.Log2E},
+ "ln10": &objects.Float{Value: math.Ln10},
+ "log10E": &objects.Float{Value: math.Log10E},
+ "abs": &objects.UserFunction{Name: "abs", Value: FuncAFRF(math.Abs)},
+ "acos": &objects.UserFunction{Name: "acos", Value: FuncAFRF(math.Acos)},
+ "acosh": &objects.UserFunction{Name: "acosh", Value: FuncAFRF(math.Acosh)},
+ "asin": &objects.UserFunction{Name: "asin", Value: FuncAFRF(math.Asin)},
+ "asinh": &objects.UserFunction{Name: "asinh", Value: FuncAFRF(math.Asinh)},
+ "atan": &objects.UserFunction{Name: "atan", Value: FuncAFRF(math.Atan)},
+ "atan2": &objects.UserFunction{Name: "atan2", Value: FuncAFFRF(math.Atan2)},
+ "atanh": &objects.UserFunction{Name: "atanh", Value: FuncAFRF(math.Atanh)},
+ "cbrt": &objects.UserFunction{Name: "cbrt", Value: FuncAFRF(math.Cbrt)},
+ "ceil": &objects.UserFunction{Name: "ceil", Value: FuncAFRF(math.Ceil)},
+ "copysign": &objects.UserFunction{Name: "copysign", Value: FuncAFFRF(math.Copysign)},
+ "cos": &objects.UserFunction{Name: "cos", Value: FuncAFRF(math.Cos)},
+ "cosh": &objects.UserFunction{Name: "cosh", Value: FuncAFRF(math.Cosh)},
+ "dim": &objects.UserFunction{Name: "dim", Value: FuncAFFRF(math.Dim)},
+ "erf": &objects.UserFunction{Name: "erf", Value: FuncAFRF(math.Erf)},
+ "erfc": &objects.UserFunction{Name: "erfc", Value: FuncAFRF(math.Erfc)},
+ "exp": &objects.UserFunction{Name: "exp", Value: FuncAFRF(math.Exp)},
+ "exp2": &objects.UserFunction{Name: "exp2", Value: FuncAFRF(math.Exp2)},
+ "expm1": &objects.UserFunction{Name: "expm1", Value: FuncAFRF(math.Expm1)},
+ "floor": &objects.UserFunction{Name: "floor", Value: FuncAFRF(math.Floor)},
+ "gamma": &objects.UserFunction{Name: "gamma", Value: FuncAFRF(math.Gamma)},
+ "hypot": &objects.UserFunction{Name: "hypot", Value: FuncAFFRF(math.Hypot)},
+ "ilogb": &objects.UserFunction{Name: "ilogb", Value: FuncAFRI(math.Ilogb)},
+ "inf": &objects.UserFunction{Name: "inf", Value: FuncAIRF(math.Inf)},
+ "is_inf": &objects.UserFunction{Name: "is_inf", Value: FuncAFIRB(math.IsInf)},
+ "is_nan": &objects.UserFunction{Name: "is_nan", Value: FuncAFRB(math.IsNaN)},
+ "j0": &objects.UserFunction{Name: "j0", Value: FuncAFRF(math.J0)},
+ "j1": &objects.UserFunction{Name: "j1", Value: FuncAFRF(math.J1)},
+ "jn": &objects.UserFunction{Name: "jn", Value: FuncAIFRF(math.Jn)},
+ "ldexp": &objects.UserFunction{Name: "ldexp", Value: FuncAFIRF(math.Ldexp)},
+ "log": &objects.UserFunction{Name: "log", Value: FuncAFRF(math.Log)},
+ "log10": &objects.UserFunction{Name: "log10", Value: FuncAFRF(math.Log10)},
+ "log1p": &objects.UserFunction{Name: "log1p", Value: FuncAFRF(math.Log1p)},
+ "log2": &objects.UserFunction{Name: "log2", Value: FuncAFRF(math.Log2)},
+ "logb": &objects.UserFunction{Name: "logb", Value: FuncAFRF(math.Logb)},
+ "max": &objects.UserFunction{Name: "max", Value: FuncAFFRF(math.Max)},
+ "min": &objects.UserFunction{Name: "min", Value: FuncAFFRF(math.Min)},
+ "mod": &objects.UserFunction{Name: "mod", Value: FuncAFFRF(math.Mod)},
+ "nan": &objects.UserFunction{Name: "nan", Value: FuncARF(math.NaN)},
+ "nextafter": &objects.UserFunction{Name: "nextafter", Value: FuncAFFRF(math.Nextafter)},
+ "pow": &objects.UserFunction{Name: "pow", Value: FuncAFFRF(math.Pow)},
+ "pow10": &objects.UserFunction{Name: "pow10", Value: FuncAIRF(math.Pow10)},
+ "remainder": &objects.UserFunction{Name: "remainder", Value: FuncAFFRF(math.Remainder)},
+ "signbit": &objects.UserFunction{Name: "signbit", Value: FuncAFRB(math.Signbit)},
+ "sin": &objects.UserFunction{Name: "sin", Value: FuncAFRF(math.Sin)},
+ "sinh": &objects.UserFunction{Name: "sinh", Value: FuncAFRF(math.Sinh)},
+ "sqrt": &objects.UserFunction{Name: "sqrt", Value: FuncAFRF(math.Sqrt)},
+ "tan": &objects.UserFunction{Name: "tan", Value: FuncAFRF(math.Tan)},
+ "tanh": &objects.UserFunction{Name: "tanh", Value: FuncAFRF(math.Tanh)},
+ "trunc": &objects.UserFunction{Name: "trunc", Value: FuncAFRF(math.Trunc)},
+ "y0": &objects.UserFunction{Name: "y0", Value: FuncAFRF(math.Y0)},
+ "y1": &objects.UserFunction{Name: "y1", Value: FuncAFRF(math.Y1)},
+ "yn": &objects.UserFunction{Name: "yn", Value: FuncAIFRF(math.Yn)},
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os.go b/vendor/github.com/d5/tengo/stdlib/os.go
new file mode 100644
index 00000000..e68d5101
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os.go
@@ -0,0 +1,437 @@
+package stdlib
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "os/exec"
+
+ "github.com/d5/tengo/objects"
+)
+
+var osModule = map[string]objects.Object{
+ "o_rdonly": &objects.Int{Value: int64(os.O_RDONLY)},
+ "o_wronly": &objects.Int{Value: int64(os.O_WRONLY)},
+ "o_rdwr": &objects.Int{Value: int64(os.O_RDWR)},
+ "o_append": &objects.Int{Value: int64(os.O_APPEND)},
+ "o_create": &objects.Int{Value: int64(os.O_CREATE)},
+ "o_excl": &objects.Int{Value: int64(os.O_EXCL)},
+ "o_sync": &objects.Int{Value: int64(os.O_SYNC)},
+ "o_trunc": &objects.Int{Value: int64(os.O_TRUNC)},
+ "mode_dir": &objects.Int{Value: int64(os.ModeDir)},
+ "mode_append": &objects.Int{Value: int64(os.ModeAppend)},
+ "mode_exclusive": &objects.Int{Value: int64(os.ModeExclusive)},
+ "mode_temporary": &objects.Int{Value: int64(os.ModeTemporary)},
+ "mode_symlink": &objects.Int{Value: int64(os.ModeSymlink)},
+ "mode_device": &objects.Int{Value: int64(os.ModeDevice)},
+ "mode_named_pipe": &objects.Int{Value: int64(os.ModeNamedPipe)},
+ "mode_socket": &objects.Int{Value: int64(os.ModeSocket)},
+ "mode_setuid": &objects.Int{Value: int64(os.ModeSetuid)},
+ "mode_setgui": &objects.Int{Value: int64(os.ModeSetgid)},
+ "mode_char_device": &objects.Int{Value: int64(os.ModeCharDevice)},
+ "mode_sticky": &objects.Int{Value: int64(os.ModeSticky)},
+ "mode_type": &objects.Int{Value: int64(os.ModeType)},
+ "mode_perm": &objects.Int{Value: int64(os.ModePerm)},
+ "path_separator": &objects.Char{Value: os.PathSeparator},
+ "path_list_separator": &objects.Char{Value: os.PathListSeparator},
+ "dev_null": &objects.String{Value: os.DevNull},
+ "seek_set": &objects.Int{Value: int64(io.SeekStart)},
+ "seek_cur": &objects.Int{Value: int64(io.SeekCurrent)},
+ "seek_end": &objects.Int{Value: int64(io.SeekEnd)},
+ "args": &objects.UserFunction{Value: osArgs}, // args() => array(string)
+ "chdir": &objects.UserFunction{Name: "chdir", Value: FuncASRE(os.Chdir)}, // chdir(dir string) => error
+ "chmod": osFuncASFmRE(os.Chmod), // chmod(name string, mode int) => error
+ "chown": &objects.UserFunction{Name: "chown", Value: FuncASIIRE(os.Chown)}, // chown(name string, uid int, gid int) => error
+ "clearenv": &objects.UserFunction{Name: "clearenv", Value: FuncAR(os.Clearenv)}, // clearenv()
+ "environ": &objects.UserFunction{Name: "environ", Value: FuncARSs(os.Environ)}, // environ() => array(string)
+ "exit": &objects.UserFunction{Name: "exit", Value: FuncAIR(os.Exit)}, // exit(code int)
+ "expand_env": &objects.UserFunction{Name: "expand_env", Value: FuncASRS(os.ExpandEnv)}, // expand_env(s string) => string
+ "getegid": &objects.UserFunction{Name: "getegid", Value: FuncARI(os.Getegid)}, // getegid() => int
+ "getenv": &objects.UserFunction{Name: "getenv", Value: FuncASRS(os.Getenv)}, // getenv(s string) => string
+ "geteuid": &objects.UserFunction{Name: "geteuid", Value: FuncARI(os.Geteuid)}, // geteuid() => int
+ "getgid": &objects.UserFunction{Name: "getgid", Value: FuncARI(os.Getgid)}, // getgid() => int
+ "getgroups": &objects.UserFunction{Name: "getgroups", Value: FuncARIsE(os.Getgroups)}, // getgroups() => array(string)/error
+ "getpagesize": &objects.UserFunction{Name: "getpagesize", Value: FuncARI(os.Getpagesize)}, // getpagesize() => int
+ "getpid": &objects.UserFunction{Name: "getpid", Value: FuncARI(os.Getpid)}, // getpid() => int
+ "getppid": &objects.UserFunction{Name: "getppid", Value: FuncARI(os.Getppid)}, // getppid() => int
+ "getuid": &objects.UserFunction{Name: "getuid", Value: FuncARI(os.Getuid)}, // getuid() => int
+ "getwd": &objects.UserFunction{Name: "getwd", Value: FuncARSE(os.Getwd)}, // getwd() => string/error
+ "hostname": &objects.UserFunction{Name: "hostname", Value: FuncARSE(os.Hostname)}, // hostname() => string/error
+ "lchown": &objects.UserFunction{Name: "lchown", Value: FuncASIIRE(os.Lchown)}, // lchown(name string, uid int, gid int) => error
+ "link": &objects.UserFunction{Name: "link", Value: FuncASSRE(os.Link)}, // link(oldname string, newname string) => error
+ "lookup_env": &objects.UserFunction{Value: osLookupEnv}, // lookup_env(key string) => string/false
+ "mkdir": osFuncASFmRE(os.Mkdir), // mkdir(name string, perm int) => error
+ "mkdir_all": osFuncASFmRE(os.MkdirAll), // mkdir_all(name string, perm int) => error
+ "readlink": &objects.UserFunction{Name: "readlink", Value: FuncASRSE(os.Readlink)}, // readlink(name string) => string/error
+ "remove": &objects.UserFunction{Name: "remove", Value: FuncASRE(os.Remove)}, // remove(name string) => error
+ "remove_all": &objects.UserFunction{Name: "remove_all", Value: FuncASRE(os.RemoveAll)}, // remove_all(name string) => error
+ "rename": &objects.UserFunction{Name: "rename", Value: FuncASSRE(os.Rename)}, // rename(oldpath string, newpath string) => error
+ "setenv": &objects.UserFunction{Name: "setenv", Value: FuncASSRE(os.Setenv)}, // setenv(key string, value string) => error
+ "symlink": &objects.UserFunction{Name: "symlink", Value: FuncASSRE(os.Symlink)}, // symlink(oldname string newname string) => error
+ "temp_dir": &objects.UserFunction{Name: "temp_dir", Value: FuncARS(os.TempDir)}, // temp_dir() => string
+ "truncate": &objects.UserFunction{Name: "truncate", Value: FuncASI64RE(os.Truncate)}, // truncate(name string, size int) => error
+ "unsetenv": &objects.UserFunction{Name: "unsetenv", Value: FuncASRE(os.Unsetenv)}, // unsetenv(key string) => error
+ "create": &objects.UserFunction{Value: osCreate}, // create(name string) => imap(file)/error
+ "open": &objects.UserFunction{Value: osOpen}, // open(name string) => imap(file)/error
+ "open_file": &objects.UserFunction{Value: osOpenFile}, // open_file(name string, flag int, perm int) => imap(file)/error
+ "find_process": &objects.UserFunction{Value: osFindProcess}, // find_process(pid int) => imap(process)/error
+ "start_process": &objects.UserFunction{Value: osStartProcess}, // start_process(name string, argv array(string), dir string, env array(string)) => imap(process)/error
+ "exec_look_path": &objects.UserFunction{Name: "exec_look_path", Value: FuncASRSE(exec.LookPath)}, // exec_look_path(file) => string/error
+ "exec": &objects.UserFunction{Value: osExec}, // exec(name, args...) => command
+ "stat": &objects.UserFunction{Value: osStat}, // stat(name) => imap(fileinfo)/error
+ "read_file": &objects.UserFunction{Value: osReadFile}, // readfile(name) => array(byte)/error
+}
+
+func osReadFile(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ fname, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ bytes, err := ioutil.ReadFile(fname)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.Bytes{Value: bytes}, nil
+}
+
+func osStat(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ fname, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ stat, err := os.Stat(fname)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ fstat := &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ "name": &objects.String{Value: stat.Name()},
+ "mtime": &objects.Time{Value: stat.ModTime()},
+ "size": &objects.Int{Value: stat.Size()},
+ "mode": &objects.Int{Value: int64(stat.Mode())},
+ },
+ }
+
+ if stat.IsDir() {
+ fstat.Value["directory"] = objects.TrueValue
+ } else {
+ fstat.Value["directory"] = objects.FalseValue
+ }
+
+ return fstat, nil
+}
+
+func osCreate(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := os.Create(s1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSFile(res), nil
+}
+
+func osOpen(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := os.Open(s1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSFile(res), nil
+}
+
+func osOpenFile(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 3 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ }
+
+ res, err := os.OpenFile(s1, i2, os.FileMode(i3))
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSFile(res), nil
+}
+
+func osArgs(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ arr := &objects.Array{}
+ for _, osArg := range os.Args {
+ arr.Value = append(arr.Value, &objects.String{Value: osArg})
+ }
+
+ return arr, nil
+}
+
+func osFuncASFmRE(fn func(string, os.FileMode) error) *objects.UserFunction {
+ return &objects.UserFunction{
+ Value: func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+ i2, ok := objects.ToInt64(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ return wrapError(fn(s1, os.FileMode(i2))), nil
+ },
+ }
+}
+
+func osLookupEnv(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, ok := os.LookupEnv(s1)
+ if !ok {
+ return objects.FalseValue, nil
+ }
+
+ return &objects.String{Value: res}, nil
+}
+
+func osExec(args ...objects.Object) (objects.Object, error) {
+ if len(args) == 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ name, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ var execArgs []string
+ for idx, arg := range args[1:] {
+ execArg, ok := objects.ToString(arg)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: fmt.Sprintf("args[%d]", idx),
+ Expected: "string(compatible)",
+ Found: args[1+idx].TypeName(),
+ }
+ }
+
+ execArgs = append(execArgs, execArg)
+ }
+
+ return makeOSExecCommand(exec.Command(name, execArgs...)), nil
+}
+
+func osFindProcess(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ proc, err := os.FindProcess(i1)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSProcess(proc), nil
+}
+
+func osStartProcess(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 4 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ name, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ var argv []string
+ var err error
+ switch arg1 := args[1].(type) {
+ case *objects.Array:
+ argv, err = stringArray(arg1.Value, "second")
+ if err != nil {
+ return nil, err
+ }
+ case *objects.ImmutableArray:
+ argv, err = stringArray(arg1.Value, "second")
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "array",
+ Found: arg1.TypeName(),
+ }
+ }
+
+ dir, ok := objects.ToString(args[2])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "string(compatible)",
+ Found: args[2].TypeName(),
+ }
+ }
+
+ var env []string
+ switch arg3 := args[3].(type) {
+ case *objects.Array:
+ env, err = stringArray(arg3.Value, "fourth")
+ if err != nil {
+ return nil, err
+ }
+ case *objects.ImmutableArray:
+ env, err = stringArray(arg3.Value, "fourth")
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "fourth",
+ Expected: "array",
+ Found: arg3.TypeName(),
+ }
+ }
+
+ proc, err := os.StartProcess(name, argv, &os.ProcAttr{
+ Dir: dir,
+ Env: env,
+ })
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSProcess(proc), nil
+}
+
+func stringArray(arr []objects.Object, argName string) ([]string, error) {
+ var sarr []string
+ for idx, elem := range arr {
+ str, ok := elem.(*objects.String)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: fmt.Sprintf("%s[%d]", argName, idx),
+ Expected: "string",
+ Found: elem.TypeName(),
+ }
+ }
+
+ sarr = append(sarr, str.Value)
+ }
+
+ return sarr, nil
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_exec.go b/vendor/github.com/d5/tengo/stdlib/os_exec.go
new file mode 100644
index 00000000..809c5810
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_exec.go
@@ -0,0 +1,109 @@
+package stdlib
+
+import (
+ "os/exec"
+
+ "github.com/d5/tengo/objects"
+)
+
+func makeOSExecCommand(cmd *exec.Cmd) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ // combined_output() => bytes/error
+ "combined_output": &objects.UserFunction{Name: "combined_output", Value: FuncARYE(cmd.CombinedOutput)}, //
+ // output() => bytes/error
+ "output": &objects.UserFunction{Name: "output", Value: FuncARYE(cmd.Output)}, //
+ // run() => error
+ "run": &objects.UserFunction{Name: "run", Value: FuncARE(cmd.Run)}, //
+ // start() => error
+ "start": &objects.UserFunction{Name: "start", Value: FuncARE(cmd.Start)}, //
+ // wait() => error
+ "wait": &objects.UserFunction{Name: "wait", Value: FuncARE(cmd.Wait)}, //
+ // set_path(path string)
+ "set_path": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ cmd.Path = s1
+
+ return objects.UndefinedValue, nil
+ },
+ },
+ // set_dir(dir string)
+ "set_dir": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ cmd.Dir = s1
+
+ return objects.UndefinedValue, nil
+ },
+ },
+ // set_env(env array(string))
+ "set_env": &objects.UserFunction{
+ Value: func(args ...objects.Object) (objects.Object, error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ var env []string
+ var err error
+ switch arg0 := args[0].(type) {
+ case *objects.Array:
+ env, err = stringArray(arg0.Value, "first")
+ if err != nil {
+ return nil, err
+ }
+ case *objects.ImmutableArray:
+ env, err = stringArray(arg0.Value, "first")
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "array",
+ Found: arg0.TypeName(),
+ }
+ }
+
+ cmd.Env = env
+
+ return objects.UndefinedValue, nil
+ },
+ },
+ // process() => imap(process)
+ "process": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return makeOSProcess(cmd.Process), nil
+ },
+ },
+ },
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_file.go b/vendor/github.com/d5/tengo/stdlib/os_file.go
new file mode 100644
index 00000000..4fc41dd8
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_file.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+ "os"
+
+ "github.com/d5/tengo/objects"
+)
+
+func makeOSFile(file *os.File) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ // chdir() => true/error
+ "chdir": &objects.UserFunction{Name: "chdir", Value: FuncARE(file.Chdir)}, //
+ // chown(uid int, gid int) => true/error
+ "chown": &objects.UserFunction{Name: "chown", Value: FuncAIIRE(file.Chown)}, //
+ // close() => error
+ "close": &objects.UserFunction{Name: "close", Value: FuncARE(file.Close)}, //
+ // name() => string
+ "name": &objects.UserFunction{Name: "name", Value: FuncARS(file.Name)}, //
+ // readdirnames(n int) => array(string)/error
+ "readdirnames": &objects.UserFunction{Name: "readdirnames", Value: FuncAIRSsE(file.Readdirnames)}, //
+ // sync() => error
+ "sync": &objects.UserFunction{Name: "sync", Value: FuncARE(file.Sync)}, //
+ // write(bytes) => int/error
+ "write": &objects.UserFunction{Name: "write", Value: FuncAYRIE(file.Write)}, //
+ // write(string) => int/error
+ "write_string": &objects.UserFunction{Name: "write_string", Value: FuncASRIE(file.WriteString)}, //
+ // read(bytes) => int/error
+ "read": &objects.UserFunction{Name: "read", Value: FuncAYRIE(file.Read)}, //
+ // chmod(mode int) => error
+ "chmod": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return wrapError(file.Chmod(os.FileMode(i1))), nil
+ },
+ },
+ // seek(offset int, whence int) => int/error
+ "seek": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ }
+
+ res, err := file.Seek(i1, i2)
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return &objects.Int{Value: res}, nil
+ },
+ },
+ // stat() => imap(fileinfo)/error
+ "stat": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ return osStat(&objects.String{Value: file.Name()})
+ },
+ },
+ },
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_process.go b/vendor/github.com/d5/tengo/stdlib/os_process.go
new file mode 100644
index 00000000..0f4a9f77
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_process.go
@@ -0,0 +1,60 @@
+package stdlib
+
+import (
+ "os"
+ "syscall"
+
+ "github.com/d5/tengo/objects"
+)
+
+func makeOSProcessState(state *os.ProcessState) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ "exited": &objects.UserFunction{Name: "exited", Value: FuncARB(state.Exited)}, //
+ "pid": &objects.UserFunction{Name: "pid", Value: FuncARI(state.Pid)}, //
+ "string": &objects.UserFunction{Name: "string", Value: FuncARS(state.String)}, //
+ "success": &objects.UserFunction{Name: "success", Value: FuncARB(state.Success)}, //
+ },
+ }
+}
+
+func makeOSProcess(proc *os.Process) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ "kill": &objects.UserFunction{Name: "kill", Value: FuncARE(proc.Kill)}, //
+ "release": &objects.UserFunction{Name: "release", Value: FuncARE(proc.Release)}, //
+ "signal": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ return wrapError(proc.Signal(syscall.Signal(i1))), nil
+ },
+ },
+ "wait": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ state, err := proc.Wait()
+ if err != nil {
+ return wrapError(err), nil
+ }
+
+ return makeOSProcessState(state), nil
+ },
+ },
+ },
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/rand.go b/vendor/github.com/d5/tengo/stdlib/rand.go
new file mode 100644
index 00000000..248d8e79
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/rand.go
@@ -0,0 +1,99 @@
+package stdlib
+
+import (
+ "math/rand"
+
+ "github.com/d5/tengo/objects"
+)
+
+var randModule = map[string]objects.Object{
+ "int": &objects.UserFunction{Name: "int", Value: FuncARI64(rand.Int63)},
+ "float": &objects.UserFunction{Name: "float", Value: FuncARF(rand.Float64)},
+ "intn": &objects.UserFunction{Name: "intn", Value: FuncAI64RI64(rand.Int63n)},
+ "exp_float": &objects.UserFunction{Name: "exp_float", Value: FuncARF(rand.ExpFloat64)},
+ "norm_float": &objects.UserFunction{Name: "norm_float", Value: FuncARF(rand.NormFloat64)},
+ "perm": &objects.UserFunction{Name: "perm", Value: FuncAIRIs(rand.Perm)},
+ "seed": &objects.UserFunction{Name: "seed", Value: FuncAI64R(rand.Seed)},
+ "read": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ y1, ok := args[0].(*objects.Bytes)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "bytes",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := rand.Read(y1.Value)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ return &objects.Int{Value: int64(res)}, nil
+ },
+ },
+ "rand": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ src := rand.NewSource(i1)
+
+ return randRand(rand.New(src)), nil
+ },
+ },
+}
+
+func randRand(r *rand.Rand) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ "int": &objects.UserFunction{Name: "int", Value: FuncARI64(r.Int63)},
+ "float": &objects.UserFunction{Name: "float", Value: FuncARF(r.Float64)},
+ "intn": &objects.UserFunction{Name: "intn", Value: FuncAI64RI64(r.Int63n)},
+ "exp_float": &objects.UserFunction{Name: "exp_float", Value: FuncARF(r.ExpFloat64)},
+ "norm_float": &objects.UserFunction{Name: "norm_float", Value: FuncARF(r.NormFloat64)},
+ "perm": &objects.UserFunction{Name: "perm", Value: FuncAIRIs(r.Perm)},
+ "seed": &objects.UserFunction{Name: "seed", Value: FuncAI64R(r.Seed)},
+ "read": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ return nil, objects.ErrWrongNumArguments
+ }
+
+ y1, ok := args[0].(*objects.Bytes)
+ if !ok {
+ return nil, objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "bytes",
+ Found: args[0].TypeName(),
+ }
+ }
+
+ res, err := r.Read(y1.Value)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ return &objects.Int{Value: int64(res)}, nil
+ },
+ },
+ },
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/stdlib.go b/vendor/github.com/d5/tengo/stdlib/stdlib.go
new file mode 100644
index 00000000..d34fbc82
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/stdlib.go
@@ -0,0 +1,16 @@
+package stdlib
+
+import "github.com/d5/tengo/objects"
+
+// Modules contain the standard modules.
+var Modules = map[string]*objects.Object{
+ "math": objectPtr(&objects.ImmutableMap{Value: mathModule}),
+ "os": objectPtr(&objects.ImmutableMap{Value: osModule}),
+ "text": objectPtr(&objects.ImmutableMap{Value: textModule}),
+ "times": objectPtr(&objects.ImmutableMap{Value: timesModule}),
+ "rand": objectPtr(&objects.ImmutableMap{Value: randModule}),
+}
+
+func objectPtr(o objects.Object) *objects.Object {
+ return &o
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/text.go b/vendor/github.com/d5/tengo/stdlib/text.go
new file mode 100644
index 00000000..053bebf5
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/text.go
@@ -0,0 +1,585 @@
+package stdlib
+
+import (
+ "regexp"
+ "strconv"
+ "strings"
+
+ "github.com/d5/tengo/objects"
+)
+
+var textModule = map[string]objects.Object{
+ "re_match": &objects.UserFunction{Value: textREMatch}, // re_match(pattern, text) => bool/error
+ "re_find": &objects.UserFunction{Value: textREFind}, // re_find(pattern, text, count) => [[{text:,begin:,end:}]]/undefined
+ "re_replace": &objects.UserFunction{Value: textREReplace}, // re_replace(pattern, text, repl) => string/error
+ "re_split": &objects.UserFunction{Value: textRESplit}, // re_split(pattern, text, count) => [string]/error
+ "re_compile": &objects.UserFunction{Value: textRECompile}, // re_compile(pattern) => Regexp/error
+ "compare": &objects.UserFunction{Name: "compare", Value: FuncASSRI(strings.Compare)}, // compare(a, b) => int
+ "contains": &objects.UserFunction{Name: "contains", Value: FuncASSRB(strings.Contains)}, // contains(s, substr) => bool
+ "contains_any": &objects.UserFunction{Name: "contains_any", Value: FuncASSRB(strings.ContainsAny)}, // contains_any(s, chars) => bool
+ "count": &objects.UserFunction{Name: "count", Value: FuncASSRI(strings.Count)}, // count(s, substr) => int
+ "equal_fold": &objects.UserFunction{Name: "equal_fold", Value: FuncASSRB(strings.EqualFold)}, // "equal_fold(s, t) => bool
+ "fields": &objects.UserFunction{Name: "fields", Value: FuncASRSs(strings.Fields)}, // fields(s) => [string]
+ "has_prefix": &objects.UserFunction{Name: "has_prefix", Value: FuncASSRB(strings.HasPrefix)}, // has_prefix(s, prefix) => bool
+ "has_suffix": &objects.UserFunction{Name: "has_suffix", Value: FuncASSRB(strings.HasSuffix)}, // has_suffix(s, suffix) => bool
+ "index": &objects.UserFunction{Name: "index", Value: FuncASSRI(strings.Index)}, // index(s, substr) => int
+ "index_any": &objects.UserFunction{Name: "index_any", Value: FuncASSRI(strings.IndexAny)}, // index_any(s, chars) => int
+ "join": &objects.UserFunction{Name: "join", Value: FuncASsSRS(strings.Join)}, // join(arr, sep) => string
+ "last_index": &objects.UserFunction{Name: "last_index", Value: FuncASSRI(strings.LastIndex)}, // last_index(s, substr) => int
+ "last_index_any": &objects.UserFunction{Name: "last_index_any", Value: FuncASSRI(strings.LastIndexAny)}, // last_index_any(s, chars) => int
+ "repeat": &objects.UserFunction{Name: "repeat", Value: FuncASIRS(strings.Repeat)}, // repeat(s, count) => string
+ "replace": &objects.UserFunction{Value: textReplace}, // replace(s, old, new, n) => string
+ "split": &objects.UserFunction{Name: "split", Value: FuncASSRSs(strings.Split)}, // split(s, sep) => [string]
+ "split_after": &objects.UserFunction{Name: "split_after", Value: FuncASSRSs(strings.SplitAfter)}, // split_after(s, sep) => [string]
+ "split_after_n": &objects.UserFunction{Name: "split_after_n", Value: FuncASSIRSs(strings.SplitAfterN)}, // split_after_n(s, sep, n) => [string]
+ "split_n": &objects.UserFunction{Name: "split_n", Value: FuncASSIRSs(strings.SplitN)}, // split_n(s, sep, n) => [string]
+ "title": &objects.UserFunction{Name: "title", Value: FuncASRS(strings.Title)}, // title(s) => string
+ "to_lower": &objects.UserFunction{Name: "to_lower", Value: FuncASRS(strings.ToLower)}, // to_lower(s) => string
+ "to_title": &objects.UserFunction{Name: "to_title", Value: FuncASRS(strings.ToTitle)}, // to_title(s) => string
+ "to_upper": &objects.UserFunction{Name: "to_upper", Value: FuncASRS(strings.ToUpper)}, // to_upper(s) => string
+ "trim_left": &objects.UserFunction{Name: "trim_left", Value: FuncASSRS(strings.TrimLeft)}, // trim_left(s, cutset) => string
+ "trim_prefix": &objects.UserFunction{Name: "trim_prefix", Value: FuncASSRS(strings.TrimPrefix)}, // trim_prefix(s, prefix) => string
+ "trim_right": &objects.UserFunction{Name: "trim_right", Value: FuncASSRS(strings.TrimRight)}, // trim_right(s, cutset) => string
+ "trim_space": &objects.UserFunction{Name: "trim_space", Value: FuncASRS(strings.TrimSpace)}, // trim_space(s) => string
+ "trim_suffix": &objects.UserFunction{Name: "trim_suffix", Value: FuncASSRS(strings.TrimSuffix)}, // trim_suffix(s, suffix) => string
+ "atoi": &objects.UserFunction{Name: "atoi", Value: FuncASRIE(strconv.Atoi)}, // atoi(str) => int/error
+ "format_bool": &objects.UserFunction{Value: textFormatBool}, // format_bool(b) => string
+ "format_float": &objects.UserFunction{Value: textFormatFloat}, // format_float(f, fmt, prec, bits) => string
+ "format_int": &objects.UserFunction{Value: textFormatInt}, // format_int(i, base) => string
+ "itoa": &objects.UserFunction{Name: "itoa", Value: FuncAIRS(strconv.Itoa)}, // itoa(i) => string
+ "parse_bool": &objects.UserFunction{Value: textParseBool}, // parse_bool(str) => bool/error
+ "parse_float": &objects.UserFunction{Value: textParseFloat}, // parse_float(str, bits) => float/error
+ "parse_int": &objects.UserFunction{Value: textParseInt}, // parse_int(str, base, bits) => int/error
+ "quote": &objects.UserFunction{Name: "quote", Value: FuncASRS(strconv.Quote)}, // quote(str) => string
+ "unquote": &objects.UserFunction{Name: "unquote", Value: FuncASRSE(strconv.Unquote)}, // unquote(str) => string/error
+}
+
+func textREMatch(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ matched, err := regexp.MatchString(s1, s2)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ if matched {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+}
+
+func textREFind(args ...objects.Object) (ret objects.Object, err error) {
+ numArgs := len(args)
+ if numArgs != 2 && numArgs != 3 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ re, err := regexp.Compile(s1)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ if numArgs < 3 {
+ m := re.FindStringSubmatchIndex(s2)
+ if m == nil {
+ ret = objects.UndefinedValue
+ return
+ }
+
+ arr := &objects.Array{}
+ for i := 0; i < len(m); i += 2 {
+ arr.Value = append(arr.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+ "text": &objects.String{Value: s2[m[i]:m[i+1]]},
+ "begin": &objects.Int{Value: int64(m[i])},
+ "end": &objects.Int{Value: int64(m[i+1])},
+ }})
+ }
+
+ ret = &objects.Array{Value: []objects.Object{arr}}
+
+ return
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+ m := re.FindAllStringSubmatchIndex(s2, i3)
+ if m == nil {
+ ret = objects.UndefinedValue
+ return
+ }
+
+ arr := &objects.Array{}
+ for _, m := range m {
+ subMatch := &objects.Array{}
+ for i := 0; i < len(m); i += 2 {
+ subMatch.Value = append(subMatch.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+ "text": &objects.String{Value: s2[m[i]:m[i+1]]},
+ "begin": &objects.Int{Value: int64(m[i])},
+ "end": &objects.Int{Value: int64(m[i+1])},
+ }})
+ }
+
+ arr.Value = append(arr.Value, subMatch)
+ }
+
+ ret = arr
+
+ return
+}
+
+func textREReplace(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 3 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ s3, ok := objects.ToString(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "string(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+
+ re, err := regexp.Compile(s1)
+ if err != nil {
+ ret = wrapError(err)
+ } else {
+ ret = &objects.String{Value: re.ReplaceAllString(s2, s3)}
+ }
+
+ return
+}
+
+func textRESplit(args ...objects.Object) (ret objects.Object, err error) {
+ numArgs := len(args)
+ if numArgs != 2 && numArgs != 3 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ var i3 = -1
+ if numArgs > 2 {
+ i3, ok = objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+ }
+
+ re, err := regexp.Compile(s1)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ arr := &objects.Array{}
+ for _, s := range re.Split(s2, i3) {
+ arr.Value = append(arr.Value, &objects.String{Value: s})
+ }
+
+ ret = arr
+
+ return
+}
+
+func textRECompile(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ re, err := regexp.Compile(s1)
+ if err != nil {
+ ret = wrapError(err)
+ } else {
+ ret = makeTextRegexp(re)
+ }
+
+ return
+}
+
+func textReplace(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 4 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ s3, ok := objects.ToString(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "string(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+
+ i4, ok := objects.ToInt(args[3])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "fourth",
+ Expected: "int(compatible)",
+ Found: args[3].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: strings.Replace(s1, s2, s3, i4)}
+
+ return
+}
+
+func textFormatBool(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ b1, ok := args[0].(*objects.Bool)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "bool",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ if b1 == objects.TrueValue {
+ ret = &objects.String{Value: "true"}
+ } else {
+ ret = &objects.String{Value: "false"}
+ }
+
+ return
+}
+
+func textFormatFloat(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 4 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ f1, ok := args[0].(*objects.Float)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "float",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+
+ i4, ok := objects.ToInt(args[3])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "fourth",
+ Expected: "int(compatible)",
+ Found: args[3].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: strconv.FormatFloat(f1.Value, s2[0], i3, i4)}
+
+ return
+}
+
+func textFormatInt(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := args[0].(*objects.Int)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: strconv.FormatInt(i1.Value, i2)}
+
+ return
+}
+
+func textParseBool(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := args[0].(*objects.String)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ parsed, err := strconv.ParseBool(s1.Value)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ if parsed {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+}
+
+func textParseFloat(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := args[0].(*objects.String)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ parsed, err := strconv.ParseFloat(s1.Value, i2)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ ret = &objects.Float{Value: parsed}
+
+ return
+}
+
+func textParseInt(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 3 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := args[0].(*objects.String)
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+
+ parsed, err := strconv.ParseInt(s1.Value, i2, i3)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ ret = &objects.Int{Value: parsed}
+
+ return
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/text_regexp.go b/vendor/github.com/d5/tengo/stdlib/text_regexp.go
new file mode 100644
index 00000000..3fb8b3b3
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/text_regexp.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+ "regexp"
+
+ "github.com/d5/tengo/objects"
+)
+
+func makeTextRegexp(re *regexp.Regexp) *objects.ImmutableMap {
+ return &objects.ImmutableMap{
+ Value: map[string]objects.Object{
+ // match(text) => bool
+ "match": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ if re.MatchString(s1) {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+ },
+ },
+
+ // find(text) => array(array({text:,begin:,end:}))/undefined
+ // find(text, maxCount) => array(array({text:,begin:,end:}))/undefined
+ "find": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ numArgs := len(args)
+ if numArgs != 1 && numArgs != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ if numArgs == 1 {
+ m := re.FindStringSubmatchIndex(s1)
+ if m == nil {
+ ret = objects.UndefinedValue
+ return
+ }
+
+ arr := &objects.Array{}
+ for i := 0; i < len(m); i += 2 {
+ arr.Value = append(arr.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+ "text": &objects.String{Value: s1[m[i]:m[i+1]]},
+ "begin": &objects.Int{Value: int64(m[i])},
+ "end": &objects.Int{Value: int64(m[i+1])},
+ }})
+ }
+
+ ret = &objects.Array{Value: []objects.Object{arr}}
+
+ return
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+ m := re.FindAllStringSubmatchIndex(s1, i2)
+ if m == nil {
+ ret = objects.UndefinedValue
+ return
+ }
+
+ arr := &objects.Array{}
+ for _, m := range m {
+ subMatch := &objects.Array{}
+ for i := 0; i < len(m); i += 2 {
+ subMatch.Value = append(subMatch.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+ "text": &objects.String{Value: s1[m[i]:m[i+1]]},
+ "begin": &objects.Int{Value: int64(m[i])},
+ "end": &objects.Int{Value: int64(m[i+1])},
+ }})
+ }
+
+ arr.Value = append(arr.Value, subMatch)
+ }
+
+ ret = arr
+
+ return
+ },
+ },
+
+ // replace(src, repl) => string
+ "replace": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: re.ReplaceAllString(s1, s2)}
+
+ return
+ },
+ },
+
+ // split(text) => array(string)
+ // split(text, maxCount) => array(string)
+ "split": &objects.UserFunction{
+ Value: func(args ...objects.Object) (ret objects.Object, err error) {
+ numArgs := len(args)
+ if numArgs != 1 && numArgs != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ var i2 = -1
+ if numArgs > 1 {
+ i2, ok = objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+ }
+
+ arr := &objects.Array{}
+ for _, s := range re.Split(s1, i2) {
+ arr.Value = append(arr.Value, &objects.String{Value: s})
+ }
+
+ ret = arr
+
+ return
+ },
+ },
+ },
+ }
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/times.go b/vendor/github.com/d5/tengo/stdlib/times.go
new file mode 100644
index 00000000..16d6d146
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/times.go
@@ -0,0 +1,982 @@
+package stdlib
+
+import (
+ "time"
+
+ "github.com/d5/tengo/objects"
+)
+
+var timesModule = map[string]objects.Object{
+ "format_ansic": &objects.String{Value: time.ANSIC},
+ "format_unix_date": &objects.String{Value: time.UnixDate},
+ "format_ruby_date": &objects.String{Value: time.RubyDate},
+ "format_rfc822": &objects.String{Value: time.RFC822},
+ "format_rfc822z": &objects.String{Value: time.RFC822Z},
+ "format_rfc850": &objects.String{Value: time.RFC850},
+ "format_rfc1123": &objects.String{Value: time.RFC1123},
+ "format_rfc1123z": &objects.String{Value: time.RFC1123Z},
+ "format_rfc3339": &objects.String{Value: time.RFC3339},
+ "format_rfc3339_nano": &objects.String{Value: time.RFC3339Nano},
+ "format_kitchen": &objects.String{Value: time.Kitchen},
+ "format_stamp": &objects.String{Value: time.Stamp},
+ "format_stamp_milli": &objects.String{Value: time.StampMilli},
+ "format_stamp_micro": &objects.String{Value: time.StampMicro},
+ "format_stamp_nano": &objects.String{Value: time.StampNano},
+ "nanosecond": &objects.Int{Value: int64(time.Nanosecond)},
+ "microsecond": &objects.Int{Value: int64(time.Microsecond)},
+ "millisecond": &objects.Int{Value: int64(time.Millisecond)},
+ "second": &objects.Int{Value: int64(time.Second)},
+ "minute": &objects.Int{Value: int64(time.Minute)},
+ "hour": &objects.Int{Value: int64(time.Hour)},
+ "january": &objects.Int{Value: int64(time.January)},
+ "february": &objects.Int{Value: int64(time.February)},
+ "march": &objects.Int{Value: int64(time.March)},
+ "april": &objects.Int{Value: int64(time.April)},
+ "may": &objects.Int{Value: int64(time.May)},
+ "june": &objects.Int{Value: int64(time.June)},
+ "july": &objects.Int{Value: int64(time.July)},
+ "august": &objects.Int{Value: int64(time.August)},
+ "september": &objects.Int{Value: int64(time.September)},
+ "october": &objects.Int{Value: int64(time.October)},
+ "november": &objects.Int{Value: int64(time.November)},
+ "december": &objects.Int{Value: int64(time.December)},
+ "sleep": &objects.UserFunction{Name: "sleep", Value: timesSleep}, // sleep(int)
+ "parse_duration": &objects.UserFunction{Name: "parse_duration", Value: timesParseDuration}, // parse_duration(str) => int
+ "since": &objects.UserFunction{Name: "since", Value: timesSince}, // since(time) => int
+ "until": &objects.UserFunction{Name: "until", Value: timesUntil}, // until(time) => int
+ "duration_hours": &objects.UserFunction{Name: "duration_hours", Value: timesDurationHours}, // duration_hours(int) => float
+ "duration_minutes": &objects.UserFunction{Name: "duration_minutes", Value: timesDurationMinutes}, // duration_minutes(int) => float
+ "duration_nanoseconds": &objects.UserFunction{Name: "duration_nanoseconds", Value: timesDurationNanoseconds}, // duration_nanoseconds(int) => int
+ "duration_seconds": &objects.UserFunction{Name: "duration_seconds", Value: timesDurationSeconds}, // duration_seconds(int) => float
+ "duration_string": &objects.UserFunction{Name: "duration_string", Value: timesDurationString}, // duration_string(int) => string
+ "month_string": &objects.UserFunction{Name: "month_string", Value: timesMonthString}, // month_string(int) => string
+ "date": &objects.UserFunction{Name: "date", Value: timesDate}, // date(year, month, day, hour, min, sec, nsec) => time
+ "now": &objects.UserFunction{Name: "now", Value: timesNow}, // now() => time
+ "parse": &objects.UserFunction{Name: "parse", Value: timesParse}, // parse(format, str) => time
+ "unix": &objects.UserFunction{Name: "unix", Value: timesUnix}, // unix(sec, nsec) => time
+ "add": &objects.UserFunction{Name: "add", Value: timesAdd}, // add(time, int) => time
+ "add_date": &objects.UserFunction{Name: "add_date", Value: timesAddDate}, // add_date(time, years, months, days) => time
+ "sub": &objects.UserFunction{Name: "sub", Value: timesSub}, // sub(t time, u time) => int
+ "after": &objects.UserFunction{Name: "after", Value: timesAfter}, // after(t time, u time) => bool
+ "before": &objects.UserFunction{Name: "before", Value: timesBefore}, // before(t time, u time) => bool
+ "time_year": &objects.UserFunction{Name: "time_year", Value: timesTimeYear}, // time_year(time) => int
+ "time_month": &objects.UserFunction{Name: "time_month", Value: timesTimeMonth}, // time_month(time) => int
+ "time_day": &objects.UserFunction{Name: "time_day", Value: timesTimeDay}, // time_day(time) => int
+ "time_weekday": &objects.UserFunction{Name: "time_weekday", Value: timesTimeWeekday}, // time_weekday(time) => int
+ "time_hour": &objects.UserFunction{Name: "time_hour", Value: timesTimeHour}, // time_hour(time) => int
+ "time_minute": &objects.UserFunction{Name: "time_minute", Value: timesTimeMinute}, // time_minute(time) => int
+ "time_second": &objects.UserFunction{Name: "time_second", Value: timesTimeSecond}, // time_second(time) => int
+ "time_nanosecond": &objects.UserFunction{Name: "time_nanosecond", Value: timesTimeNanosecond}, // time_nanosecond(time) => int
+ "time_unix": &objects.UserFunction{Name: "time_unix", Value: timesTimeUnix}, // time_unix(time) => int
+ "time_unix_nano": &objects.UserFunction{Name: "time_unix_nano", Value: timesTimeUnixNano}, // time_unix_nano(time) => int
+ "time_format": &objects.UserFunction{Name: "time_format", Value: timesTimeFormat}, // time_format(time, format) => string
+ "time_location": &objects.UserFunction{Name: "time_location", Value: timesTimeLocation}, // time_location(time) => string
+ "time_string": &objects.UserFunction{Name: "time_string", Value: timesTimeString}, // time_string(time) => string
+ "is_zero": &objects.UserFunction{Name: "is_zero", Value: timesIsZero}, // is_zero(time) => bool
+ "to_local": &objects.UserFunction{Name: "to_local", Value: timesToLocal}, // to_local(time) => time
+ "to_utc": &objects.UserFunction{Name: "to_utc", Value: timesToUTC}, // to_utc(time) => time
+}
+
+func timesSleep(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ time.Sleep(time.Duration(i1))
+ ret = objects.UndefinedValue
+
+ return
+}
+
+func timesParseDuration(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ dur, err := time.ParseDuration(s1)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ ret = &objects.Int{Value: int64(dur)}
+
+ return
+}
+
+func timesSince(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(time.Since(t1))}
+
+ return
+}
+
+func timesUntil(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(time.Until(t1))}
+
+ return
+}
+
+func timesDurationHours(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Float{Value: time.Duration(i1).Hours()}
+
+ return
+}
+
+func timesDurationMinutes(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Float{Value: time.Duration(i1).Minutes()}
+
+ return
+}
+
+func timesDurationNanoseconds(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: time.Duration(i1).Nanoseconds()}
+
+ return
+}
+
+func timesDurationSeconds(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Float{Value: time.Duration(i1).Seconds()}
+
+ return
+}
+
+func timesDurationString(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: time.Duration(i1).String()}
+
+ return
+}
+
+func timesMonthString(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: time.Month(i1).String()}
+
+ return
+}
+
+func timesDate(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 7 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+ i4, ok := objects.ToInt(args[3])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "fourth",
+ Expected: "int(compatible)",
+ Found: args[3].TypeName(),
+ }
+ return
+ }
+ i5, ok := objects.ToInt(args[4])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "fifth",
+ Expected: "int(compatible)",
+ Found: args[4].TypeName(),
+ }
+ return
+ }
+ i6, ok := objects.ToInt(args[5])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "sixth",
+ Expected: "int(compatible)",
+ Found: args[5].TypeName(),
+ }
+ return
+ }
+ i7, ok := objects.ToInt(args[6])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "seventh",
+ Expected: "int(compatible)",
+ Found: args[6].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: time.Date(i1, time.Month(i2), i3, i4, i5, i6, i7, time.Now().Location())}
+
+ return
+}
+
+func timesNow(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 0 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ ret = &objects.Time{Value: time.Now()}
+
+ return
+}
+
+func timesParse(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ s1, ok := objects.ToString(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "string(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ parsed, err := time.Parse(s1, s2)
+ if err != nil {
+ ret = wrapError(err)
+ return
+ }
+
+ ret = &objects.Time{Value: parsed}
+
+ return
+}
+
+func timesUnix(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ i1, ok := objects.ToInt64(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "int(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt64(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: time.Unix(i1, i2)}
+
+ return
+}
+
+func timesAdd(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt64(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: t1.Add(time.Duration(i2))}
+
+ return
+}
+
+func timesSub(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ t2, ok := objects.ToTime(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "time(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Sub(t2))}
+
+ return
+}
+
+func timesAddDate(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 4 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ i2, ok := objects.ToInt(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "int(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ i3, ok := objects.ToInt(args[2])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "third",
+ Expected: "int(compatible)",
+ Found: args[2].TypeName(),
+ }
+ return
+ }
+
+ i4, ok := objects.ToInt(args[3])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "fourth",
+ Expected: "int(compatible)",
+ Found: args[3].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: t1.AddDate(i2, i3, i4)}
+
+ return
+}
+
+func timesAfter(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ t2, ok := objects.ToTime(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "time(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ if t1.After(t2) {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+}
+
+func timesBefore(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ t2, ok := objects.ToTime(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ if t1.Before(t2) {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+}
+
+func timesTimeYear(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Year())}
+
+ return
+}
+
+func timesTimeMonth(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Month())}
+
+ return
+}
+
+func timesTimeDay(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Day())}
+
+ return
+}
+
+func timesTimeWeekday(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Weekday())}
+
+ return
+}
+
+func timesTimeHour(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Hour())}
+
+ return
+}
+
+func timesTimeMinute(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Minute())}
+
+ return
+}
+
+func timesTimeSecond(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Second())}
+
+ return
+}
+
+func timesTimeNanosecond(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Nanosecond())}
+
+ return
+}
+
+func timesTimeUnix(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.Unix())}
+
+ return
+}
+
+func timesTimeUnixNano(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Int{Value: int64(t1.UnixNano())}
+
+ return
+}
+
+func timesTimeFormat(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 2 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ s2, ok := objects.ToString(args[1])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "second",
+ Expected: "string(compatible)",
+ Found: args[1].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: t1.Format(s2)}
+
+ return
+}
+
+func timesIsZero(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ if t1.IsZero() {
+ ret = objects.TrueValue
+ } else {
+ ret = objects.FalseValue
+ }
+
+ return
+}
+
+func timesToLocal(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: t1.Local()}
+
+ return
+}
+
+func timesToUTC(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.Time{Value: t1.UTC()}
+
+ return
+}
+
+func timesTimeLocation(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: t1.Location().String()}
+
+ return
+}
+
+func timesTimeString(args ...objects.Object) (ret objects.Object, err error) {
+ if len(args) != 1 {
+ err = objects.ErrWrongNumArguments
+ return
+ }
+
+ t1, ok := objects.ToTime(args[0])
+ if !ok {
+ err = objects.ErrInvalidArgumentType{
+ Name: "first",
+ Expected: "time(compatible)",
+ Found: args[0].TypeName(),
+ }
+ return
+ }
+
+ ret = &objects.String{Value: t1.String()}
+
+ return
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-04 17:56:54 +0000