mirror of
https://github.com/cwinfo/matterbridge.git
synced 2024-11-25 11:01:35 +00:00
738 lines
19 KiB
Go
738 lines
19 KiB
Go
package stdlib
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"unicode/utf8"
|
|
|
|
"github.com/d5/tengo"
|
|
"github.com/d5/tengo/objects"
|
|
)
|
|
|
|
var textModule = map[string]objects.Object{
|
|
"re_match": &objects.UserFunction{Name: "re_match", Value: textREMatch}, // re_match(pattern, text) => bool/error
|
|
"re_find": &objects.UserFunction{Name: "re_find", Value: textREFind}, // re_find(pattern, text, count) => [[{text:,begin:,end:}]]/undefined
|
|
"re_replace": &objects.UserFunction{Name: "re_replace", Value: textREReplace}, // re_replace(pattern, text, repl) => string/error
|
|
"re_split": &objects.UserFunction{Name: "re_split", Value: textRESplit}, // re_split(pattern, text, count) => [string]/error
|
|
"re_compile": &objects.UserFunction{Name: "re_compile", 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: textJoin}, // 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: textRepeat}, // repeat(s, count) => string
|
|
"replace": &objects.UserFunction{Name: "replace", 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{Name: "format_bool", Value: textFormatBool}, // format_bool(b) => string
|
|
"format_float": &objects.UserFunction{Name: "format_float", Value: textFormatFloat}, // format_float(f, fmt, prec, bits) => string
|
|
"format_int": &objects.UserFunction{Name: "format_int", Value: textFormatInt}, // format_int(i, base) => string
|
|
"itoa": &objects.UserFunction{Name: "itoa", Value: FuncAIRS(strconv.Itoa)}, // itoa(i) => string
|
|
"parse_bool": &objects.UserFunction{Name: "parse_bool", Value: textParseBool}, // parse_bool(str) => bool/error
|
|
"parse_float": &objects.UserFunction{Name: "parse_float", Value: textParseFloat}, // parse_float(str, bits) => float/error
|
|
"parse_int": &objects.UserFunction{Name: "parse_int", 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 {
|
|
s, ok := doTextRegexpReplace(re, s2, s3)
|
|
if !ok {
|
|
return nil, objects.ErrStringLimit
|
|
}
|
|
|
|
ret = &objects.String{Value: s}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
s, ok := doTextReplace(s1, s2, s3, i4)
|
|
if !ok {
|
|
err = objects.ErrStringLimit
|
|
return
|
|
}
|
|
|
|
ret = &objects.String{Value: s}
|
|
|
|
return
|
|
}
|
|
|
|
func textRepeat(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(),
|
|
}
|
|
}
|
|
|
|
if len(s1)*i2 > tengo.MaxStringLen {
|
|
return nil, objects.ErrStringLimit
|
|
}
|
|
|
|
return &objects.String{Value: strings.Repeat(s1, i2)}, nil
|
|
}
|
|
|
|
func textJoin(args ...objects.Object) (ret objects.Object, err error) {
|
|
if len(args) != 2 {
|
|
return nil, objects.ErrWrongNumArguments
|
|
}
|
|
|
|
var slen int
|
|
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(),
|
|
}
|
|
}
|
|
slen += len(as)
|
|
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(),
|
|
}
|
|
}
|
|
slen += len(as)
|
|
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(),
|
|
}
|
|
}
|
|
|
|
// make sure output length does not exceed the limit
|
|
if slen+len(s2)*(len(ss1)-1) > tengo.MaxStringLen {
|
|
return nil, objects.ErrStringLimit
|
|
}
|
|
|
|
return &objects.String{Value: strings.Join(ss1, s2)}, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// Modified implementation of strings.Replace
|
|
// to limit the maximum length of output string.
|
|
func doTextReplace(s, old, new string, n int) (string, bool) {
|
|
if old == new || n == 0 {
|
|
return s, true // avoid allocation
|
|
}
|
|
|
|
// Compute number of replacements.
|
|
if m := strings.Count(s, old); m == 0 {
|
|
return s, true // avoid allocation
|
|
} else if n < 0 || m < n {
|
|
n = m
|
|
}
|
|
|
|
// Apply replacements to buffer.
|
|
t := make([]byte, len(s)+n*(len(new)-len(old)))
|
|
w := 0
|
|
start := 0
|
|
for i := 0; i < n; i++ {
|
|
j := start
|
|
if len(old) == 0 {
|
|
if i > 0 {
|
|
_, wid := utf8.DecodeRuneInString(s[start:])
|
|
j += wid
|
|
}
|
|
} else {
|
|
j += strings.Index(s[start:], old)
|
|
}
|
|
|
|
ssj := s[start:j]
|
|
if w+len(ssj)+len(new) > tengo.MaxStringLen {
|
|
return "", false
|
|
}
|
|
|
|
w += copy(t[w:], ssj)
|
|
w += copy(t[w:], new)
|
|
start = j + len(old)
|
|
}
|
|
|
|
ss := s[start:]
|
|
if w+len(ss) > tengo.MaxStringLen {
|
|
return "", false
|
|
}
|
|
|
|
w += copy(t[w:], ss)
|
|
|
|
return string(t[0:w]), true
|
|
}
|