mirror of
https://github.com/wader/fq.git
synced 2024-10-26 11:49:54 +03:00
Merge pull request #910 from wader/go-1.20-cleanup
fq: Use go 1.20 and cleanup
This commit is contained in:
commit
c5e84236df
@ -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
|
||||
|
@ -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
|
||||
}},
|
||||
|
@ -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)
|
||||
}
|
||||
|
@ -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]
|
||||
|
||||
|
@ -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
|
||||
|
@ -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()
|
||||
|
@ -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())
|
||||
|
@ -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()
|
||||
|
@ -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))
|
||||
})
|
||||
}
|
||||
|
@ -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,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,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)])
|
||||
|
@ -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()
|
||||
}
|
||||
|
||||
|
@ -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()
|
||||
|
@ -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}
|
||||
}
|
||||
|
@ -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
2
go.mod
@ -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
|
||||
|
@ -1,4 +1,4 @@
|
||||
package bitioex
|
||||
package bitiox
|
||||
|
||||
// bitio helpers that im not sure belong in bitio
|
||||
|
@ -1,4 +1,4 @@
|
||||
package bitioex
|
||||
package bitiox
|
||||
|
||||
import (
|
||||
"io"
|
@ -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
|
||||
}
|
@ -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 {
|
||||
|
@ -1,4 +1,4 @@
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"fmt"
|
@ -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"
|
||||
|
@ -1,5 +1,5 @@
|
||||
// Generated from makefn_gen.go.tmpl
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"github.com/wader/fq/internal/mapstruct"
|
@ -1,5 +1,5 @@
|
||||
// Generated from makefn_gen.go.tmpl
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"github.com/wader/fq/internal/mapstruct"
|
@ -1,4 +1,4 @@
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"fmt"
|
@ -3,7 +3,7 @@
|
||||
// The MIT License (MIT)
|
||||
// Copyright (c) 2019-2021 itchyny
|
||||
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"fmt"
|
@ -1,5 +1,5 @@
|
||||
//nolint:gosimple
|
||||
package gojqex
|
||||
package gojqx
|
||||
|
||||
import (
|
||||
"bytes"
|
@ -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 {
|
||||
|
@ -1,4 +1,4 @@
|
||||
package ioex
|
||||
package iox
|
||||
|
||||
import (
|
||||
"context"
|
@ -1,4 +1,4 @@
|
||||
package ioex
|
||||
package iox
|
||||
|
||||
import (
|
||||
"io"
|
@ -1,4 +1,4 @@
|
||||
package mathex
|
||||
package mathx
|
||||
|
||||
import "math/big"
|
||||
|
@ -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)
|
||||
}
|
@ -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,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"
|
@ -1,4 +1,4 @@
|
||||
package mathex
|
||||
package mathx
|
||||
|
||||
import (
|
||||
"fmt"
|
@ -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 {
|
||||
|
@ -1,4 +1,4 @@
|
||||
package sortex
|
||||
package sortx
|
||||
|
||||
import "sort"
|
||||
|
@ -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
|
||||
}
|
@ -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 {
|
||||
|
@ -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
|
||||
|
@ -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 }
|
||||
|
@ -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)
|
||||
|
@ -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 {
|
||||
|
@ -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)
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -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)
|
||||
}
|
||||
|
@ -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} },
|
||||
)
|
||||
}
|
||||
|
@ -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 {
|
||||
|
@ -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))
|
||||
}
|
||||
|
@ -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
|
||||
}
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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:
|
||||
|
@ -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)
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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 {
|
||||
|
Loading…
Reference in New Issue
Block a user