From bf28b48d23d19990190d5e5aeaee14ea6652a293 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Sat, 28 Jan 2023 10:05:06 -0700 Subject: reencode: Wrapping the handleRune state is no longer necessary --- reencode.go | 101 +++++++++++++++++++++++++++++------------------------------- 1 file changed, 49 insertions(+), 52 deletions(-) diff --git a/reencode.go b/reencode.go index b3f4d20..d588b1b 100644 --- a/reencode.go +++ b/reencode.go @@ -98,16 +98,13 @@ type ReEncoder struct { inputPos int64 // state: .handleRune - handleRuneState struct { - lastNonSpace internal.RuneType - wasNumber bool - curIndent int - uhex [4]byte // "\uABCD"-encoded characters in strings - fracZeros int64 - expZero bool - - specu *speculation - } + lastNonSpace internal.RuneType + wasNumber bool + curIndent int + uhex [4]byte // "\uABCD"-encoded characters in strings + fracZeros int64 + expZero bool + specu *speculation } type speculation struct { @@ -281,7 +278,7 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err } // main - if enc.handleRuneState.specu == nil { // not speculating + if enc.specu == nil { // not speculating switch t { case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg: // start speculating if err, _ := enc.handleRunePre(c, t); err != nil { @@ -295,8 +292,8 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err } specu.fmt.Compact = true specu.fmt.out = &specu.compact - enc.handleRuneState.specu = specu - enc.handleRuneState.specu.buf = append(enc.handleRuneState.specu.buf, inputTuple{ + enc.specu = specu + enc.specu.buf = append(enc.specu.buf, inputTuple{ c: c, t: t, stackSize: stackSize, @@ -310,18 +307,18 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err } } } else { // speculating - enc.handleRuneState.specu.buf = append(enc.handleRuneState.specu.buf, inputTuple{ + enc.specu.buf = append(enc.specu.buf, inputTuple{ c: c, t: t, stackSize: stackSize, }) - if err := enc.handleRuneState.specu.fmt.handleRune(c, t, stackSize); err != nil { + if err := enc.specu.fmt.handleRune(c, t, stackSize); err != nil { return err } switch { - case enc.handleRuneState.specu.compact.Len() >= enc.CompactIfUnder: // stop speculating; use indent - buf := enc.handleRuneState.specu.buf - enc.handleRuneState.specu = nil + case enc.specu.compact.Len() >= enc.CompactIfUnder: // stop speculating; use indent + buf := enc.specu.buf + enc.specu = nil if err := enc.handleRuneMain(buf[0].c, buf[0].t); err != nil { return err } @@ -330,13 +327,13 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err return err } } - case stackSize == enc.handleRuneState.specu.endWhenStackSize: // stop speculating; use compact - if _, err := enc.handleRuneState.specu.compact.WriteTo(enc.out); err != nil { + case stackSize == enc.specu.endWhenStackSize: // stop speculating; use compact + if _, err := enc.specu.compact.WriteTo(enc.out); err != nil { return err } - enc.handleRuneState.lastNonSpace = t - enc.handleRuneState.curIndent-- - enc.handleRuneState.specu = nil + enc.lastNonSpace = t + enc.curIndent-- + enc.specu = nil } } @@ -358,9 +355,9 @@ func (enc *ReEncoder) handleRuneNoSpeculation(c rune, t internal.RuneType) error // the new rune itself is handled. func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { // emit newlines between top-level values - if enc.handleRuneState.lastNonSpace == internal.RuneTypeEOF { + if enc.lastNonSpace == internal.RuneTypeEOF { switch { - case enc.handleRuneState.wasNumber && t.IsNumber(): + case enc.wasNumber && t.IsNumber(): if err := enc.emitByte('\n'); err != nil { return err, false } @@ -374,35 +371,35 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { // shorten numbers switch t { // trim trailing '0's from the fraction-part, but don't remove all digits case internal.RuneTypeNumberFracDot: - enc.handleRuneState.fracZeros = 0 + enc.fracZeros = 0 case internal.RuneTypeNumberFracDig: - if c == '0' && enc.handleRuneState.lastNonSpace == internal.RuneTypeNumberFracDig { - enc.handleRuneState.fracZeros++ + if c == '0' && enc.lastNonSpace == internal.RuneTypeNumberFracDig { + enc.fracZeros++ return nil, false } fallthrough default: - for enc.handleRuneState.fracZeros > 0 { + for enc.fracZeros > 0 { if err := enc.emitByte('0'); err != nil { return err, false } - enc.handleRuneState.fracZeros-- + enc.fracZeros-- } } switch t { // trim leading '0's from the exponent-part, but don't remove all digits case internal.RuneTypeNumberExpE, internal.RuneTypeNumberExpSign: - enc.handleRuneState.expZero = true + enc.expZero = true case internal.RuneTypeNumberExpDig: - if c == '0' && enc.handleRuneState.expZero { + if c == '0' && enc.expZero { return nil, false } - enc.handleRuneState.expZero = false + enc.expZero = false default: - if enc.handleRuneState.expZero { + if enc.expZero { if err := enc.emitByte('0'); err != nil { return err, false } - enc.handleRuneState.expZero = false + enc.expZero = false } } @@ -418,8 +415,8 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { // let us manage whitespace, don't pass it through return nil, false case internal.RuneTypeObjectEnd, internal.RuneTypeArrayEnd: - enc.handleRuneState.curIndent-- - switch enc.handleRuneState.lastNonSpace { + enc.curIndent-- + switch enc.lastNonSpace { case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg: // collapse default: @@ -428,7 +425,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { } } default: - switch enc.handleRuneState.lastNonSpace { + switch enc.lastNonSpace { case internal.RuneTypeObjectBeg, internal.RuneTypeObjectComma, internal.RuneTypeArrayBeg, internal.RuneTypeArrayComma: if err := enc.emitNlIndent(); err != nil { return err, false @@ -440,7 +437,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { } switch t { case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg: - enc.handleRuneState.curIndent++ + enc.curIndent++ } } } @@ -452,7 +449,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) { func (enc *ReEncoder) handleRuneMain(c rune, t internal.RuneType) error { defer func() { if t != internal.RuneTypeSpace { - enc.handleRuneState.lastNonSpace = t + enc.lastNonSpace = t } }() @@ -484,33 +481,33 @@ func (enc *ReEncoder) handleRuneMain(c rune, t internal.RuneType) error { panic("should not happen") } case internal.RuneTypeStringEscUA: - enc.handleRuneState.uhex[0], _ = internal.HexToInt(c) + enc.uhex[0], _ = internal.HexToInt(c) return nil case internal.RuneTypeStringEscUB: - enc.handleRuneState.uhex[1], _ = internal.HexToInt(c) + enc.uhex[1], _ = internal.HexToInt(c) return nil case internal.RuneTypeStringEscUC: - enc.handleRuneState.uhex[2], _ = internal.HexToInt(c) + enc.uhex[2], _ = internal.HexToInt(c) return nil case internal.RuneTypeStringEscUD: - enc.handleRuneState.uhex[3], _ = internal.HexToInt(c) + enc.uhex[3], _ = internal.HexToInt(c) c := 0 | - rune(enc.handleRuneState.uhex[0])<<12 | - rune(enc.handleRuneState.uhex[1])<<8 | - rune(enc.handleRuneState.uhex[2])<<4 | - rune(enc.handleRuneState.uhex[3])<<0 + rune(enc.uhex[0])<<12 | + rune(enc.uhex[1])<<8 | + rune(enc.uhex[2])<<4 | + rune(enc.uhex[3])<<0 return enc.emit(writeStringChar(enc.out, c, BackslashEscapeUnicode, enc.BackslashEscape)) case internal.RuneTypeError: // EOF explicitly stated by .Close() fallthrough case internal.RuneTypeEOF: // EOF implied by the start of the next top-level value - enc.handleRuneState.wasNumber = enc.handleRuneState.lastNonSpace.IsNumber() + enc.wasNumber = enc.lastNonSpace.IsNumber() switch { case enc.ForceTrailingNewlines: - t = internal.RuneTypeError // enc.handleRuneState.lastNonSpace : an NL isn't needed (we already printed one) + t = internal.RuneTypeError // enc.lastNonSpace : an NL isn't needed (we already printed one) return enc.emitByte('\n') default: - t = internal.RuneTypeEOF // enc.handleRuneState.lastNonSpace : an NL *might* be needed + t = internal.RuneTypeEOF // enc.lastNonSpace : an NL *might* be needed return nil } default: @@ -540,7 +537,7 @@ func (enc *ReEncoder) emitNlIndent() error { return err } } - for i := 0; i < enc.handleRuneState.curIndent; i++ { + for i := 0; i < enc.curIndent; i++ { if err := enc.emit(enc.out.WriteString(enc.Indent)); err != nil { return err } -- cgit v1.1-4-g5e80