wader/fq
1
1
Fork 0
mirror of https://github.com/wader/fq.git synced 2024-08-16 15:30:36 +03:00
Code Issues Projects Releases Wiki Activity

fq: Use go 1.20 and cleanup

Browse Source 
Also rename *ex packages to *x
This commit is contained in:
Mattias Wadman 2024-04-01 18:39:45 +02:00
parent 48351028c5
commit bf7fa07c41
56 changed files with 245 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -240,7 +240,7 @@ apk add -X http://dl-cdn.alpinelinux.org/alpine/edge/testing fq
### Build from source
Make sure you have [go](https://go.dev) 1.18 or later installed.
Make sure you have [go](https://go.dev) 1.20 or later installed.
To install directly from git repository (no clone needed):
```sh

4
format/cbor/cbor.go
View File

@ -13,7 +13,7 @@ import (
"strings"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -117,7 +117,7 @@ func decodeCBORValue(d *decode.D) any {
}},
majorTypeNegativeInt: {s: scalar.Uint{Sym: "negative_int"}, d: func(d *decode.D, shortCount uint64, count uint64) any {
n := new(big.Int)
n.SetUint64(count).Neg(n).Sub(n, mathex.BigIntOne)
n.SetUint64(count).Neg(n).Sub(n, mathx.BigIntOne)
d.FieldValueBigInt("value", n)
return nil
}},

10
format/csv/csv.go
View File

@ -9,7 +9,7 @@ import (
"io"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -83,11 +83,11 @@ func toCSV(_ *interp.Interp, c []any, opts ToCSVOpts) any {
w.Comma = rune(opts.Comma[0])
}
for _, row := range c {
rs, ok := gojqex.Cast[[]any](row)
rs, ok := gojqx.Cast[[]any](row)
if !ok {
return fmt.Errorf("expected row to be an array, got %s", gojqex.TypeErrorPreview(row))
return fmt.Errorf("expected row to be an array, got %s", gojqx.TypeErrorPreview(row))
}
vs, ok := gojqex.NormalizeToStrings(rs).([]any)
vs, ok := gojqx.NormalizeToStrings(rs).([]any)
if !ok {
panic("not array")
}
@ -95,7 +95,7 @@ func toCSV(_ *interp.Interp, c []any, opts ToCSVOpts) any {
for _, v := range vs {
s, ok := v.(string)
if !ok {
return fmt.Errorf("expected row record to be scalars, got %s", gojqex.TypeErrorPreview(v))
return fmt.Errorf("expected row record to be scalars, got %s", gojqx.TypeErrorPreview(v))
}
ss = append(ss, s)
}

4
format/fit/fit.go
View File

@ -6,7 +6,7 @@ package fit
import (
"embed"
"fmt"
"sort"
"slices"
"github.com/wader/fq/format"
"github.com/wader/fq/format/fit/mappers"
@ -344,7 +344,7 @@ func fitDecodeDataMessage(d *decode.D, drc *dataRecordContext, lmfd localFieldDe
keys[i] = int(k)
i++
}
sort.Ints(keys)
slices.Sort(keys)
isDevDep := isDevMap[drc.localMessageType]

4
format/flac/flac.go
View File

@ -9,7 +9,7 @@ import (
"fmt"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -65,7 +65,7 @@ func flacDecode(d *decode.D) any {
samplesInFrame := ffo.Samples
if streamTotalSamples > 0 {
samplesInFrame = mathex.Min(streamTotalSamples-streamDecodedSamples, ffo.Samples)
samplesInFrame = mathx.Min(streamTotalSamples-streamDecodedSamples, ffo.Samples)
}
frameStreamSamplesBuf := ffo.SamplesBuf[0 : samplesInFrame*uint64(ffo.Channels*ffo.BitsPerSample/8)]
framesNDecodedSamples += ffo.Samples

4
format/flac/flac_frame.go
View File

@ -5,7 +5,7 @@ import (
"math/bits"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/checksum"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -478,7 +478,7 @@ func frameDecode(d *decode.D) any {
for j := 0; j < count; j++ {
high := d.Unary(0)
low := d.U(riceParameter)
samples[n] = mathex.ZigZag[uint64, int64](high<<riceParameter | low)
samples[n] = mathx.ZigZag[uint64, int64](high<<riceParameter | low)
n++
}
samplesStop := d.Pos()

4
format/icc/icc_profile.go
View File

@ -5,7 +5,7 @@ package icc
import (
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
)
@ -166,7 +166,7 @@ func iccProfileDecode(d *decode.D) any {
// was. instead add alignment after if offset+size does not align and to be sure clamp it if outside buffer.
alignStart := int64(offset) + int64(size)
alignBytes := (4 - (int64(offset)+int64(size))%4) % 4
alignBytes = mathex.Min(d.Len()/8-alignStart, alignBytes)
alignBytes = mathx.Min(d.Len()/8-alignStart, alignBytes)
if alignBytes != 0 {
d.RangeFn(alignStart*8, alignBytes*8, func(d *decode.D) {
d.FieldRawLen("alignment", d.BitsLeft())

4
format/inet/ipv6_packet.go
View File

@ -5,7 +5,7 @@ import (
"net"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
"github.com/wader/fq/pkg/scalar"
@ -105,7 +105,7 @@ var hopByHopTypeNames = scalar.UintMapSymStr{
var mapUToIPv6Sym = scalar.BitBufFn(func(s scalar.BitBuf) (scalar.BitBuf, error) {
b := &bytes.Buffer{}
if _, err := bitioex.CopyBits(b, s.Actual); err != nil {
if _, err := bitiox.CopyBits(b, s.Actual); err != nil {
return s, err
}
s.Sym = net.IP(b.Bytes()).String()

4
format/leveldb/leveldb_log_blocks.go
View File

@ -7,7 +7,7 @@ package leveldb
// - MANIFEST-*
import (
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/scalar"
)
@ -49,7 +49,7 @@ func readBlockSequence(rro recordReadOptions, d *decode.D) {
d.FieldArray("blocks", func(d *decode.D) {
for d.BitsLeft() >= headerSize {
d.LimitedFn(mathex.Min(blockSize, d.BitsLeft()), func(d *decode.D) {
d.LimitedFn(mathx.Min(blockSize, d.BitsLeft()), func(d *decode.D) {
d.FieldStruct("block", bind(readLogBlock, rro))
})
}

6
format/mp4/mp4.go
View File

@ -16,11 +16,11 @@ package mp4
// TODO: better probe, find first 2 boxes, should be free,ftyp or mdat?
import (
"cmp"
"embed"
"fmt"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/cmpex"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
"golang.org/x/exp/slices"
@ -240,10 +240,10 @@ func mp4Tracks(d *decode.D, ctx *decodeContext) {
// sort by id then order in file
slices.SortStableFunc(tracksCollected, func(a, b *trackCollected) int {
if r := cmpex.Compare(a.track.id, b.track.id); r != 0 {
if r := cmp.Compare(a.track.id, b.track.id); r != 0 {
return r
}
return cmpex.Compare(a.order, b.order)
return cmp.Compare(a.order, b.order)
})
d.FieldArray("tracks", func(d *decode.D) {

4
format/mpeg/avc_nalu.go
View File

@ -4,7 +4,7 @@ package mpeg
import (
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -50,7 +50,7 @@ func uEV(d *decode.D) uint64 { return expGolomb(d) }
func sEV(d *decode.D) int64 {
v := expGolomb(d) + 1
return mathex.ZigZag[uint64, int64](v) - -int64(v&1)
return mathx.ZigZag[uint64, int64](v) - -int64(v&1)
}
const (

6
format/protobuf/protobuf.go
View File

@ -6,7 +6,7 @@ import (
"embed"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
"github.com/wader/fq/pkg/scalar"
@ -70,7 +70,7 @@ func protobufDecodeField(d *decode.D, pbm *format.ProtoBufMessage) {
switch pbf.Type {
case format.ProtoBufTypeInt32, format.ProtoBufTypeInt64:
v := mathex.ZigZag[uint64, int64](value)
v := mathx.ZigZag[uint64, int64](value)
d.FieldValueSint("value", v)
if len(pbf.Enums) > 0 {
d.FieldValueStr("enum", pbf.Enums[uint64(v)])
@ -82,7 +82,7 @@ func protobufDecodeField(d *decode.D, pbm *format.ProtoBufMessage) {
}
case format.ProtoBufTypeSInt32, format.ProtoBufTypeSInt64:
// TODO: correct? 32 different?
v := mathex.TwosComplement(64, value)
v := mathx.TwosComplement(64, value)
d.FieldValueSint("value", v)
if len(pbf.Enums) > 0 {
d.FieldValueStr("enum", pbf.Enums[uint64(v)])

20
format/text/url.go
View File

@ -3,7 +3,7 @@ package text
import (
"net/url"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/interp"
)
@ -56,15 +56,15 @@ func init() {
toURLValues := func(c map[string]any) url.Values {
qv := url.Values{}
for k, v := range c {
if va, ok := gojqex.Cast[[]any](v); ok {
if va, ok := gojqx.Cast[[]any](v); ok {
var ss []string
for _, s := range va {
if s, ok := gojqex.Cast[string](s); ok {
if s, ok := gojqx.Cast[string](s); ok {
ss = append(ss, s)
}
}
qv[k] = ss
} else if vs, ok := gojqex.Cast[string](v); ok {
} else if vs, ok := gojqx.Cast[string](v); ok {
qv[k] = []string{vs}
}
}
@ -72,7 +72,7 @@ func init() {
}
interp.RegisterFunc0("to_urlquery", func(_ *interp.Interp, c map[string]any) any {
// TODO: nicer
c, ok := gojqex.NormalizeToStrings(c).(map[string]any)
c, ok := gojqx.NormalizeToStrings(c).(map[string]any)
if !ok {
panic("not map")
}
@ -118,12 +118,12 @@ func init() {
})
interp.RegisterFunc0("to_url", func(_ *interp.Interp, c map[string]any) any {
// TODO: nicer
c, ok := gojqex.NormalizeToStrings(c).(map[string]any)
c, ok := gojqx.NormalizeToStrings(c).(map[string]any)
if !ok {
panic("not map")
}
str := func(v any) string { s, _ := gojqex.Cast[string](v); return s }
str := func(v any) string { s, _ := gojqx.Cast[string](v); return s }
u := url.URL{
Scheme: str(c["scheme"]),
Host: str(c["host"]),
@ -131,7 +131,7 @@ func init() {
Fragment: str(c["fragment"]),
}
if um, ok := gojqex.Cast[map[string]any](c["user"]); ok {
if um, ok := gojqx.Cast[map[string]any](c["user"]); ok {
username, password := str(um["username"]), str(um["password"])
if username != "" {
if password == "" {
@ -141,10 +141,10 @@ func init() {
}
}
}
if s, ok := gojqex.Cast[string](c["rawquery"]); ok {
if s, ok := gojqx.Cast[string](c["rawquery"]); ok {
u.RawQuery = s
}
if qm, ok := gojqex.Cast[map[string]any](c["query"]); ok {
if qm, ok := gojqx.Cast[map[string]any](c["query"]); ok {
u.RawQuery = toURLValues(qm).Encode()
}

8
format/toml/toml.go
View File

@ -10,7 +10,7 @@ import (
"github.com/BurntSushi/toml"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -69,7 +69,7 @@ func decodeTOML(d *decode.D) any {
d.Fatalf("%s", err)
}
var s scalar.Any
s.Actual = gojqex.Normalize(r)
s.Actual = gojqx.Normalize(r)
// TODO: better way to handle that an empty file is valid toml and parsed as an object
switch v := s.Actual.(type) {
@ -90,11 +90,11 @@ func decodeTOML(d *decode.D) any {
func toTOML(_ *interp.Interp, c any) any {
if c == nil {
return gojqex.FuncTypeError{Name: "to_toml", V: c}
return gojqx.FuncTypeError{Name: "to_toml", V: c}
}
b := &bytes.Buffer{}
if err := toml.NewEncoder(b).Encode(gojqex.Normalize(c)); err != nil {
if err := toml.NewEncoder(b).Encode(gojqx.Normalize(c)); err != nil {
return err
}
return b.String()

26
format/xml/xml.go
View File

@ -21,9 +21,9 @@ import (
"unicode/utf8"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/sortex"
"github.com/wader/fq/internal/stringsex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/internal/sortx"
"github.com/wader/fq/internal/stringsx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -330,7 +330,7 @@ func decodeXML(d *decode.D) any {
switch t := t.(type) {
case xml.CharData:
if !whitespaceRE.Match([]byte(t)) {
d.Fatalf("root element has trailing non-whitespace %q", stringsex.TrimN(string(t), 50, "..."))
d.Fatalf("root element has trailing non-whitespace %q", stringsx.TrimN(string(t), 50, "..."))
}
// ignore trailing whitespace
case xml.ProcInst:
@ -433,9 +433,9 @@ func toXMLFromObject(c any, opts ToXMLOpts) any {
// if one #seq was found, assume all have them, otherwise sort by name
if orderHasSeq {
sortex.ProxySort(orderSeqs, n.Nodes, func(a, b int) bool { return a < b })
sortx.ProxySort(orderSeqs, n.Nodes, func(a, b int) bool { return a < b })
} else {
sortex.ProxySort(orderNames, n.Nodes, func(a, b string) bool { return a < b })
sortx.ProxySort(orderNames, n.Nodes, func(a, b string) bool { return a < b })
}
slices.SortFunc(n.Attrs, func(a, b xml.Attr) int { return xmlNameSort(a.Name, b.Name) })
@ -528,12 +528,12 @@ func toXMLFromArray(c any, opts ToXMLOpts) any {
ca, ok := c.([]any)
if !ok {
return gojqex.FuncTypeError{Name: "to_xml", V: c}
return gojqx.FuncTypeError{Name: "to_xml", V: c}
}
n, ok := f(ca)
if !ok {
// TODO: better error
return gojqex.FuncTypeError{Name: "to_xml", V: c}
return gojqx.FuncTypeError{Name: "to_xml", V: c}
}
bb := &bytes.Buffer{}
e := xml.NewEncoder(bb)
@ -549,10 +549,10 @@ func toXMLFromArray(c any, opts ToXMLOpts) any {
}
func toXML(_ *interp.Interp, c any, opts ToXMLOpts) any {
if v, ok := gojqex.Cast[map[string]any](c); ok {
return toXMLFromObject(gojqex.NormalizeToStrings(v), opts)
} else if v, ok := gojqex.Cast[[]any](c); ok {
return toXMLFromArray(gojqex.NormalizeToStrings(v), opts)
if v, ok := gojqx.Cast[map[string]any](c); ok {
return toXMLFromObject(gojqx.NormalizeToStrings(v), opts)
} else if v, ok := gojqx.Cast[[]any](c); ok {
return toXMLFromArray(gojqx.NormalizeToStrings(v), opts)
}
return gojqex.FuncTypeError{Name: "to_xml", V: c}
return gojqx.FuncTypeError{Name: "to_xml", V: c}
}

6
format/yaml/yaml.go
View File

@ -8,7 +8,7 @@ import (
"io"
"github.com/wader/fq/format"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/interp"
@ -46,7 +46,7 @@ func decodeYAML(d *decode.D) any {
}
var s scalar.Any
s.Actual = gojqex.Normalize(r)
s.Actual = gojqx.Normalize(r)
switch s.Actual.(type) {
case map[string]any,
@ -62,7 +62,7 @@ func decodeYAML(d *decode.D) any {
}
func toYAML(_ *interp.Interp, c any) any {
b, err := yaml.Marshal(gojqex.Normalize(c))
b, err := yaml.Marshal(gojqx.Normalize(c))
if err != nil {
return err
}

2
go.mod
View File

@ -1,6 +1,6 @@
module github.com/wader/fq
go 1.18
go 1.20
// fork of github.com/itchyny/gojq, see github.com/wader/gojq fq branch
require github.com/wader/gojq v0.12.1-0.20240401131232-6c6bc364201a

2
internal/bitioex/bitioextra.go → internal/bitiox/bitiox.go
View File

@ -1,4 +1,4 @@
package bitioex
package bitiox
// bitio helpers that im not sure belong in bitio

2
internal/bitioex/zeroreadatseeker.go → internal/bitiox/zeroreadatseeker.go
View File

@ -1,4 +1,4 @@
package bitioex
package bitiox
import (
"io"

59
internal/cmpex/cmpex.go
View File

@ -1,59 +0,0 @@
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package cmp provides types and functions related to comparing
// ordered values.
package cmpex
// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
//
// Note that floating-point types may contain NaN ("not-a-number") values.
// An operator such as == or < will always report false when
// comparing a NaN value with any other value, NaN or not.
// See the [Compare] function for a consistent way to compare NaN values.
type Ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 |
~string
}
// Less reports whether x is less than y.
// For floating-point types, a NaN is considered less than any non-NaN,
// and -0.0 is not less than (is equal to) 0.0.
func Less[T Ordered](x, y T) bool {
return (isNaN(x) && !isNaN(y)) || x < y
}
// Compare returns
//
// -1 if x is less than y,
// 0 if x equals y,
// +1 if x is greater than y.
//
// For floating-point types, a NaN is considered less than any non-NaN,
// a NaN is considered equal to a NaN, and -0.0 is equal to 0.0.
func Compare[T Ordered](x, y T) int {
xNaN := isNaN(x)
yNaN := isNaN(y)
if xNaN && yNaN {
return 0
}
if xNaN || x < y {
return -1
}
if yNaN || x > y {
return +1
}
return 0
}
// isNaN reports whether x is a NaN without requiring the math package.
// This will always return false if T is not floating-point.
func isNaN[T Ordered](x T) bool {
return x != x
}

7
internal/colorjson/encoder.go
View File

@ -25,11 +25,12 @@ package colorjson
import (
"bytes"
"cmp"
"fmt"
"io"
"math"
"math/big"
"sort"
"slices"
"strconv"
"unicode/utf8"
)
@ -255,8 +256,8 @@ func (e *Encoder) encodeMap(vs map[string]any) error {
kvs[i] = keyVal{k, v}
i++
}
sort.Slice(kvs, func(i, j int) bool {
return kvs[i].key < kvs[j].key
slices.SortFunc(kvs, func(a, b keyVal) int {
return cmp.Compare(a.key, b.key)
})
for i, kv := range kvs {
if i > 0 {

2
internal/gojqex/error.go → internal/gojqx/error.go
View File

@ -1,4 +1,4 @@
package gojqex
package gojqx
import (
"fmt"

2
internal/gojqex/makefn.go → internal/gojqx/makefn.go
View File

@ -1,4 +1,4 @@
package gojqex
package gojqx
//go:generate sh -c "cat makefn_gen.go.tmpl | go run ../../dev/tmpl.go | gofmt > makefn_gen.go"

2
internal/gojqex/makefn_gen.go → internal/gojqx/makefn_gen.go
View File

@ -1,5 +1,5 @@
// Generated from makefn_gen.go.tmpl
package gojqex
package gojqx
import (
"github.com/wader/fq/internal/mapstruct"

2
internal/gojqex/makefn_gen.go.tmpl → internal/gojqx/makefn_gen.go.tmpl
View File

@ -1,5 +1,5 @@
// Generated from makefn_gen.go.tmpl
package gojqex
package gojqx
import (
"github.com/wader/fq/internal/mapstruct"

2
internal/gojqex/regexp.go → internal/gojqx/regexp.go
View File

@ -1,4 +1,4 @@
package gojqex
package gojqx
import (
"fmt"

2
internal/gojqex/totype.go → internal/gojqx/totype.go
View File

@ -3,7 +3,7 @@
// The MIT License (MIT)
// Copyright (c) 2019-2021 itchyny
package gojqex
package gojqx
import (
"fmt"

2
internal/gojqex/types.go → internal/gojqx/types.go
View File

@ -1,5 +1,5 @@
//nolint:gosimple
package gojqex
package gojqx
import (
"bytes"

8
internal/hexdump/hexdump.go
View File

@ -5,7 +5,7 @@ import (
"strings"
"github.com/wader/fq/internal/columnwriter"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
)
@ -69,7 +69,7 @@ func New(w io.Writer, startOffset int64, addrLen int, addrBase int, lineBytes in
func (d *Dumper) flush() error {
if _, err := d.columnW.Columns[0].Write([]byte(
d.dumpAddrFn(mathex.PadFormatInt(((d.offset-1)/d.lineBytes)*d.lineBytes, d.addrBase, true, d.addrLen)))); err != nil {
d.dumpAddrFn(mathx.PadFormatInt(((d.offset-1)/d.lineBytes)*d.lineBytes, d.addrBase, true, d.addrLen)))); err != nil {
return err
}
if _, err := d.separatorsW.Write([]byte(d.column)); err != nil {
@ -85,7 +85,7 @@ func (d *Dumper) WriteBits(p []byte, nBits int64) (n int64, err error) {
pos := int64(0)
rBits := nBits
if d.bitsBufN > 0 {
r := mathex.Min(8-d.bitsBufN, nBits)
r := mathx.Min(8-d.bitsBufN, nBits)
v := bitio.Read64(p, 0, r)
bitio.Write64(v, r, d.bitsBuf, d.bitsBufN)
@ -131,7 +131,7 @@ func (d *Dumper) Write(p []byte) (n int, err error) {
}
for i := int64(0); i < d.lineBytes; i++ {
headerSB := &strings.Builder{}
if _, err := headerSB.Write([]byte(mathex.PadFormatInt(i, d.addrBase, false, 2))); err != nil {
if _, err := headerSB.Write([]byte(mathx.PadFormatInt(i, d.addrBase, false, 2))); err != nil {
return 0, err
}
if i < d.lineBytes-1 {

2
internal/ioex/ioex.go → internal/iox/iox.go
View File

@ -1,4 +1,4 @@
package ioex
package iox
import (
"context"

2
internal/ioex/runereader.go → internal/iox/runereader.go
View File

@ -1,4 +1,4 @@
package ioex
package iox
import (
"io"

2
internal/mathex/big.go → internal/mathx/big.go
View File

@ -1,4 +1,4 @@
package mathex
package mathx
import "math/big"

6
internal/mathex/big_test.go → internal/mathx/big_test.go
View File

@ -1,11 +1,11 @@
package mathex_test
package mathx_test
import (
"fmt"
"math/big"
"testing"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
)
func TestBigIntSetBytesSigned(t *testing.T) {
@ -28,7 +28,7 @@ func TestBigIntSetBytesSigned(t *testing.T) {
t.Run(fmt.Sprintf("%v %s", tC.buf, tC.s), func(t *testing.T) {
var n big.Int
expected := tC.s
actual := mathex.BigIntSetBytesSigned(&n, tC.buf).String()
actual := mathx.BigIntSetBytesSigned(&n, tC.buf).String()
if expected != actual {
t.Errorf("expected %s, got %s", expected, actual)
}

2
internal/mathex/float16.go → internal/mathx/float16.go
View File

@ -11,7 +11,7 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package mathex
package mathx
import "unsafe"

2
internal/mathex/float80.go → internal/mathx/float80.go
View File

@ -2,7 +2,7 @@
// modified a bit to read bytes instead of hex string
//
// Was previously under unlicense/public domain but is under MIT license for fq
package mathex
package mathx
import (
"fmt"

2
internal/mathex/num.go → internal/mathx/num.go
View File

@ -1,4 +1,4 @@
package mathex
package mathx
import (
"fmt"

4
internal/script/script.go
View File

@ -2,6 +2,7 @@ package script
import (
"bytes"
"cmp"
"encoding/hex"
"errors"
"fmt"
@ -13,7 +14,6 @@ import (
"strconv"
"strings"
"github.com/wader/fq/internal/cmpex"
"github.com/wader/fq/internal/shquote"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/interp"
@ -275,7 +275,7 @@ type Case struct {
func (c *Case) ToActual() string {
var partsLineSorted []part
partsLineSorted = append(partsLineSorted, c.Parts...)
slices.SortFunc(partsLineSorted, func(a, b part) int { return cmpex.Compare(a.Line(), b.Line()) })
slices.SortFunc(partsLineSorted, func(a, b part) int { return cmp.Compare(a.Line(), b.Line()) })
sb := &strings.Builder{}
for _, p := range partsLineSorted {

2
internal/sortex/proxysort.go → internal/sortx/proxysort.go
View File

@ -1,4 +1,4 @@
package sortex
package sortx
import "sort"

6
internal/stringsex/stringsextra.go → internal/stringsx/stringsx.go
View File

@ -1,11 +1,11 @@
package stringsex
package stringsx
import "github.com/wader/fq/internal/mathex"
import "github.com/wader/fq/internal/mathx"
func TrimN(s string, n int, suffix string) string {
sl, tl := len(s), len(suffix)
if sl+tl <= n {
return s
}
return s[0:mathex.Max(n-tl, 0)] + suffix
return s[0:mathx.Max(n-tl, 0)] + suffix
}

4
pkg/cli/cli.go
View File

@ -13,7 +13,7 @@ import (
"path/filepath"
"runtime"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/interp"
"golang.org/x/term"
@ -92,7 +92,7 @@ type fdTerminal uintptr
func (fd fdTerminal) Size() (int, int) {
w, h, _ := term.GetSize(int(fd))
// TODO: old version return 0 on no terminal
w, h = mathex.Max(0, w), mathex.Max(0, h)
w, h = mathx.Max(0, w), mathx.Max(0, h)
return w, h
}
func (fd fdTerminal) IsTerminal() bool {

24
pkg/decode/decode.go
View File

@ -9,8 +9,8 @@ import (
"reflect"
"regexp"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/ioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/internal/iox"
"github.com/wader/fq/internal/recoverfn"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/ranges"
@ -46,7 +46,7 @@ func Decode(ctx context.Context, br bitio.ReaderAtSeeker, group *Group, opts Opt
}
func decode(ctx context.Context, br bitio.ReaderAtSeeker, group *Group, opts Options) (*Value, any, error) {
brLen, err := bitioex.Len(br)
brLen, err := bitiox.Len(br)
if err != nil {
return nil, nil, err
}
@ -99,7 +99,7 @@ func decode(ctx context.Context, br bitio.ReaderAtSeeker, group *Group, opts Opt
inArgs = append(inArgs, groupArg)
}
cBR, err := bitioex.Range(br, decodeRange.Start, decodeRange.Len)
cBR, err := bitiox.Range(br, decodeRange.Start, decodeRange.Len)
if err != nil {
return nil, nil, IOError{Err: err, Op: "BitBufRange", ReadSize: decodeRange.Len, Pos: decodeRange.Start}
}
@ -257,7 +257,7 @@ func (d *D) fieldDecoder(name string, bitBuf bitio.ReaderAtSeeker, v any) *D {
func (d *D) TryCopyBits(w io.Writer, r bitio.Reader) (int64, error) {
// TODO: what size? now same as io.Copy
buf := d.SharedReadBuf(32 * 1024)
return bitioex.CopyBitsBuffer(w, r, buf)
return bitiox.CopyBitsBuffer(w, r, buf)
}
func (d *D) CopyBits(w io.Writer, r bitio.Reader) int64 {
@ -299,7 +299,7 @@ func (d *D) NewBitBufFromReader(r io.Reader) bitio.ReaderAtSeeker {
func (d *D) TryReadAllBits(r bitio.Reader) ([]byte, error) {
bb := &bytes.Buffer{}
buf := d.SharedReadBuf(32 * 1024)
if _, err := bitioex.CopyBitsBuffer(bb, r, buf); err != nil {
if _, err := bitiox.CopyBitsBuffer(bb, r, buf); err != nil {
return nil, err
}
return bb.Bytes(), nil
@ -348,7 +348,7 @@ func (d *D) FillGaps(r ranges.Range, namePrefix string) {
gaps := ranges.Gaps(r, valueRanges)
for i, gap := range gaps {
br, err := bitioex.Range(d.bitBuf, gap.Start, gap.Len)
br, err := bitiox.Range(d.bitBuf, gap.Start, gap.Len)
if err != nil {
d.IOPanic(err, "FillGaps: Range")
}
@ -590,11 +590,11 @@ func (d *D) BytesLen(nBytes int) []byte {
// TODO: rename/remove BitBuf name?
func (d *D) TryBitBufRange(firstBit int64, nBits int64) (bitio.ReaderAtSeeker, error) {
return bitioex.Range(d.bitBuf, firstBit, nBits)
return bitiox.Range(d.bitBuf, firstBit, nBits)
}
func (d *D) BitBufRange(firstBit int64, nBits int64) bitio.ReaderAtSeeker {
br, err := bitioex.Range(d.bitBuf, firstBit, nBits)
br, err := bitiox.Range(d.bitBuf, firstBit, nBits)
if err != nil {
panic(IOError{Err: err, Op: "BitBufRange", ReadSize: nBits, Pos: firstBit})
}
@ -614,7 +614,7 @@ func (d *D) Pos() int64 {
}
func (d *D) TryLen() (int64, error) {
return bitioex.Len(d.bitBuf)
return bitiox.Len(d.bitBuf)
}
func (d *D) Len() int64 {
@ -1139,7 +1139,7 @@ func (d *D) FieldFormatBitBuf(name string, br bitio.ReaderAtSeeker, group *Group
// TODO: rethink these
func (d *D) FieldRootBitBuf(name string, br bitio.ReaderAtSeeker, sms ...scalar.BitBufMapper) *Value {
brLen, err := bitioex.Len(br)
brLen, err := bitiox.Len(br)
if err != nil {
d.IOPanic(err, "br Len")
}
@ -1276,7 +1276,7 @@ func (d *D) FieldValue(name string, fn func() *Value) *Value {
func (d *D) RE(re *regexp.Regexp) []ranges.Range {
startPos := d.Pos()
rr := ioex.ByteRuneReader{RS: bitio.NewIOReadSeeker(d.bitBuf)}
rr := iox.ByteRuneReader{RS: bitio.NewIOReadSeeker(d.bitBuf)}
locs := re.FindReaderSubmatchIndex(rr)
if locs == nil {
return nil

6
pkg/decode/errors.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"strings"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/internal/recoverfn"
)
@ -72,7 +72,7 @@ func (e IOError) Error() string {
}
return fmt.Sprintf("%s: failed at position %s (read size %s seek pos %s): %s",
prefix, mathex.Bits(e.Pos).StringByteBits(10), mathex.Bits(e.ReadSize).StringByteBits(10), mathex.Bits(e.SeekPos).StringByteBits(10), e.Err)
prefix, mathx.Bits(e.Pos).StringByteBits(10), mathx.Bits(e.ReadSize).StringByteBits(10), mathx.Bits(e.SeekPos).StringByteBits(10), e.Err)
}
func (e IOError) Unwrap() error { return e.Err }
@ -84,7 +84,7 @@ type DecoderError struct {
}
func (e DecoderError) Error() string {
return fmt.Sprintf("error at position %s: %s", mathex.Bits(e.Pos).StringByteBits(16), e.Reason)
return fmt.Sprintf("error at position %s: %s", mathx.Bits(e.Pos).StringByteBits(16), e.Reason)
}
func (DecoderError) IsRecoverableError() bool { return true }

10
pkg/decode/read.go
View File

@ -7,7 +7,7 @@ import (
"math"
"math/big"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
"golang.org/x/text/encoding"
"golang.org/x/text/encoding/unicode"
@ -76,7 +76,7 @@ func (d *D) tryBigIntEndianSign(nBits int, endian Endian, sign bool) (*big.Int,
n := new(big.Int)
if sign {
mathex.BigIntSetBytesSigned(n, buf)
mathx.BigIntSetBytesSigned(n, buf)
} else {
n.SetBytes(buf)
}
@ -98,13 +98,13 @@ func (d *D) tryFEndian(nBits int, endian Endian) (float64, error) {
}
switch nBits {
case 16:
return float64(mathex.Float16(binary.BigEndian.Uint16(b)).Float32()), nil
return float64(mathx.Float16(binary.BigEndian.Uint16(b)).Float32()), nil
case 32:
return float64(math.Float32frombits(binary.BigEndian.Uint32(b))), nil
case 64:
return math.Float64frombits(binary.BigEndian.Uint64(b)), nil
case 80:
return mathex.NewFloat80FromBytes(b).Float64(), nil
return mathx.NewFloat80FromBytes(b).Float64(), nil
default:
return 0, fmt.Errorf("unsupported float size %d", nBits)
}
@ -169,7 +169,7 @@ func (d *D) tryTextLenPrefixed(prefixLenBytes int, fixedBytes int, e encoding.En
if fixedBytes != -1 {
// TODO: error?
readBytes = fixedBytes - prefixLenBytes
lenBytes = mathex.Min(lenBytes, uint64(readBytes))
lenBytes = mathx.Min(lenBytes, uint64(readBytes))
}
bs, err := d.TryBytesLen(readBytes)

6
pkg/decode/scalar.go
View File

@ -5,7 +5,7 @@ import (
"encoding/binary"
"errors"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/scalar"
)
@ -17,7 +17,7 @@ func bitBufIsZero(s scalar.BitBuf, isValidate bool) (scalar.BitBuf, error) {
// TODO: shared
b := make([]byte, 32*1024)
bLen := int64(len(b)) * 8
brLen, err := bitioex.Len(br)
brLen, err := bitiox.Len(br)
if err != nil {
return scalar.BitBuf{}, err
}
@ -77,7 +77,7 @@ func (d *D) BitBufValidateIsZero() scalar.BitBufMapper {
// TODO: generate?
func assertBitBuf(s scalar.BitBuf, isErr bool, bss ...[]byte) (scalar.BitBuf, error) {
bb := &bytes.Buffer{}
if _, err := bitioex.CopyBits(bb, s.Actual); err != nil {
if _, err := bitiox.CopyBits(bb, s.Actual); err != nil {
return s, err
}
for _, bs := range bss {

4
pkg/decode/value.go
View File

@ -1,10 +1,10 @@
package decode
import (
"cmp"
"errors"
"fmt"
"github.com/wader/fq/internal/cmpex"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/ranges"
"github.com/wader/fq/pkg/scalar"
@ -205,7 +205,7 @@ func (v *Value) postProcess() {
// sort struct fields and make sure to keep order if range is the same
if !vv.IsArray {
slices.SortStableFunc(vv.Children, func(a, b *Value) int {
return cmpex.Compare(a.Range.Start, b.Range.Start)
return cmp.Compare(a.Range.Start, b.Range.Start)
})
}

30
pkg/interp/binary.go
View File

@ -9,10 +9,10 @@ import (
"math/big"
"github.com/wader/fq/internal/aheadreadseeker"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/internal/ctxreadseeker"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/ioex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/internal/iox"
"github.com/wader/fq/internal/progressreadseeker"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/ranges"
@ -59,7 +59,7 @@ func toBitReaderEx(v any, inArray bool) (bitio.ReaderAtSeeker, error) {
if err != nil {
return nil, err
}
return bitioex.Range(bv.br, bv.r.Start, bv.r.Len)
return bitiox.Range(bv.br, bv.r.Start, bv.r.Len)
case string:
return bitio.NewBitReader([]byte(vv), -1), nil
case int, float64, *big.Int:
@ -86,7 +86,7 @@ func toBitReaderEx(v any, inArray bool) (bitio.ReaderAtSeeker, error) {
// TODO: how should this work? "0xf | tobytes" 4bits or 8bits? now 4
padBefore := (8 - (bitLen % 8)) % 8
// padBefore := 0
br, err := bitioex.Range(bitio.NewBitReader(bi.Bytes(), -1), padBefore, bitLen)
br, err := bitiox.Range(bitio.NewBitReader(bi.Bytes(), -1), padBefore, bitLen)
if err != nil {
return nil, err
}
@ -258,7 +258,7 @@ func (i *Interp) _open(c any) any {
}
if fRS == nil {
buf, err := io.ReadAll(ctxreadseeker.New(i.EvalInstance.Ctx, &ioex.ReadErrSeeker{Reader: f}))
buf, err := io.ReadAll(ctxreadseeker.New(i.EvalInstance.Ctx, &iox.ReadErrSeeker{Reader: f}))
if err != nil {
f.Close()
return err
@ -302,7 +302,7 @@ type Binary struct {
}
func NewBinaryFromBitReader(br bitio.ReaderAtSeeker, unit int, pad int64) (Binary, error) {
l, err := bitioex.Len(br)
l, err := bitiox.Len(br)
if err != nil {
return Binary{}, err
}
@ -316,12 +316,12 @@ func NewBinaryFromBitReader(br bitio.ReaderAtSeeker, unit int, pad int64) (Binar
}
func (b Binary) toBytesBuffer(r ranges.Range) (*bytes.Buffer, error) {
br, err := bitioex.Range(b.br, r.Start, r.Len)
br, err := bitiox.Range(b.br, r.Start, r.Len)
if err != nil {
return nil, err
}
buf := &bytes.Buffer{}
if _, err := bitioex.CopyBits(buf, br); err != nil {
if _, err := bitiox.CopyBits(buf, br); err != nil {
return nil, err
}
@ -391,7 +391,7 @@ func (b Binary) JQValueKey(name string) any {
return Binary{br: b.br, r: b.r, unit: 8}
case "name":
f := ioex.Unwrap(b.br)
f := iox.Unwrap(b.br)
// this exploits the fact that *os.File has Name()
if n, ok := f.(interface{ Name() string }); ok {
return n.Name()
@ -420,10 +420,10 @@ func (b Binary) JQValueType() string {
return gojq.JQTypeString
}
func (b Binary) JQValueKeys() any {
return gojqex.FuncTypeNameError{Name: "keys", Typ: gojq.JQTypeString}
return gojqx.FuncTypeNameError{Name: "keys", Typ: gojq.JQTypeString}
}
func (b Binary) JQValueHas(key any) any {
return gojqex.HasKeyTypeError{L: gojq.JQTypeString, R: fmt.Sprintf("%v", key)}
return gojqx.HasKeyTypeError{L: gojq.JQTypeString, R: fmt.Sprintf("%v", key)}
}
func (b Binary) JQValueToNumber() any {
buf, err := b.toBytesBuffer(b.r)
@ -475,7 +475,7 @@ func (b Binary) Display(w io.Writer, opts *Options) error {
return err
}
if _, err := bitioex.CopyBits(w, br); err != nil {
if _, err := bitiox.CopyBits(w, br); err != nil {
return err
}
@ -486,12 +486,12 @@ func (b Binary) Display(w io.Writer, opts *Options) error {
}
func (b Binary) toReader() (bitio.ReaderAtSeeker, error) {
br, err := bitioex.Range(b.br, b.r.Start, b.r.Len)
br, err := bitiox.Range(b.br, b.r.Start, b.r.Len)
if err != nil {
return nil, err
}
if b.pad == 0 {
return br, nil
}
return bitio.NewMultiReader(bitioex.NewZeroAtSeeker(b.pad), br)
return bitio.NewMultiReader(bitiox.NewZeroAtSeeker(b.pad), br)
}

44
pkg/interp/bitops.go
View File

@ -3,7 +3,7 @@ package interp
import (
"math/big"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/gojq"
)
@ -25,7 +25,7 @@ func (i *Interp) bnot(c any) any {
case gojq.JQValue:
return i.bnot(c.JQValueToGoJQ())
default:
return &gojqex.UnaryTypeError{Name: "bnot", V: c}
return &gojqx.UnaryTypeError{Name: "bnot", V: c}
}
}
@ -39,12 +39,12 @@ func (i *Interp) bsl(c any, a any, b any) any {
},
func(l, r float64) any { return int(l) << int(r) },
func(l, r *big.Int) any { return new(big.Int).Lsh(l, uint(r.Uint64())) },
func(l, r string) any { return &gojqex.BinopTypeError{Name: "bsl", L: l, R: r} },
func(l, r []any) any { return &gojqex.BinopTypeError{Name: "bsl", L: l, R: r} },
func(l, r string) any { return &gojqx.BinopTypeError{Name: "bsl", L: l, R: r} },
func(l, r []any) any { return &gojqx.BinopTypeError{Name: "bsl", L: l, R: r} },
func(l, r map[string]any) any {
return &gojqex.BinopTypeError{Name: "bsl", L: l, R: r}
return &gojqx.BinopTypeError{Name: "bsl", L: l, R: r}
},
func(l, r any) any { return &gojqex.BinopTypeError{Name: "bsl", L: l, R: r} },
func(l, r any) any { return &gojqx.BinopTypeError{Name: "bsl", L: l, R: r} },
)
}
@ -53,12 +53,12 @@ func (i *Interp) bsr(c any, a any, b any) any {
func(l, r int) any { return l >> r },
func(l, r float64) any { return int(l) >> int(r) },
func(l, r *big.Int) any { return new(big.Int).Rsh(l, uint(r.Uint64())) },
func(l, r string) any { return &gojqex.BinopTypeError{Name: "bsr", L: l, R: r} },
func(l, r []any) any { return &gojqex.BinopTypeError{Name: "bsr", L: l, R: r} },
func(l, r string) any { return &gojqx.BinopTypeError{Name: "bsr", L: l, R: r} },
func(l, r []any) any { return &gojqx.BinopTypeError{Name: "bsr", L: l, R: r} },
func(l, r map[string]any) any {
return &gojqex.BinopTypeError{Name: "bsr", L: l, R: r}
return &gojqx.BinopTypeError{Name: "bsr", L: l, R: r}
},
func(l, r any) any { return &gojqex.BinopTypeError{Name: "bsr", L: l, R: r} },
func(l, r any) any { return &gojqx.BinopTypeError{Name: "bsr", L: l, R: r} },
)
}
@ -67,12 +67,12 @@ func (i *Interp) band(c any, a any, b any) any {
func(l, r int) any { return l & r },
func(l, r float64) any { return int(l) & int(r) },
func(l, r *big.Int) any { return new(big.Int).And(l, r) },
func(l, r string) any { return &gojqex.BinopTypeError{Name: "band", L: l, R: r} },
func(l, r []any) any { return &gojqex.BinopTypeError{Name: "band", L: l, R: r} },
func(l, r string) any { return &gojqx.BinopTypeError{Name: "band", L: l, R: r} },
func(l, r []any) any { return &gojqx.BinopTypeError{Name: "band", L: l, R: r} },
func(l, r map[string]any) any {
return &gojqex.BinopTypeError{Name: "band", L: l, R: r}
return &gojqx.BinopTypeError{Name: "band", L: l, R: r}
},
func(l, r any) any { return &gojqex.BinopTypeError{Name: "band", L: l, R: r} },
func(l, r any) any { return &gojqx.BinopTypeError{Name: "band", L: l, R: r} },
)
}
@ -81,12 +81,12 @@ func (i *Interp) bor(c any, a any, b any) any {
func(l, r int) any { return l | r },
func(l, r float64) any { return int(l) | int(r) },
func(l, r *big.Int) any { return new(big.Int).Or(l, r) },
func(l, r string) any { return &gojqex.BinopTypeError{Name: "bor", L: l, R: r} },
func(l, r []any) any { return &gojqex.BinopTypeError{Name: "bor", L: l, R: r} },
func(l, r string) any { return &gojqx.BinopTypeError{Name: "bor", L: l, R: r} },
func(l, r []any) any { return &gojqx.BinopTypeError{Name: "bor", L: l, R: r} },
func(l, r map[string]any) any {
return &gojqex.BinopTypeError{Name: "bor", L: l, R: r}
return &gojqx.BinopTypeError{Name: "bor", L: l, R: r}
},
func(l, r any) any { return &gojqex.BinopTypeError{Name: "bor", L: l, R: r} },
func(l, r any) any { return &gojqx.BinopTypeError{Name: "bor", L: l, R: r} },
)
}
@ -95,11 +95,11 @@ func (i *Interp) bxor(c any, a any, b any) any {
func(l, r int) any { return l ^ r },
func(l, r float64) any { return int(l) ^ int(r) },
func(l, r *big.Int) any { return new(big.Int).Xor(l, r) },
func(l, r string) any { return &gojqex.BinopTypeError{Name: "bxor", L: l, R: r} },
func(l, r []any) any { return &gojqex.BinopTypeError{Name: "bxor", L: l, R: r} },
func(l, r string) any { return &gojqx.BinopTypeError{Name: "bxor", L: l, R: r} },
func(l, r []any) any { return &gojqx.BinopTypeError{Name: "bxor", L: l, R: r} },
func(l, r map[string]any) any {
return &gojqex.BinopTypeError{Name: "bxor", L: l, R: r}
return &gojqx.BinopTypeError{Name: "bxor", L: l, R: r}
},
func(l, r any) any { return &gojqex.BinopTypeError{Name: "bxor", L: l, R: r} },
func(l, r any) any { return &gojqx.BinopTypeError{Name: "bxor", L: l, R: r} },
)
}

50
pkg/interp/decode.go
View File

@ -10,9 +10,9 @@ import (
"time"
"github.com/mitchellh/copystructure"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/ioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/internal/iox"
"github.com/wader/fq/internal/mapstruct"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
@ -106,7 +106,7 @@ func (i *Interp) _registry(c any) any {
delete(args, k)
}
}
vf["decode_in_arg"] = gojqex.Normalize(args)
vf["decode_in_arg"] = gojqx.Normalize(args)
}
if f.Functions != nil {
@ -192,7 +192,7 @@ func (i *Interp) _decode(c any, format string, opts decodeOpts) any {
c,
opts.Progress,
nil,
EvalOpts{output: ioex.DiscardCtxWriter{Ctx: i.EvalInstance.Ctx}},
EvalOpts{output: iox.DiscardCtxWriter{Ctx: i.EvalInstance.Ctx}},
)
}
lastProgress := time.Now()
@ -304,7 +304,7 @@ func valueOrFallbackHas(key any, baseHas func(key any) any, valueHas func(key an
// TODO: make more efficient somehow? shallow values but might be hard
// when things like tovalue.key should behave like a jq value and not a decode value etc
func toValue(optsFn func() (*Options, error), v any) (any, error) {
return gojqex.ToGoJQValueFn(v, func(v any) (any, error) {
return gojqx.ToGoJQValueFn(v, func(v any) (any, error) {
switch v := v.(type) {
case JQValueEx:
if optsFn == nil {
@ -357,7 +357,7 @@ func makeDecodeValueOut(dv *decode.Value, kind decodeValueKind, out any) any {
// create another binary we don't have to read and create a string, ex:
// .unknown0 | tobytes[1:] | ...
return decodeValue{
JQValue: &gojqex.Lazy{
JQValue: &gojqx.Lazy{
Type: "string",
IsScalar: true,
Fn: func() (gojq.JQValue, error) {
@ -366,10 +366,10 @@ func makeDecodeValueOut(dv *decode.Value, kind decodeValueKind, out any) any {
if err != nil {
return nil, err
}
if _, err := bitioex.CopyBits(buf, vvvC); err != nil {
if _, err := bitiox.CopyBits(buf, vvvC); err != nil {
return nil, err
}
return gojqex.String([]rune(buf.String())), nil
return gojqx.String([]rune(buf.String())), nil
},
},
decodeValueBase: decodeValueBase{dv: dv},
@ -377,52 +377,52 @@ func makeDecodeValueOut(dv *decode.Value, kind decodeValueKind, out any) any {
}
case bool:
return decodeValue{
JQValue: gojqex.Boolean(vvv),
JQValue: gojqx.Boolean(vvv),
decodeValueBase: decodeValueBase{dv: dv},
}
case int:
return decodeValue{
JQValue: gojqex.Number{V: vvv},
JQValue: gojqx.Number{V: vvv},
decodeValueBase: decodeValueBase{dv: dv},
}
case int64:
return decodeValue{
JQValue: gojqex.Number{V: big.NewInt(vvv)},
JQValue: gojqx.Number{V: big.NewInt(vvv)},
decodeValueBase: decodeValueBase{dv: dv},
}
case uint64:
return decodeValue{
JQValue: gojqex.Number{V: new(big.Int).SetUint64(vvv)},
JQValue: gojqx.Number{V: new(big.Int).SetUint64(vvv)},
decodeValueBase: decodeValueBase{dv: dv},
}
case float64:
return decodeValue{
JQValue: gojqex.Number{V: vvv},
JQValue: gojqx.Number{V: vvv},
decodeValueBase: decodeValueBase{dv: dv},
}
case string:
return decodeValue{
JQValue: gojqex.String(vvv),
JQValue: gojqx.String(vvv),
decodeValueBase: decodeValueBase{dv: dv},
}
case []any:
return decodeValue{
JQValue: gojqex.Array(vvv),
JQValue: gojqx.Array(vvv),
decodeValueBase: decodeValueBase{dv: dv},
}
case map[string]any:
return decodeValue{
JQValue: gojqex.Object(vvv),
JQValue: gojqx.Object(vvv),
decodeValueBase: decodeValueBase{dv: dv},
}
case nil:
return decodeValue{
JQValue: gojqex.Null{},
JQValue: gojqx.Null{},
decodeValueBase: decodeValueBase{dv: dv},
}
case *big.Int:
return decodeValue{
JQValue: gojqex.Number{V: vvv},
JQValue: gojqx.Number{V: vvv},
decodeValueBase: decodeValueBase{dv: dv},
}
case Binary:
@ -651,7 +651,7 @@ func (v decodeValue) JQValueToGoJQEx(optsFn func() (*Options, error)) any {
var _ DecodeValue = ArrayDecodeValue{}
type ArrayDecodeValue struct {
gojqex.Base
gojqx.Base
decodeValueBase
*decode.Compound
}
@ -659,7 +659,7 @@ type ArrayDecodeValue struct {
func NewArrayDecodeValue(dv *decode.Value, out any, c *decode.Compound) ArrayDecodeValue {
return ArrayDecodeValue{
decodeValueBase: decodeValueBase{dv: dv, out: out},
Base: gojqex.Base{Typ: gojq.JQTypeArray},
Base: gojqx.Base{Typ: gojq.JQTypeArray},
Compound: c,
}
}
@ -704,7 +704,7 @@ func (v ArrayDecodeValue) JQValueHas(key any) any {
func(key any) any {
intKey, ok := key.(int)
if !ok {
return gojqex.HasKeyTypeError{L: gojq.JQTypeArray, R: fmt.Sprintf("%v", key)}
return gojqx.HasKeyTypeError{L: gojq.JQTypeArray, R: fmt.Sprintf("%v", key)}
}
return intKey >= 0 && intKey < len(v.Compound.Children)
})
@ -738,7 +738,7 @@ func (v ArrayDecodeValue) JQValueToGoJQ() any {
var _ DecodeValue = StructDecodeValue{}
type StructDecodeValue struct {
gojqex.Base
gojqx.Base
decodeValueBase
*decode.Compound
}
@ -746,7 +746,7 @@ type StructDecodeValue struct {
func NewStructDecodeValue(dv *decode.Value, out any, c *decode.Compound) StructDecodeValue {
return StructDecodeValue{
decodeValueBase: decodeValueBase{dv: dv, out: out},
Base: gojqex.Base{Typ: gojq.JQTypeObject},
Base: gojqx.Base{Typ: gojq.JQTypeObject},
Compound: c,
}
}
@ -801,7 +801,7 @@ func (v StructDecodeValue) JQValueHas(key any) any {
func(key any) any {
stringKey, ok := key.(string)
if !ok {
return gojqex.HasKeyTypeError{L: gojq.JQTypeObject, R: fmt.Sprintf("%v", key)}
return gojqx.HasKeyTypeError{L: gojq.JQTypeObject, R: fmt.Sprintf("%v", key)}
}
if v.Compound.ByName != nil {

14
pkg/interp/default_register.go
View File

@ -3,7 +3,7 @@ package interp
import (
"io/fs"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/decode"
"github.com/wader/gojq"
)
@ -20,25 +20,25 @@ func RegisterFS(fs fs.ReadDirFS) {
}
func RegisterFunc0[Tc any](name string, fn func(e *Interp, c Tc) any) {
DefaultRegistry.Func(gojqex.Func0(name, fn))
DefaultRegistry.Func(gojqx.Func0(name, fn))
}
func RegisterFunc1[Tc any, Ta0 any](name string, fn func(e *Interp, c Tc, a0 Ta0) any) {
DefaultRegistry.Func(gojqex.Func1(name, fn))
DefaultRegistry.Func(gojqx.Func1(name, fn))
}
func RegisterFunc2[Tc any, Ta0 any, Ta1 any](name string, fn func(e *Interp, c Tc, a0 Ta0, a1 Ta1) any) {
DefaultRegistry.Func(gojqex.Func2(name, fn))
DefaultRegistry.Func(gojqx.Func2(name, fn))
}
func RegisterIter0[Tc any](name string, fn func(e *Interp, c Tc) gojq.Iter) {
DefaultRegistry.Func(gojqex.Iter0(name, fn))
DefaultRegistry.Func(gojqx.Iter0(name, fn))
}
func RegisterIter1[Tc any, Ta0 any](name string, fn func(e *Interp, c Tc, a0 Ta0) gojq.Iter) {
DefaultRegistry.Func(gojqex.Iter1(name, fn))
DefaultRegistry.Func(gojqx.Iter1(name, fn))
}
func RegisterIter2[Tc any, Ta0 any, Ta1 any](name string, fn func(e *Interp, c Tc, a0 Ta0, a1 Ta1) gojq.Iter) {
DefaultRegistry.Func(gojqex.Iter2(name, fn))
DefaultRegistry.Func(gojqx.Iter2(name, fn))
}

30
pkg/interp/dump.go
View File

@ -9,10 +9,10 @@ import (
"github.com/wader/fq/internal/ansi"
"github.com/wader/fq/internal/asciiwriter"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/internal/columnwriter"
"github.com/wader/fq/internal/hexpairwriter"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
"github.com/wader/fq/pkg/scalar"
@ -185,7 +185,7 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
if opts.Verbose && !isSynthetic {
cfmt(colField, " %s (%s)",
mathex.BitRange(innerRange).StringByteBits(opts.Addrbase), mathex.Bits(innerRange.Len).StringByteBits(opts.Sizebase))
mathx.BitRange(innerRange).StringByteBits(opts.Addrbase), mathx.Bits(innerRange.Len).StringByteBits(opts.Sizebase))
}
cprint(colField, "\n")
@ -225,7 +225,7 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
printErrs(depth, valueErr)
}
rootBitLen, err := bitioex.Len(rootV.RootReader)
rootBitLen, err := bitiox.Len(rootV.RootReader)
if err != nil {
return err
}
@ -269,9 +269,9 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
// has length and is not compound or a collapsed struct/array (max depth)
if willDisplayData {
cfmt(colAddr, "%s%s\n",
rootIndent, deco.DumpAddr.F(mathex.PadFormatInt(startLineByte, opts.Addrbase, true, addrWidth)))
rootIndent, deco.DumpAddr.F(mathx.PadFormatInt(startLineByte, opts.Addrbase, true, addrWidth)))
vBR, err := bitioex.Range(rootV.RootReader, startByte*8, displaySizeBits)
vBR, err := bitiox.Range(rootV.RootReader, startByte*8, displaySizeBits)
if err != nil {
return err
}
@ -284,7 +284,7 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
if err != nil {
return err
}
if _, err := bitioex.CopyBitsBuffer(
if _, err := bitiox.CopyBitsBuffer(
hexpairwriter.New(cw.Columns[colHex], opts.LineBytes, int(startLineByteOffset), hexpairFn),
hexBR,
buf); err != nil {
@ -295,7 +295,7 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
if err != nil {
return err
}
if _, err := bitioex.CopyBitsBuffer(
if _, err := bitiox.CopyBitsBuffer(
asciiwriter.New(cw.Columns[colASCII], opts.LineBytes, int(startLineByteOffset), asciiFn),
asciiBR,
buf); err != nil {
@ -304,7 +304,7 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
for i := int64(1); i < addrLines; i++ {
lineStartByte := startLineByte + i*int64(opts.LineBytes)
cfmt(colAddr, "%s%s\n", rootIndent, deco.DumpAddr.F(mathex.PadFormatInt(lineStartByte, opts.Addrbase, true, addrWidth)))
cfmt(colAddr, "%s%s\n", rootIndent, deco.DumpAddr.F(mathx.PadFormatInt(lineStartByte, opts.Addrbase, true, addrWidth)))
}
// TODO: correct? should rethink columnwriter api maybe?
lastLineStopByte := startLineByte + addrLines*int64(opts.LineBytes) - 1
@ -324,9 +324,9 @@ func dumpEx(v *decode.Value, ctx *dumpCtx, depth int, rootV *decode.Value, rootD
cprint(colHex, "\n")
// TODO: truncate if display_bytes is small?
cfmt(colHex, "until %s%s (%s)",
mathex.Bits(stopBit).StringByteBits(opts.Addrbase),
mathx.Bits(stopBit).StringByteBits(opts.Addrbase),
isEnd,
mathex.PadFormatInt(bitio.BitsByteCount(sizeBits), opts.Sizebase, true, 0))
mathx.PadFormatInt(bitio.BitsByteCount(sizeBits), opts.Sizebase, true, 0))
// TODO: dump last line?
}
}
@ -351,9 +351,9 @@ func dump(v *decode.Value, w io.Writer, opts *Options) error {
}
_ = v.WalkPreOrder(makeWalkFn(func(v *decode.Value, _ *decode.Value, _ int, rootDepth int) error {
maxAddrIndentWidth = mathex.Max(
maxAddrIndentWidth = mathx.Max(
maxAddrIndentWidth,
rootIndentWidth*rootDepth+mathex.DigitsInBase(bitio.BitsByteCount(v.InnerRange().Stop()), true, opts.Addrbase),
rootIndentWidth*rootDepth+mathx.DigitsInBase(bitio.BitsByteCount(v.InnerRange().Stop()), true, opts.Addrbase),
)
return nil
}))
@ -390,7 +390,7 @@ func dump(v *decode.Value, w io.Writer, opts *Options) error {
var hexHeader string
var asciiHeader string
for i := 0; i < opts.LineBytes; i++ {
s := mathex.PadFormatInt(int64(i), opts.Addrbase, false, 2)
s := mathx.PadFormatInt(int64(i), opts.Addrbase, false, 2)
hexHeader += s
if i < opts.LineBytes-1 {
hexHeader += " "
@ -412,7 +412,7 @@ func dump(v *decode.Value, w io.Writer, opts *Options) error {
}
func hexdump(w io.Writer, bv Binary, opts *Options) error {
br, err := bitioex.Range(bv.br, bv.r.Start, bv.r.Len)
br, err := bitiox.Range(bv.br, bv.r.Start, bv.r.Len)
if err != nil {
return err
}

44
pkg/interp/interp.go
View File

@ -18,13 +18,13 @@ import (
"time"
"github.com/wader/fq/internal/ansi"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/internal/colorjson"
"github.com/wader/fq/internal/ctxstack"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/ioex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/internal/iox"
"github.com/wader/fq/internal/mapstruct"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/internal/pos"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/decode"
@ -284,7 +284,7 @@ func toBytes(v any) ([]byte, error) {
return nil, fmt.Errorf("value is not bytes")
}
buf := &bytes.Buffer{}
if _, err := bitioex.CopyBits(buf, br); err != nil {
if _, err := bitiox.CopyBits(buf, br); err != nil {
return nil, err
}
@ -469,7 +469,7 @@ func (i *Interp) _readline(c any, opts readlineOpts) gojq.Iter {
opts.Complete,
[]any{line, pos},
EvalOpts{
output: ioex.DiscardCtxWriter{Ctx: completeCtx},
output: iox.DiscardCtxWriter{Ctx: completeCtx},
isCompleting: true,
},
)
@ -485,7 +485,7 @@ func (i *Interp) _readline(c any, opts readlineOpts) gojq.Iter {
}
// {abc: 123, abd: 123} | complete(".ab"; 3) will return {prefix: "ab", names: ["abc", "abd"]}
r, ok := gojqex.CastFn[completionResult](v, mapstruct.ToStruct)
r, ok := gojqx.CastFn[completionResult](v, mapstruct.ToStruct)
if !ok {
return nil, pos, fmt.Errorf("completion result not a map")
}
@ -963,7 +963,7 @@ func (i *Interp) Eval(ctx context.Context, c any, expr string, opts EvalOpts) (g
runCtx, runCtxCancelFn := i.interruptStack.Push(ctx)
ni.EvalInstance.Ctx = runCtx
ni.EvalInstance.Output = ioex.CtxWriter{Writer: output, Ctx: runCtx}
ni.EvalInstance.Output = iox.CtxWriter{Writer: output, Ctx: runCtx}
// inherit or maybe set
ni.EvalInstance.IsCompleting = i.EvalInstance.IsCompleting || opts.isCompleting
iter := gc.RunWithContext(runCtx, c, variableValues...)
@ -1056,12 +1056,12 @@ type Options struct {
func OptionsFromValue(v any) (*Options, error) {
var opts Options
_ = mapstruct.ToStruct(v, &opts)
opts.ArrayTruncate = mathex.Max(0, opts.ArrayTruncate)
opts.Depth = mathex.Max(0, opts.Depth)
opts.Addrbase = mathex.Clamp(2, 36, opts.Addrbase)
opts.Sizebase = mathex.Clamp(2, 36, opts.Sizebase)
opts.LineBytes = mathex.Max(1, opts.LineBytes)
opts.DisplayBytes = mathex.Max(0, opts.DisplayBytes)
opts.ArrayTruncate = mathx.Max(0, opts.ArrayTruncate)
opts.Depth = mathx.Max(0, opts.Depth)
opts.Addrbase = mathx.Clamp(2, 36, opts.Addrbase)
opts.Sizebase = mathx.Clamp(2, 36, opts.Sizebase)
opts.LineBytes = mathx.Max(1, opts.LineBytes)
opts.DisplayBytes = mathx.Max(0, opts.DisplayBytes)
opts.Decorator = decoratorFromOptions(opts)
if fn, err := bitsFormatFnFromOptions(opts); err != nil {
return nil, err
@ -1077,7 +1077,7 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
case "md5":
return func(br bitio.ReaderAtSeeker) (any, error) {
d := md5.New()
if _, err := bitioex.CopyBits(d, br); err != nil {
if _, err := bitiox.CopyBits(d, br); err != nil {
return "", err
}
return hex.EncodeToString(d.Sum(nil)), nil
@ -1086,7 +1086,7 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
return func(br bitio.ReaderAtSeeker) (any, error) {
b := &bytes.Buffer{}
e := hex.NewEncoder(b)
if _, err := bitioex.CopyBits(e, br); err != nil {
if _, err := bitiox.CopyBits(e, br); err != nil {
return "", err
}
return b.String(), nil
@ -1095,7 +1095,7 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
return func(br bitio.ReaderAtSeeker) (any, error) {
b := &bytes.Buffer{}
e := base64.NewEncoder(base64.StdEncoding, b)
if _, err := bitioex.CopyBits(e, br); err != nil {
if _, err := bitiox.CopyBits(e, br); err != nil {
return "", err
}
e.Close()
@ -1105,7 +1105,7 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
// TODO: configure
return func(br bitio.ReaderAtSeeker) (any, error) {
b := &bytes.Buffer{}
if _, err := bitioex.CopyBits(b, bitio.NewLimitReader(br, 1024*8)); err != nil {
if _, err := bitiox.CopyBits(b, bitio.NewLimitReader(br, 1024*8)); err != nil {
return "", err
}
return b.String(), nil
@ -1113,7 +1113,7 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
case "string":
return func(br bitio.ReaderAtSeeker) (any, error) {
b := &bytes.Buffer{}
if _, err := bitioex.CopyBits(b, br); err != nil {
if _, err := bitiox.CopyBits(b, br); err != nil {
return "", err
}
return b.String(), nil
@ -1122,16 +1122,16 @@ func bitsFormatFnFromOptions(opts Options) (func(br bitio.ReaderAtSeeker) (any,
return func(br bitio.ReaderAtSeeker) (any, error) {
b := &bytes.Buffer{}
e := base64.NewEncoder(base64.StdEncoding, b)
if _, err := bitioex.CopyBits(e, bitio.NewLimitReader(br, 256*8)); err != nil {
if _, err := bitiox.CopyBits(e, bitio.NewLimitReader(br, 256*8)); err != nil {
return "", err
}
e.Close()
brLen, err := bitioex.Len(br)
brLen, err := bitiox.Len(br)
if err != nil {
return nil, err
}
return fmt.Sprintf("<%s>%s", mathex.Bits(brLen).StringByteBits(opts.Sizebase), b.String()), nil
return fmt.Sprintf("<%s>%s", mathx.Bits(brLen).StringByteBits(opts.Sizebase), b.String()), nil
}, nil
default:
return nil, fmt.Errorf("invalid bits format %q", opts.BitsFormat)

10
pkg/interp/match.go
View File

@ -5,8 +5,8 @@ import (
"regexp"
"strings"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/ioex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/internal/iox"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/ranges"
"github.com/wader/gojq"
@ -50,7 +50,7 @@ func (i *Interp) _binaryMatch(c any, pattern any, flags string) gojq.Iter {
// TODO: err to string
// TODO: extract to regexpextra? "all" FindReaderSubmatchIndex that can iter?
sre, err := gojqex.CompileRegexp(re, "gimb", flags)
sre, err := gojqx.CompileRegexp(re, "gimb", flags)
if err != nil {
return gojq.NewIter(err)
}
@ -70,9 +70,9 @@ func (i *Interp) _binaryMatch(c any, pattern any, flags string) gojq.Iter {
// will match the byte \0xff
if byteRunes {
// byte mode, read each byte as a rune
rr = ioex.ByteRuneReader{RS: bitio.NewIOReadSeeker(br)}
rr = iox.ByteRuneReader{RS: bitio.NewIOReadSeeker(br)}
} else {
rr = ioex.RuneReadSeeker{RS: bitio.NewIOReadSeeker(br)}
rr = iox.RuneReadSeeker{RS: bitio.NewIOReadSeeker(br)}
}
var off int64

21
pkg/interp/preview.go
View File

@ -1,14 +1,13 @@
package interp
import (
"bytes"
"fmt"
"math/big"
"strconv"
"strings"
"github.com/wader/fq/internal/mathex"
"github.com/wader/fq/internal/stringsex"
"github.com/wader/fq/internal/mathx"
"github.com/wader/fq/internal/stringsx"
"github.com/wader/fq/pkg/bitio"
"github.com/wader/fq/pkg/scalar"
)
@ -22,23 +21,17 @@ func previewValue(v any, df scalar.DisplayFormat) string {
return "false"
case int:
// TODO: DisplayFormat is weird
return mathex.PadFormatInt(int64(vv), df.FormatBase(), true, 0)
return mathx.PadFormatInt(int64(vv), df.FormatBase(), true, 0)
case int64:
// TODO: DisplayFormat is weird
return mathex.PadFormatInt(vv, df.FormatBase(), true, 0)
return mathx.PadFormatInt(vv, df.FormatBase(), true, 0)
case uint64:
return mathex.PadFormatUint(vv, df.FormatBase(), true, 0)
return mathx.PadFormatUint(vv, df.FormatBase(), true, 0)
case float64:
// TODO: float32? better truncated to significant digits?
return strconv.FormatFloat(vv, 'g', -1, 64)
case string:
s := strconv.Quote(stringsex.TrimN(vv, 50, "..."))
// TODO: hack for https://github.com/golang/go/issues/52062
// 0x7f used to be escaped as \u007f in 1.18 and lower, was changed to \x7f
// remove once 1.18 is not supported
if !bytes.Contains([]byte(s), []byte{0x7f}) {
return s
}
s := strconv.Quote(stringsx.TrimN(vv, 50, "..."))
return strings.ReplaceAll(s, `\u007f`, `\x7f`)
case nil:
return "null"
@ -46,7 +39,7 @@ func previewValue(v any, df scalar.DisplayFormat) string {
Binary:
return "raw bits"
case *big.Int:
return mathex.PadFormatBigInt(vv, df.FormatBase(), true, 0)
return mathx.PadFormatBigInt(vv, df.FormatBase(), true, 0)
case map[string]any:
return "{}"
case []any:

8
pkg/interp/registry.go
View File

@ -1,19 +1,19 @@
package interp
import (
"cmp"
"errors"
"fmt"
"io/fs"
"strings"
"sync"
"github.com/wader/fq/internal/cmpex"
"github.com/wader/fq/internal/gojqex"
"github.com/wader/fq/internal/gojqx"
"github.com/wader/fq/pkg/decode"
"golang.org/x/exp/slices"
)
type EnvFuncFn func(env *Interp) gojqex.Function
type EnvFuncFn func(env *Interp) gojqx.Function
type Registry struct {
allGroup *decode.Group
@ -70,7 +70,7 @@ func sortFormats(g *decode.Group) {
if a.ProbeOrder == b.ProbeOrder {
return strings.Compare(a.Name, b.Name)
}
return cmpex.Compare(a.ProbeOrder, b.ProbeOrder)
return cmp.Compare(a.ProbeOrder, b.ProbeOrder)
})
}

5
pkg/ranges/ranges.go
View File

@ -1,13 +1,12 @@
package ranges
import (
"cmp"
"fmt"
"strconv"
"strings"
"golang.org/x/exp/slices"
"github.com/wader/fq/internal/cmpex"
)
func max(a, b int64) int64 {
@ -65,7 +64,7 @@ func Gaps(total Range, ranges []Range) []Range {
return []Range{total}
}
slices.SortFunc(ranges, func(a, b Range) int { return cmpex.Compare(a.Start, b.Start) })
slices.SortFunc(ranges, func(a, b Range) int { return cmp.Compare(a.Start, b.Start) })
// worst case ranges+1 gaps
merged := make([]Range, 0, len(ranges)+1)

6
pkg/scalar/scalar.go
View File

@ -12,7 +12,7 @@ import (
"strings"
"time"
"github.com/wader/fq/internal/bitioex"
"github.com/wader/fq/internal/bitiox"
"github.com/wader/fq/pkg/bitio"
)
@ -185,7 +185,7 @@ func (rs SRangeToScalar) MapSint(s Sint) (Sint, error) {
func RawSym(s BitBuf, nBytes int, fn func(b []byte) string) (BitBuf, error) {
br := s.Actual
brLen, err := bitioex.Len(br)
brLen, err := bitiox.Len(br)
if err != nil {
return BitBuf{}, err
}
@ -230,7 +230,7 @@ func (m RawBytesMap) MapBitBuf(s BitBuf) (BitBuf, error) {
return s, err
}
bb := &bytes.Buffer{}
if _, err := bitioex.CopyBits(bb, rc); err != nil {
if _, err := bitiox.CopyBits(bb, rc); err != nil {
return s, err
}
for _, bs := range m {