type conversion builtin functions: string(), int(), bool(), float(), char()

ast/undefined_lit.go

@@ -0,0 +1,21 @@
+package ast
+
+import "github.com/d5/tengo/scanner"
+
+type UndefinedLit struct {
+	TokenPos scanner.Pos
+}
+
+func (e *UndefinedLit) exprNode() {}
+
+func (e *UndefinedLit) Pos() scanner.Pos {
+	return e.TokenPos
+}
+
+func (e *UndefinedLit) End() scanner.Pos {
+	return e.TokenPos + 9 // len(undefined) == 9
+}
+
+func (e *UndefinedLit) String() string {
+	return "undefined"
+}

compiler/compiler.go

@@ -162,6 +162,10 @@ func (c *Compiler) Compile(node ast.Node) error {
 		}
 	case *ast.StringLit:
 		c.emit(OpConstant, c.addConstant(&objects.String{Value: node.Value}))
+	case *ast.CharLit:
+		c.emit(OpConstant, c.addConstant(&objects.Char{Value: node.Value}))
+	case *ast.UndefinedLit:
+		c.emit(OpNull)
 	case *ast.UnaryExpr:
 		if err := c.Compile(node.Expr); err != nil {
 			return err

objects/array.go

@@ -46,7 +46,7 @@ func (o *Array) Copy() Object {
 }
 
 func (o *Array) IsFalsy() bool {
-	return false
+	return len(o.Value) == 0
 }
 
 func (o *Array) Equals(x Object) bool {

objects/builtin_convert.go

@@ -0,0 +1,104 @@
+package objects
+
+import (
+	"errors"
+	"strconv"
+)
+
+func builtinString(args ...Object) (Object, error) {
+	if len(args) != 1 {
+		return nil, errors.New("wrong number of arguments")
+	}
+
+	switch arg := args[0].(type) {
+	case *String:
+		return arg, nil
+	case *Undefined:
+		return undefined, nil
+	default:
+		return &String{Value: arg.String()}, nil
+	}
+}
+
+func builtinInt(args ...Object) (Object, error) {
+	if len(args) != 1 {
+		return nil, errors.New("wrong number of arguments")
+	}
+
+	switch arg := args[0].(type) {
+	case *Int:
+		return arg, nil
+	case *Float:
+		return &Int{Value: int64(arg.Value)}, nil
+	case *Char:
+		return &Int{Value: int64(arg.Value)}, nil
+	case *Bool:
+		if arg.Value {
+			return &Int{Value: 1}, nil
+		}
+		return &Int{Value: 0}, nil
+	case *String:
+		n, err := strconv.ParseInt(arg.Value, 10, 64)
+		if err == nil {
+			return &Int{Value: n}, nil
+		}
+	}
+
+	return undefined, nil
+}
+
+func builtinFloat(args ...Object) (Object, error) {
+	if len(args) != 1 {
+		return nil, errors.New("wrong number of arguments")
+	}
+
+	switch arg := args[0].(type) {
+	case *Float:
+		return arg, nil
+	case *Int:
+		return &Float{Value: float64(arg.Value)}, nil
+	case *String:
+		f, err := strconv.ParseFloat(arg.Value, 64)
+		if err == nil {
+			return &Float{Value: f}, nil
+		}
+	}
+
+	return undefined, nil
+}
+
+func builtinBool(args ...Object) (Object, error) {
+	if len(args) != 1 {
+		return nil, errors.New("wrong number of arguments")
+	}
+
+	switch arg := args[0].(type) {
+	case *Bool:
+		return arg, nil
+	default:
+		return &Bool{Value: !arg.IsFalsy()}, nil
+	}
+}
+
+func builtinChar(args ...Object) (Object, error) {
+	if len(args) != 1 {
+		return nil, errors.New("wrong number of arguments")
+	}
+
+	switch arg := args[0].(type) {
+	case *Char:
+		return arg, nil
+	case *Int:
+		return &Char{Value: rune(arg.Value)}, nil
+	case *String:
+		rs := []rune(arg.Value)
+		switch len(rs) {
+		case 0:
+			return &Char{}, nil
+		case 1:
+			return &Char{Value: rs[0]}, nil
+		}
+	}
+
+	return undefined, nil
+}

objects/builtins.go

@@ -22,4 +22,24 @@ var Builtins = []struct {
 		Name: "append",
 		Func: builtinAppend,
 	},
+	{
+		Name: "string",
+		Func: builtinString,
+	},
+	{
+		Name: "int",
+		Func: builtinInt,
+	},
+	{
+		Name: "bool",
+		Func: builtinBool,
+	},
+	{
+		Name: "float",
+		Func: builtinFloat,
+	},
+	{
+		Name: "char",
+		Func: builtinChar,
+	},
 }

objects/char.go

@@ -1,8 +1,6 @@
 package objects
 
 import (
-	"fmt"
-
 	"github.com/d5/tengo/token"
 )
 
@@ -11,7 +9,7 @@ type Char struct {
 }
 
 func (o *Char) String() string {
-	return fmt.Sprintf("%q", string(o.Value))
+	return string(o.Value)
 }
 
 func (o *Char) TypeName() string {
@@ -27,7 +25,7 @@ func (o *Char) Copy() Object {
 }
 
 func (o *Char) IsFalsy() bool {
-	return false
+	return o.Value == 0
 }
 
 func (o *Char) Equals(x Object) bool {

objects/float.go

@@ -1,6 +1,7 @@
 package objects
 
 import (
+	"math"
 	"strconv"
 
 	"github.com/d5/tengo/token"
@@ -68,7 +69,7 @@ func (o *Float) Copy() Object {
 }
 
 func (o *Float) IsFalsy() bool {
-	return false
+	return math.IsNaN(o.Value)
 }
 
 func (o *Float) Equals(x Object) bool {

objects/map.go

@@ -38,7 +38,7 @@ func (o *Map) Copy() Object {
 }
 
 func (o *Map) IsFalsy() bool {
-	return false
+	return len(o.Value) == 0
 }
 
 func (o *Map) Get(key string) (Object, bool) {

objects/undefined.go

@@ -2,6 +2,8 @@ package objects
 
 import "github.com/d5/tengo/token"
 
+var undefined = &Undefined{}
+
 type Undefined struct{}
 
 func (o Undefined) TypeName() string {

parser/parser.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"io"
 	"strconv"
-	"unicode/utf8"
 
 	"github.com/d5/tengo/ast"
 	"github.com/d5/tengo/scanner"
@@ -286,9 +285,8 @@ func (p *Parser) parseOperand() ast.Expr {
 		return x
 
 	case token.Char:
-		v, _ := utf8.DecodeRuneInString(p.tokenLit)
 		x := &ast.CharLit{
-			Value:    v,
+			Value:    rune(p.tokenLit[1]),
 			ValuePos: p.pos,
 			Literal:  p.tokenLit,
 		}
@@ -323,6 +321,11 @@ func (p *Parser) parseOperand() ast.Expr {
 		p.next()
 		return x
 
+	case token.Undefined:
+		x := &ast.UndefinedLit{TokenPos: p.pos}
+		p.next()
+		return x
+
 	case token.LParen:
 		lparen := p.pos
 		p.next()
@@ -485,10 +488,10 @@ func (p *Parser) parseStmt() (stmt ast.Stmt) {
 	}
 
 	switch p.token {
-	case                                                                                                                  // simple statements
+	case // simple statements
 		token.Func, token.Ident, token.Int, token.Float, token.Char, token.String, token.True, token.False, token.LParen, // operands
-		token.LBrace, token.LBrack,                                                                                       // composite types
-		token.Add, token.Sub, token.Mul, token.And, token.Xor, token.Not:                                                 // unary operators
+		token.LBrace, token.LBrack, // composite types
+		token.Add, token.Sub, token.Mul, token.And, token.Xor, token.Not: // unary operators
 		s := p.parseSimpleStmt(false)
 		p.expectSemi()
 		return s

token/tokens.go

@@ -78,6 +78,7 @@ const (
 	True
 	False
 	In
+	Undefined
 	_keywordEnd
 )
 
@@ -150,6 +151,7 @@ var tokens = [...]string{
 	True:         "true",
 	False:        "false",
 	In:           "in",
+	Undefined:    "undefined",
 }
 
 func (tok Token) String() string {

vm/vm_builtin_test.go

@@ -17,4 +17,60 @@ func TestBuiltinFunction(t *testing.T) {
 	expect(t, `out = append([1, 2, 3], 4)`, ARR{1, 2, 3, 4})
 	expect(t, `out = append([1, 2, 3], 4, 5, 6)`, ARR{1, 2, 3, 4, 5, 6})
 	expect(t, `out = append([1, 2, 3], "foo", false)`, ARR{1, 2, 3, "foo", false})
+
+	expect(t, `out = int(1)`, 1)
+	expect(t, `out = int(1.8)`, 1)
+	expect(t, `out = int("-522")`, -522)
+	expect(t, `out = int(true)`, 1)
+	expect(t, `out = int(false)`, 0)
+	expect(t, `out = int('8')`, 56)
+	expect(t, `out = int([1])`, undefined())
+	expect(t, `out = int({a: 1})`, undefined())
+	expect(t, `out = int(undefined)`, undefined())
+
+	expect(t, `out = string(1)`, "1")
+	expect(t, `out = string(1.8)`, "1.8")
+	expect(t, `out = string("-522")`, "-522")
+	expect(t, `out = string(true)`, "true")
+	expect(t, `out = string(false)`, "false")
+	expect(t, `out = string('8')`, "8")
+	expect(t, `out = string([1,8.1,true,3])`, "[1, 8.1, true, 3]")
+	expect(t, `out = string({b: "foo"})`, `{b: "foo"}`)
+	expect(t, `out = string(undefined)`, undefined()) // not "undefined"
+
+	expect(t, `out = float(1)`, 1.0)
+	expect(t, `out = float(1.8)`, 1.8)
+	expect(t, `out = float("-52.2")`, -52.2)
+	expect(t, `out = float(true)`, undefined())
+	expect(t, `out = float(false)`, undefined())
+	expect(t, `out = float('8')`, undefined())
+	expect(t, `out = float([1,8.1,true,3])`, undefined())
+	expect(t, `out = float({a: 1, b: "foo"})`, undefined())
+	expect(t, `out = float(undefined)`, undefined())
+
+	expect(t, `out = char(56)`, '8')
+	expect(t, `out = char(1.8)`, undefined())
+	expect(t, `out = char("-52.2")`, undefined())
+	expect(t, `out = char(true)`, undefined())
+	expect(t, `out = char(false)`, undefined())
+	expect(t, `out = char('8')`, '8')
+	expect(t, `out = char([1,8.1,true,3])`, undefined())
+	expect(t, `out = char({a: 1, b: "foo"})`, undefined())
+	expect(t, `out = char(undefined)`, undefined())
+
+	expect(t, `out = bool(1)`, true)          // non-zero integer: true
+	expect(t, `out = bool(0)`, false)         // zero: true
+	expect(t, `out = bool(1.8)`, true)        // all floats (except for NaN): true
+	expect(t, `out = bool(0.0)`, true)        // all floats (except for NaN): true
+	expect(t, `out = bool("false")`, true)    // non-empty string: true
+	expect(t, `out = bool("")`, false)        // empty string: false
+	expect(t, `out = bool(true)`, true)       // true: true
+	expect(t, `out = bool(false)`, false)     // false: false
+	expect(t, `out = bool('8')`, true)        // non-zero chars: true
+	expect(t, `out = bool(char(0))`, false)   // zero char: false
+	expect(t, `out = bool([1])`, true)        // non-empty arrays: true
+	expect(t, `out = bool([])`, false)        // empty array: false
+	expect(t, `out = bool({a: 1})`, true)     // non-empty maps: true
+	expect(t, `out = bool({})`, false)        // empty maps: false
+	expect(t, `out = bool(undefined)`, false) // undefined: false
 }