@ 1e3679e075694dda43bb3b82dd39f993c8e7705a | history
package sexpr
import (
"fmt"
"math"
"strconv"
"strings"
)
// Print returns the text form of v. For everything except functions, the
// output reads back (step 1.4) as an equal value.
func Print(v Value) string {
var b strings.Builder
write(&b, v)
return b.String()
}
func write(b *strings.Builder, v Value) {
switch v := v.(type) {
case Int:
b.WriteString(strconv.FormatInt(int64(v), 10))
case Float:
b.WriteString(formatFloat(float64(v)))
case String:
writeString(b, string(v))
case Bool:
if v {
b.WriteString("T")
} else {
b.WriteString("F")
}
case Symbol:
b.WriteString(string(v))
case Empty:
b.WriteString("()")
case *Pair:
writePair(b, v)
case Function:
switch {
case v.Builtin():
fmt.Fprintf(b, "#<builtin %s>", v.Name())
case v.Name() != "":
fmt.Fprintf(b, "#<lambda %s>", v.Name())
default:
b.WriteString("#<lambda>")
}
default:
panic(fmt.Sprintf("sexpr: unknown value type %T", v))
}
}
// writePair loops along the cdr chain and recurses only into cars, so stack
// depth follows nesting, not list length.
func writePair(b *strings.Builder, p *Pair) {
b.WriteByte('(')
write(b, p.Car)
rest := p.Cdr
for {
switch r := rest.(type) {
case *Pair:
b.WriteByte(' ')
write(b, r.Car)
rest = r.Cdr
continue
case Empty:
default:
b.WriteString(" . ")
write(b, r)
}
break
}
b.WriteByte(')')
}
// formatFloat guarantees a dot in the mantissa, because the reader's float
// grammar requires one: "1" would read back as an Int. Magnitudes outside
// [1e-6, 1e21) use an exponent, as JavaScript does (1e21 prints as
// "1.0e+21").
func formatFloat(f float64) string {
if math.IsNaN(f) || math.IsInf(f, 0) {
// Unreachable from the evaluator; must not print as a readable value.
return fmt.Sprintf("#<float %v>", f)
}
abs := math.Abs(f)
format := byte('f')
if abs != 0 && (abs < 1e-6 || abs >= 1e21) {
format = 'e'
}
s := strconv.FormatFloat(f, format, -1, 64)
mantissa, exponent, _ := strings.Cut(s, "e")
if !strings.Contains(mantissa, ".") {
mantissa += ".0"
}
if exponent != "" {
return mantissa + "e" + exponent
}
return mantissa
}
// writeString uses the reader's escapes: short forms for quote, backslash,
// newline and tab, \u{hex} for other control characters, and raw UTF-8 for
// everything else.
func writeString(b *strings.Builder, s string) {
b.WriteByte('"')
for _, r := range s {
switch {
case r == '"':
b.WriteString(`\"`)
case r == '\\':
b.WriteString(`\\`)
case r == '\n':
b.WriteString(`\n`)
case r == '\t':
b.WriteString(`\t`)
case r < 0x20 || r == 0x7f:
fmt.Fprintf(b, `\u{%x}`, r)
default:
b.WriteRune(r)
}
}
b.WriteByte('"')
}