Fix lexer in Fuzz test

api_test.go

@@ -42,3 +42,25 @@ func TestInvalidMustCompilePanics(t *testing.T) {
 	}()
 	MustCompile("not a valid expression")
 }
+
+func TestToEntries(t *testing.T) {
+	assert := assert.New(t)
+	data := make(map[string]interface{})
+	data["foo"] = "bar"
+	data["baz"] = 42
+	result, err := Search("to_entries(@)", data)
+	assert.Nil(err)
+
+	entries, ok := result.([]interface{})
+	assert.True(ok)
+	assert.Equal(2, len(entries))
+
+	for _, entry := range entries {
+		entryMap, ok := entry.(map[string]interface{})
+		assert.True(ok)
+		_, hasKey := entryMap["key"]
+		_, hasValue := entryMap["value"]
+		assert.True(hasKey)
+		assert.True(hasValue)
+	}
+}

compliance/functions.json

@@ -355,6 +355,18 @@
       "expression": "values(foo)",
       "error": "invalid-type"
     },
+    {
+      "expression": "to_entries(objects)",
+      "result": [{"key": "bar", "value": "baz"}, {"key": "foo", "value": "bar"}]
+    },
+    {
+      "expression": "to_entries(empty_hash)",
+      "result": []
+    },
+    {
+      "expression": "to_entries(foo)",
+      "error": "invalid-type"
+    },
     {
       "expression": "join(', ', strings)",
       "result": "a, b, c"

functions.go

@@ -259,6 +259,13 @@ func newFunctionCaller() *functionCaller {
 			},
 			handler: jpfValues,
 		},
+		"to_entries": {
+			name: "to_entries",
+			arguments: []argSpec{
+				{types: []jpType{jpObject}},
+			},
+			handler: jpfToEntries,
+		},
 		"sort": {
 			name: "sort",
 			arguments: []argSpec{
@@ -711,6 +718,24 @@ func jpfValues(arguments []interface{}) (interface{}, error) {
 	}
 	return collected, nil
 }
+func jpfToEntries(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0].(map[string]interface{})
+	keys := make([]string, 0, len(arg))
+	for key := range arg {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	collected := make([]interface{}, 0, len(arg))
+	for _, key := range keys {
+		entry := map[string]interface{}{
+			"key":   key,
+			"value": arg[key],
+		}
+		collected = append(collected, entry)
+	}
+	return collected, nil
+}
 func jpfSort(arguments []interface{}) (interface{}, error) {
 	if items, ok := toArrayNum(arguments[0]); ok {
 		d := sort.Float64Slice(items)

fuzz/jmespath_native_test.go

@@ -0,0 +1,14 @@
+package jmespath
+
+import (
+	"testing"
+
+	"github.com/jmespath/go-jmespath"
+)
+
+func FuzzParse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data string) {
+		p := jmespath.NewParser()
+		_, _ = p.Parse(data)
+	})
+}

go.mod

@@ -1,5 +1,11 @@
 module github.com/jmespath/go-jmespath
 
-go 1.14
+go 1.23
 
 require github.com/jmespath/go-jmespath/internal/testify v1.5.1
+
+require (
+	github.com/davecgh/go-spew v1.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v2 v2.2.8 // indirect
+)

lexer.go

@@ -149,7 +149,7 @@ func (lexer *Lexer) tokenize(expression string) ([]token, error) {
 loop:
 	for {
 		r := lexer.next()
-		if identifierStartBits&(1<<(uint64(r)-64)) > 0 {
+		if r >= 64 && r < 128 && identifierStartBits&(1<<(uint64(r)-64)) > 0 {
 			t := lexer.consumeUnquotedIdentifier()
 			tokens = append(tokens, t)
 		} else if val, ok := basicTokens[r]; ok {
@@ -386,7 +386,7 @@ func (lexer *Lexer) consumeUnquotedIdentifier() token {
 	start := lexer.currentPos - lexer.lastWidth
 	for {
 		r := lexer.next()
-		if r < 0 || r > 128 || identifierTrailingBits[uint64(r)/64]&(1<<(uint64(r)%64)) == 0 {
+		if r < 0 || r >= 128 || identifierTrailingBits[uint64(r)/64]&(1<<(uint64(r)%64)) == 0 {
 			lexer.back()
 			break
 		}