government / sexpr / print.go

@ 912e56eddc8c1e6341ea2c0b844e37334a96050f | 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:
		if name := v.Name(); name != "" {
			fmt.Fprintf(b, "#<builtin %s>", name)
		} else {
			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('"')
}