From 0e2320908333812c5dff2c478d64d48295915c70 Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Fri, 3 Nov 2023 17:51:34 +0900 Subject: [PATCH 1/9] Update octal conversion logic --- gnovm/pkg/gnolang/op_eval.go | 2 + gnovm/pkg/gnolang/op_eval_test.go | 75 +++++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+) create mode 100644 gnovm/pkg/gnolang/op_eval_test.go diff --git a/gnovm/pkg/gnolang/op_eval.go b/gnovm/pkg/gnolang/op_eval.go index 83dd3737b6b..b3e70553d1e 100644 --- a/gnovm/pkg/gnolang/op_eval.go +++ b/gnovm/pkg/gnolang/op_eval.go @@ -56,6 +56,8 @@ func (m *Machine) doOpEval() { _, ok = bi.SetString(x.Value[2:], 8) case 'x', 'X': _, ok = bi.SetString(x.Value[2:], 16) + case '0', '1', '2', '3', '4', '5', '6', '7': + _, ok = bi.SetString(x.Value, 8) default: ok = false } diff --git a/gnovm/pkg/gnolang/op_eval_test.go b/gnovm/pkg/gnolang/op_eval_test.go new file mode 100644 index 00000000000..cad18a38ea8 --- /dev/null +++ b/gnovm/pkg/gnolang/op_eval_test.go @@ -0,0 +1,75 @@ +package gnolang_test + +import ( + "fmt" + "math/big" + "testing" +) + +// parseIntegerLiteral function is a Mock-up of the doOpEval() function in `op_eval.go`. +func parseIntegerLiteral(value string) (*big.Int, error) { + if len(value) > 2 && value[0] == '0' { + bi := big.NewInt(0) + var ok bool + switch value[1] { + case 'b', 'B': + _, ok = bi.SetString(value[2:], 2) + case 'o', 'O': + _, ok = bi.SetString(value[2:], 8) + case 'x', 'X': + _, ok = bi.SetString(value[2:], 16) + case '0', '1', '2', '3', '4', '5', '6', '7': + _, ok = bi.SetString(value, 8) + default: + ok = false + } + if !ok { + return nil, fmt.Errorf("invalid integer constant: %s", value) + } + return bi, nil + } else { + bi, ok := new(big.Int).SetString(value, 10) + if !ok { + return nil, fmt.Errorf("invalid integer constant: %s", value) + } + return bi, nil + } +} + +type testCase struct { + input string + expected string + hasError bool +} + +func TestParseIntegerLiteral(t *testing.T) { + testCases := []testCase{ + {"012345", "5349", false}, + {"02001", "1025", false}, + {"002001", "1025", false}, + {"0002001", "1025", false}, + {"0o12345", "5349", false}, + {"0x1a2b", "6699", false}, + {"0xbeefcafe", "3203386110", false}, + {"0b1010", "10", false}, + {"12345", "12345", false}, + {"invalid", "", true}, + {"0o12345invalid", "", true}, + {"", "", true}, + } + + for _, tc := range testCases { + result, err := parseIntegerLiteral(tc.input) + if tc.hasError { + if err == nil { + t.Errorf("Expected error for input %s, but got none", tc.input) + } + } else { + if err != nil { + t.Errorf("Unexpected error for input %s: %v", tc.input, err) + } else if result.String() != tc.expected { + t.Errorf("For input %s, expected %s but got %s", tc.input, tc.expected, result.String()) + } + } + } +} From 5a041900e9d5f2b77845a5dfe285a105833fba44 Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Thu, 9 Nov 2023 16:42:29 +0900 Subject: [PATCH 2/9] allow base string length = 2 --- gnovm/pkg/gnolang/gno_test.go | 34 ++++++++++++++ gnovm/pkg/gnolang/op_eval.go | 4 +- gnovm/pkg/gnolang/op_eval_test.go | 75 ------------------------------- 3 files changed, 36 insertions(+), 77 deletions(-) delete mode 100644 gnovm/pkg/gnolang/op_eval_test.go diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 5ed5971c836..6f727479f1c 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -35,6 +35,40 @@ func main() { m.RunMain() } +func TestIntegerBaseConversion(t *testing.T) { + m := NewMachine("p", nil) + c := `package p +func main() { + vals := []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 42, 12345, + + 00, 01, 07, 007, 010, 012345, 02001, + 000, 001, 007, 0007, 0010, 0012345, 002001, + 0o1, 0o2, 0o3, 0o4, 0o5, 0o6, 0o7, + 0o10, 0o12, 0o12345, 0o2001, + 0O1, 0O2, 0O3, 0O4, 0O5, 0O6, 0O7, + 0O10, 0O12, 0O12345, 0O2001, + + 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, + 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, + 0xbeefcafe, 0Xbeefcafe, 0xBeEfCaFe, 0XBeEfCaFe, 0xbEeFcAfE, 0xC0FFEE, + + 0b0, 0b1, 0b10, 0b11, 0b100, 0b101, + 0b110, 0b111, 0b1000, 0b1001, 0b1010, + 0b1011, 0b1100, 0b1101, 0b1111, + 0B0, 0B1, 0B10, 0B11, 0B100, 0B101, + 0B110, 0B111, 0B1000, 0B1001, 0B1010, + } + + for _, v := range vals { + println(v) + } +}` + + n := MustParseFile("main.go", c) + m.RunFiles(n) +} + func TestEval(t *testing.T) { m := NewMachine("test", nil) c := `package test diff --git a/gnovm/pkg/gnolang/op_eval.go b/gnovm/pkg/gnolang/op_eval.go index b3e70553d1e..3eadbeabfc9 100644 --- a/gnovm/pkg/gnolang/op_eval.go +++ b/gnovm/pkg/gnolang/op_eval.go @@ -47,8 +47,8 @@ func (m *Machine) doOpEval() { bi := big.NewInt(0) // TODO optimize. // TODO deal with base. - if len(x.Value) > 2 && x.Value[0] == '0' { - var ok bool = false + var ok bool + if len(x.Value) >= 2 && x.Value[0] == '0' { switch x.Value[1] { case 'b', 'B': _, ok = bi.SetString(x.Value[2:], 2) diff --git a/gnovm/pkg/gnolang/op_eval_test.go b/gnovm/pkg/gnolang/op_eval_test.go deleted file mode 100644 index cad18a38ea8..00000000000 --- a/gnovm/pkg/gnolang/op_eval_test.go +++ /dev/null @@ -1,75 +0,0 @@ -package gnolang_test - -import ( - "fmt" - "math/big" - "testing" -) - -// parseIntegerLiteral function is a Mock-up of the doOpEval() function in `op_eval.go`. -func parseIntegerLiteral(value string) (*big.Int, error) { - if len(value) > 2 && value[0] == '0' { - bi := big.NewInt(0) - var ok bool - switch value[1] { - case 'b', 'B': - _, ok = bi.SetString(value[2:], 2) - case 'o', 'O': - _, ok = bi.SetString(value[2:], 8) - case 'x', 'X': - _, ok = bi.SetString(value[2:], 16) - case '0', '1', '2', '3', '4', '5', '6', '7': - _, ok = bi.SetString(value, 8) - default: - ok = false - } - if !ok { - return nil, fmt.Errorf("invalid integer constant: %s", value) - } - return bi, nil - } else { - bi, ok := new(big.Int).SetString(value, 10) - if !ok { - return nil, fmt.Errorf("invalid integer constant: %s", value) - } - return bi, nil - } -} - -type testCase struct { - input string - expected string - hasError bool -} - -func TestParseIntegerLiteral(t *testing.T) { - testCases := []testCase{ - {"012345", "5349", false}, - {"02001", "1025", false}, - {"002001", "1025", false}, - {"0002001", "1025", false}, - {"0o12345", "5349", false}, - {"0x1a2b", "6699", false}, - {"0xbeefcafe", "3203386110", false}, - {"0b1010", "10", false}, - {"12345", "12345", false}, - {"invalid", "", true}, - {"0o12345invalid", "", true}, - {"", "", true}, - } - - for _, tc := range testCases { - result, err := parseIntegerLiteral(tc.input) - if tc.hasError { - if err == nil { - t.Errorf("Expected error for input %s, but got none", tc.input) - } - } else { - if err != nil { - t.Errorf("Unexpected error for input %s: %v", tc.input, err) - } else if result.String() != tc.expected { - t.Errorf("For input %s, expected %s but got %s", tc.input, tc.expected, result.String()) - } - } - } -} From d83d471ef3c50948f62d54dafead92d2425fc32e Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Thu, 9 Nov 2023 16:43:50 +0900 Subject: [PATCH 3/9] add RunMain to test --- gnovm/pkg/gnolang/gno_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 6f727479f1c..12cb46952dd 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -67,6 +67,7 @@ func main() { n := MustParseFile("main.go", c) m.RunFiles(n) + m.RunMain() } func TestEval(t *testing.T) { From c05aae518a11ea928d0baaa1632a94430e91a1ee Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Fri, 10 Nov 2023 14:06:30 +0900 Subject: [PATCH 4/9] Update test to direct run `doOpEval` --- gnovm/pkg/gnolang/gno_test.go | 87 ++++++++++++++++++++++------------- 1 file changed, 56 insertions(+), 31 deletions(-) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 12cb46952dd..a0ec1076516 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -35,39 +35,64 @@ func main() { m.RunMain() } -func TestIntegerBaseConversion(t *testing.T) { - m := NewMachine("p", nil) - c := `package p -func main() { - vals := []int{ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 42, 12345, - - 00, 01, 07, 007, 010, 012345, 02001, - 000, 001, 007, 0007, 0010, 0012345, 002001, - 0o1, 0o2, 0o3, 0o4, 0o5, 0o6, 0o7, - 0o10, 0o12, 0o12345, 0o2001, - 0O1, 0O2, 0O3, 0O4, 0O5, 0O6, 0O7, - 0O10, 0O12, 0O12345, 0O2001, - - 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, - 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, - 0xbeefcafe, 0Xbeefcafe, 0xBeEfCaFe, 0XBeEfCaFe, 0xbEeFcAfE, 0xC0FFEE, - - 0b0, 0b1, 0b10, 0b11, 0b100, 0b101, - 0b110, 0b111, 0b1000, 0b1001, 0b1010, - 0b1011, 0b1100, 0b1101, 0b1111, - 0B0, 0B1, 0B10, 0B11, 0B100, 0B101, - 0B110, 0B111, 0B1000, 0B1001, 0B1010, - } +func TestDoOpEvalOctal(t *testing.T) { + m := NewMachine("test", nil) - for _, v := range vals { - println(v) - } -}` + m.PushExpr(&BasicLitExpr{ + Kind: INT, + Value: "0o42", + }) + m.doOpEval() + v1 := m.PopValue() + assert.Equal(t, v1.V.String(), "34") - n := MustParseFile("main.go", c) - m.RunFiles(n) - m.RunMain() + m.PushExpr(&BasicLitExpr{ + Kind: INT, + Value: "0O0000042", + }) + + m.doOpEval() + v2 := m.PopValue() + assert.Equal(t, v2.V.String(), "34") + + // Push a basic literal expression onto the stack. + m.PushExpr(&BasicLitExpr{ + Kind: INT, + Value: "042", + }) + m.doOpEval() + v3 := m.PopValue() + assert.Equal(t, v3.V.String(), "34") + + m.PushExpr((&BasicLitExpr{ + Kind: INT, + Value: "048", + })) + assert.Panics(t, func() { + m.doOpEval() + }, + "8 is not an octal digit", + ) + + m.PushExpr((&BasicLitExpr{ + Kind: INT, + Value: "0o", + })) + assert.Panics(t, func() { + m.doOpEval() + }, + "No digits after 0o", + ) + + m.PushExpr((&BasicLitExpr{ + Kind: INT, + Value: "0OXXXX", + })) + assert.Panics(t, func() { + m.doOpEval() + }, + "Non-octal digits(0-7) after 0o", + ) } func TestEval(t *testing.T) { From 04660e00f0315cfdb7d9de604e8f3ffb118f467f Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Mon, 13 Nov 2023 16:41:58 +0900 Subject: [PATCH 5/9] fmt --- gnovm/pkg/gnolang/gno_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index a0ec1076516..0aa9e99c4fa 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -39,7 +39,7 @@ func TestDoOpEvalOctal(t *testing.T) { m := NewMachine("test", nil) m.PushExpr(&BasicLitExpr{ - Kind: INT, + Kind: INT, Value: "0o42", }) m.doOpEval() @@ -47,7 +47,7 @@ func TestDoOpEvalOctal(t *testing.T) { assert.Equal(t, v1.V.String(), "34") m.PushExpr(&BasicLitExpr{ - Kind: INT, + Kind: INT, Value: "0O0000042", }) From d6d936f188689341db753476a1e09045acda9199 Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Fri, 1 Dec 2023 11:23:56 +0900 Subject: [PATCH 6/9] handle negative value and make table test --- gnovm/pkg/gnolang/gno_test.go | 131 ++++++++++++++++++------------- gnovm/pkg/gnolang/op_eval.go | 8 ++ gnovm/tests/files/base_conv0.gno | 27 +++++++ gnovm/tests/files/base_conv1.gno | 27 +++++++ 4 files changed, 139 insertions(+), 54 deletions(-) create mode 100644 gnovm/tests/files/base_conv0.gno create mode 100644 gnovm/tests/files/base_conv1.gno diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 23b297a0618..0fd7feb95e5 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -39,64 +39,87 @@ func main() { m.RunMain() } -func TestDoOpEvalOctal(t *testing.T) { +func TestBaseConversion(t *testing.T) { m := NewMachine("test", nil) - m.PushExpr(&BasicLitExpr{ - Kind: INT, - Value: "0o42", - }) - m.doOpEval() - v1 := m.PopValue() - assert.Equal(t, v1.V.String(), "34") - - m.PushExpr(&BasicLitExpr{ - Kind: INT, - Value: "0O0000042", - }) + // Test case struct + type testCase struct { + input string + expect string + expectErr bool + } - m.doOpEval() - v2 := m.PopValue() - assert.Equal(t, v2.V.String(), "34") + // Define test cases + testCases := []testCase{ + // binary + {input: "0b101010", expect: "42", expectErr: false}, + {input: "0B101010", expect: "42", expectErr: false}, + {input: "-0b1", expect: "-1", expectErr: false}, + {input: "0b111111111111111111111111111111111111111111111111111111111111111", expect: "9223372036854775807", expectErr: false}, + {input: "-0b1000000000000000000000000000000000000000000000000000000000000000", expect: "-9223372036854775808", expectErr: false}, + {input: "0b0", expect: "0", expectErr: false}, + {input: "-0b101010", expect: "-42", expectErr: false}, + {input: "-0B101010", expect: "-42", expectErr: false}, + {input: "0b000000101010", expect: "42", expectErr: false}, + {input: " 0b101010", expectErr: true}, + {input: "0b", expectErr: true}, + {input: "0bXXXX", expectErr: true}, + {input: "42b0", expectErr: true}, + // octal + {input: "0o42", expect: "34", expectErr: false}, + {input: "-0o42", expect: "-34", expectErr: false}, + {input: "-0o0", expect: "0", expectErr: false}, + {input: "0o0", expect: "0", expectErr: false}, + {input: "042", expect: "34", expectErr: false}, + {input: "-042", expect: "-34", expectErr: false}, + {input: "0777", expect: "511", expectErr: false}, + {input: "-0777", expect: "-511", expectErr: false}, + {input: "0O0000042", expect: "34", expectErr: false}, + {input: "-01", expect: "-1", expectErr: false}, + {input: "0777777777777777777777", expect: "9223372036854775807", expectErr: false}, + {input: "0o777777777777777777777", expect: "9223372036854775807", expectErr: false}, + {input: "-01000000000000000000000", expect: "-9223372036854775808", expectErr: false}, + {input: "048", expectErr: true}, + {input: "-048", expectErr: true}, + {input: "0o", expectErr: true}, + {input: "0oXXXX", expectErr: true}, + {input: "0OXXXX", expectErr: true}, + {input: "0x2a ", expectErr: true}, + // hex + {input: "-0x1", expect: "-1", expectErr: false}, + {input: "0x2a", expect: "42", expectErr: false}, + {input: "0X2A", expect: "42", expectErr: false}, + {input: "-0x2a", expect: "-42", expectErr: false}, + {input: "-0X2A", expect: "-42", expectErr: false}, + {input: "0x7FFFFFFFFFFFFFFF", expect: "9223372036854775807", expectErr: false}, + {input: "-0x8000000000000000", expect: "-9223372036854775808", expectErr: false}, + {input: "0x", expectErr: true}, + {input: "0xXXXX", expectErr: true}, + {input: "0xGHIJ", expectErr: true}, + // decimal + {input: "-1", expect: "-1", expectErr: false}, + {input: "42", expect: "42", expectErr: false}, + {input: "0", expect: "0", expectErr: false}, + {input: "0000000000", expect: "0", expectErr: false}, + {input: "9223372036854775807", expect: "9223372036854775807", expectErr: false}, + {input: "-9223372036854775808", expect: "-9223372036854775808", expectErr: false}, + } - // Push a basic literal expression onto the stack. - m.PushExpr(&BasicLitExpr{ - Kind: INT, - Value: "042", - }) - m.doOpEval() - v3 := m.PopValue() - assert.Equal(t, v3.V.String(), "34") - - m.PushExpr((&BasicLitExpr{ - Kind: INT, - Value: "048", - })) - assert.Panics(t, func() { - m.doOpEval() - }, - "8 is not an octal digit", - ) - - m.PushExpr((&BasicLitExpr{ - Kind: INT, - Value: "0o", - })) - assert.Panics(t, func() { - m.doOpEval() - }, - "No digits after 0o", - ) - - m.PushExpr((&BasicLitExpr{ - Kind: INT, - Value: "0OXXXX", - })) - assert.Panics(t, func() { - m.doOpEval() - }, - "Non-octal digits(0-7) after 0o", - ) + // Run test cases + for _, tc := range testCases { + m.PushExpr(&BasicLitExpr{ + Kind: INT, + Value: tc.input, + }) + + if tc.expectErr { + assert.Panics(t, func() { m.doOpEval() }) + } else { + m.doOpEval() + v := m.PopValue() + assert.Equal(t, v.V.String(), tc.expect) + } + } } func TestEval(t *testing.T) { diff --git a/gnovm/pkg/gnolang/op_eval.go b/gnovm/pkg/gnolang/op_eval.go index 3eadbeabfc9..19ed73db144 100644 --- a/gnovm/pkg/gnolang/op_eval.go +++ b/gnovm/pkg/gnolang/op_eval.go @@ -43,6 +43,11 @@ func (m *Machine) doOpEval() { switch x.Kind { case INT: x.Value = strings.ReplaceAll(x.Value, "_", "") + isNegative := false + if strings.HasPrefix(x.Value, "-") { + isNegative = true + x.Value = strings.TrimPrefix(x.Value, "-") + } // temporary optimization bi := big.NewInt(0) // TODO optimize. @@ -74,6 +79,9 @@ func (m *Machine) doOpEval() { x.Value)) } } + if isNegative { + bi.Neg(bi) + } m.PushValue(TypedValue{ T: UntypedBigintType, V: BigintValue{V: bi}, diff --git a/gnovm/tests/files/base_conv0.gno b/gnovm/tests/files/base_conv0.gno new file mode 100644 index 00000000000..381d10cdc98 --- /dev/null +++ b/gnovm/tests/files/base_conv0.gno @@ -0,0 +1,27 @@ +package main + +func main() { + // binary + println(0b1010) + println(0B1010) + + // decimal + println(10) + + // octal + println(0o12) + println(012) + + // hex + println(0xA) + println(0xa) +} + +// Output: +// 10 +// 10 +// 10 +// 10 +// 10 +// 10 +// 10 diff --git a/gnovm/tests/files/base_conv1.gno b/gnovm/tests/files/base_conv1.gno new file mode 100644 index 00000000000..6ccf8d0fe70 --- /dev/null +++ b/gnovm/tests/files/base_conv1.gno @@ -0,0 +1,27 @@ +package main + +func main() { + // binary + println(-0b1010) + println(-0B1010) + + // decimal + println(-10) + + // octal + println(-0o12) + println(-012) + + // hex + println(-0xA) + println(-0xa) +} + +// Output: +// -10 +// -10 +// -10 +// -10 +// -10 +// -10 +// -10 From 6e4293709443006f19ddee21d43c345205aefcbd Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Fri, 1 Dec 2023 11:27:43 +0900 Subject: [PATCH 7/9] typo --- gnovm/pkg/gnolang/gno_test.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 0fd7feb95e5..b4fc883c15a 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -42,14 +42,12 @@ func main() { func TestBaseConversion(t *testing.T) { m := NewMachine("test", nil) - // Test case struct type testCase struct { input string expect string expectErr bool } - // Define test cases testCases := []testCase{ // binary {input: "0b101010", expect: "42", expectErr: false}, @@ -105,7 +103,6 @@ func TestBaseConversion(t *testing.T) { {input: "-9223372036854775808", expect: "-9223372036854775808", expectErr: false}, } - // Run test cases for _, tc := range testCases { m.PushExpr(&BasicLitExpr{ Kind: INT, From 0a68538a1f4bdf940241275ba1ac02a82beeb32a Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Sun, 10 Dec 2023 19:08:08 +0900 Subject: [PATCH 8/9] remove unnecessary negative check --- gnovm/pkg/gnolang/gno_test.go | 19 +------------------ gnovm/pkg/gnolang/op_eval.go | 8 -------- 2 files changed, 1 insertion(+), 26 deletions(-) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index b4fc883c15a..46fb3713da1 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -39,7 +39,7 @@ func main() { m.RunMain() } -func TestBaseConversion(t *testing.T) { +func TestDoOpEvalBaseConversion(t *testing.T) { m := NewMachine("test", nil) type testCase struct { @@ -52,12 +52,8 @@ func TestBaseConversion(t *testing.T) { // binary {input: "0b101010", expect: "42", expectErr: false}, {input: "0B101010", expect: "42", expectErr: false}, - {input: "-0b1", expect: "-1", expectErr: false}, {input: "0b111111111111111111111111111111111111111111111111111111111111111", expect: "9223372036854775807", expectErr: false}, - {input: "-0b1000000000000000000000000000000000000000000000000000000000000000", expect: "-9223372036854775808", expectErr: false}, {input: "0b0", expect: "0", expectErr: false}, - {input: "-0b101010", expect: "-42", expectErr: false}, - {input: "-0B101010", expect: "-42", expectErr: false}, {input: "0b000000101010", expect: "42", expectErr: false}, {input: " 0b101010", expectErr: true}, {input: "0b", expectErr: true}, @@ -65,42 +61,29 @@ func TestBaseConversion(t *testing.T) { {input: "42b0", expectErr: true}, // octal {input: "0o42", expect: "34", expectErr: false}, - {input: "-0o42", expect: "-34", expectErr: false}, - {input: "-0o0", expect: "0", expectErr: false}, {input: "0o0", expect: "0", expectErr: false}, {input: "042", expect: "34", expectErr: false}, - {input: "-042", expect: "-34", expectErr: false}, {input: "0777", expect: "511", expectErr: false}, - {input: "-0777", expect: "-511", expectErr: false}, {input: "0O0000042", expect: "34", expectErr: false}, - {input: "-01", expect: "-1", expectErr: false}, {input: "0777777777777777777777", expect: "9223372036854775807", expectErr: false}, {input: "0o777777777777777777777", expect: "9223372036854775807", expectErr: false}, - {input: "-01000000000000000000000", expect: "-9223372036854775808", expectErr: false}, {input: "048", expectErr: true}, - {input: "-048", expectErr: true}, {input: "0o", expectErr: true}, {input: "0oXXXX", expectErr: true}, {input: "0OXXXX", expectErr: true}, {input: "0x2a ", expectErr: true}, // hex - {input: "-0x1", expect: "-1", expectErr: false}, {input: "0x2a", expect: "42", expectErr: false}, {input: "0X2A", expect: "42", expectErr: false}, - {input: "-0x2a", expect: "-42", expectErr: false}, - {input: "-0X2A", expect: "-42", expectErr: false}, {input: "0x7FFFFFFFFFFFFFFF", expect: "9223372036854775807", expectErr: false}, - {input: "-0x8000000000000000", expect: "-9223372036854775808", expectErr: false}, {input: "0x", expectErr: true}, {input: "0xXXXX", expectErr: true}, {input: "0xGHIJ", expectErr: true}, // decimal - {input: "-1", expect: "-1", expectErr: false}, {input: "42", expect: "42", expectErr: false}, {input: "0", expect: "0", expectErr: false}, {input: "0000000000", expect: "0", expectErr: false}, {input: "9223372036854775807", expect: "9223372036854775807", expectErr: false}, - {input: "-9223372036854775808", expect: "-9223372036854775808", expectErr: false}, } for _, tc := range testCases { diff --git a/gnovm/pkg/gnolang/op_eval.go b/gnovm/pkg/gnolang/op_eval.go index 19ed73db144..3eadbeabfc9 100644 --- a/gnovm/pkg/gnolang/op_eval.go +++ b/gnovm/pkg/gnolang/op_eval.go @@ -43,11 +43,6 @@ func (m *Machine) doOpEval() { switch x.Kind { case INT: x.Value = strings.ReplaceAll(x.Value, "_", "") - isNegative := false - if strings.HasPrefix(x.Value, "-") { - isNegative = true - x.Value = strings.TrimPrefix(x.Value, "-") - } // temporary optimization bi := big.NewInt(0) // TODO optimize. @@ -79,9 +74,6 @@ func (m *Machine) doOpEval() { x.Value)) } } - if isNegative { - bi.Neg(bi) - } m.PushValue(TypedValue{ T: UntypedBigintType, V: BigintValue{V: bi}, From 4cfe6fae2cc721446281549812309fad06ae398f Mon Sep 17 00:00:00 2001 From: Lee ByeongJun Date: Mon, 11 Dec 2023 11:32:33 +0900 Subject: [PATCH 9/9] update test --- gnovm/pkg/gnolang/gno_test.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/gnovm/pkg/gnolang/gno_test.go b/gnovm/pkg/gnolang/gno_test.go index 46fb3713da1..751534e1e16 100644 --- a/gnovm/pkg/gnolang/gno_test.go +++ b/gnovm/pkg/gnolang/gno_test.go @@ -71,14 +71,20 @@ func TestDoOpEvalBaseConversion(t *testing.T) { {input: "0o", expectErr: true}, {input: "0oXXXX", expectErr: true}, {input: "0OXXXX", expectErr: true}, - {input: "0x2a ", expectErr: true}, + {input: "0o42x42", expectErr: true}, + {input: "0O42x42", expectErr: true}, + {input: "0420x42", expectErr: true}, + {input: "0o420o42", expectErr: true}, // hex {input: "0x2a", expect: "42", expectErr: false}, {input: "0X2A", expect: "42", expectErr: false}, {input: "0x7FFFFFFFFFFFFFFF", expect: "9223372036854775807", expectErr: false}, + {input: "0x2a ", expectErr: true}, {input: "0x", expectErr: true}, {input: "0xXXXX", expectErr: true}, {input: "0xGHIJ", expectErr: true}, + {input: "0x42o42", expectErr: true}, + {input: "0x2ax42", expectErr: true}, // decimal {input: "42", expect: "42", expectErr: false}, {input: "0", expect: "0", expectErr: false},