Check a typed column's value, not its text: one literal, value call, calc or read, bounded by its arguments
Tests / vet + fmt + tests (pull_request) Successful in 59s
Tests / vet + fmt + tests (pull_request) Successful in 59s
This commit is contained in:
@@ -6,7 +6,6 @@ import (
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// calcNode is a parsed expression node. It evaluates over the operand values expand
|
||||
@@ -200,6 +199,14 @@ func calcPrep(args []string) callFn {
|
||||
}
|
||||
}
|
||||
|
||||
// calcDecimals is a calc's decimals count, or -1 for the shortest form.
|
||||
func calcDecimals(args []string) int {
|
||||
if len(args) == 2 {
|
||||
return atoi(args[1])
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// indexVars replaces each operand name with its position in the values expand reads.
|
||||
// Both sides take that order from calcVars, so they cannot drift.
|
||||
func indexVars(n calcNode, at map[string]int) calcNode {
|
||||
@@ -384,256 +391,3 @@ func contains(bs []byte, b byte) bool {
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// calcDecimals is a calc's decimals count, or -1 for the shortest form.
|
||||
func calcDecimals(args []string) int {
|
||||
if len(args) == 2 {
|
||||
return atoi(args[1])
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// calcLimit is the largest magnitude a proof accepts as finite, far enough below
|
||||
// math.MaxFloat64 that rounding in the bounds cannot hide an overflow.
|
||||
const calcLimit = 1e300
|
||||
|
||||
// maxOperandLen is the longest operand text a proof bounds by its length, so that
|
||||
// bound, 10^maxOperandLen, stays within calcLimit.
|
||||
const maxOperandLen = 300
|
||||
|
||||
// calcBound is what a proof knows of every value a calc can take: it lies in [lo, hi],
|
||||
// is at least nonZero from zero unless nonZero is 0, and is whole when integral.
|
||||
type calcBound struct {
|
||||
lo, hi, nonZero float64
|
||||
integral bool
|
||||
}
|
||||
|
||||
func magnitude(b calcBound) float64 { return math.Max(math.Abs(b.lo), math.Abs(b.hi)) }
|
||||
|
||||
// doubt is why a proof could not show a calc finite, and the render that shows it.
|
||||
type doubt struct{ render, why string }
|
||||
|
||||
type bounded struct {
|
||||
b calcBound
|
||||
d *doubt
|
||||
}
|
||||
|
||||
// calcProof bounds a typed column's calcs from their operands' renders, to show each
|
||||
// prints a number rather than NaN or Inf.
|
||||
type calcProof struct {
|
||||
decimal *textLanguage
|
||||
operands map[node]bounded
|
||||
lengths map[node]int
|
||||
}
|
||||
|
||||
func newCalcProof() *calcProof {
|
||||
p := &calcProof{operands: map[node]bounded{}, lengths: map[node]int{}}
|
||||
p.decimal = newTextLanguage(decimalGrammar, p)
|
||||
return p
|
||||
}
|
||||
|
||||
// call bounds one calc token of t.
|
||||
func (p *calcProof) call(t *template, args []string) (calcBound, *doubt) {
|
||||
expr, err := parseCalc(args[0])
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("fejkdata: calc(%q) reached a proof unparsed: %v", args[0], err))
|
||||
}
|
||||
b, d := p.expr(expr, t.fields)
|
||||
if d != nil {
|
||||
return b, &doubt{d.render, fmt.Sprintf("{calc(%s)}: %s", strings.Join(args, ", "), d.why)}
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
func (p *calcProof) expr(n calcNode, fields map[string]node) (calcBound, *doubt) {
|
||||
switch n := n.(type) {
|
||||
case calcNum:
|
||||
v := float64(n)
|
||||
return calcBound{v, v, v, v == math.Trunc(v)}, nil
|
||||
case calcVar:
|
||||
return p.operand(string(n), fields[string(n)])
|
||||
case calcNeg:
|
||||
b, d := p.expr(n.x, fields)
|
||||
return calcBound{-b.hi, -b.lo, b.nonZero, b.integral}, d
|
||||
case calcBin:
|
||||
l, d := p.expr(n.l, fields)
|
||||
if d != nil {
|
||||
return l, d
|
||||
}
|
||||
r, d := p.expr(n.r, fields)
|
||||
if d != nil {
|
||||
return r, d
|
||||
}
|
||||
return combine(n, l, r)
|
||||
}
|
||||
panic(fmt.Sprintf("fejkdata: calc node %T has no bound", n))
|
||||
}
|
||||
|
||||
// combine bounds one operation from the bounds of its sides.
|
||||
func combine(n calcBin, l, r calcBound) (calcBound, *doubt) {
|
||||
b := calcBound{integral: l.integral && r.integral}
|
||||
switch n.op {
|
||||
case '+':
|
||||
b.lo, b.hi = l.lo+r.lo, l.hi+r.hi
|
||||
case '-':
|
||||
b.lo, b.hi = l.lo-r.hi, l.hi-r.lo
|
||||
case '*':
|
||||
b.lo = min(l.lo*r.lo, l.lo*r.hi, l.hi*r.lo, l.hi*r.hi)
|
||||
b.hi = max(l.lo*r.lo, l.lo*r.hi, l.hi*r.lo, l.hi*r.hi)
|
||||
b.nonZero = l.nonZero * r.nonZero
|
||||
default:
|
||||
if r.nonZero == 0 {
|
||||
return b, &doubt{"+Inf", fmt.Sprintf("divides by %s, which can be zero", calcText(n.r))}
|
||||
}
|
||||
m := magnitude(l) / r.nonZero
|
||||
b = calcBound{lo: -m, hi: m, nonZero: l.nonZero / magnitude(r)}
|
||||
}
|
||||
if b.lo > 0 || b.hi < 0 {
|
||||
b.nonZero = math.Max(b.nonZero, math.Min(math.Abs(b.lo), math.Abs(b.hi)))
|
||||
}
|
||||
if !(magnitude(b) <= calcLimit) {
|
||||
return b, &doubt{"+Inf", calcText(n) + " can overflow"}
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
// operand bounds a calc operand, once per node.
|
||||
func (p *calcProof) operand(name string, n node) (calcBound, *doubt) {
|
||||
if seen, done := p.operands[n]; done {
|
||||
return seen.b, seen.d
|
||||
}
|
||||
b, d := p.measure(name, n)
|
||||
p.operands[n] = bounded{b, d}
|
||||
return b, d
|
||||
}
|
||||
|
||||
// measure bounds an operand through the calc it renders when that is all it renders,
|
||||
// and otherwise from its text: a plain decimal of at most maxOperandLen bytes.
|
||||
func (p *calcProof) measure(name string, n node) (calcBound, *doubt) {
|
||||
if t, ok := n.(*template); ok {
|
||||
if args, isCalc := soleCalc(t); isCalc {
|
||||
b, d := p.call(t, args)
|
||||
return rounded(b, calcDecimals(args)), d
|
||||
}
|
||||
}
|
||||
text := p.decimal.node(n, nil)
|
||||
if w, escapes := text.escape(decimalAccept); escapes {
|
||||
why := fmt.Sprintf("operand %q can render %s, which is not a plain decimal", name, w)
|
||||
if w.why != "" {
|
||||
why += ": " + w.why
|
||||
}
|
||||
return calcBound{}, &doubt{"NaN", why}
|
||||
}
|
||||
size := p.length(n)
|
||||
if size > maxOperandLen {
|
||||
return calcBound{}, &doubt{"NaN", fmt.Sprintf("operand %q can render more than %d bytes, too many to bound", name, maxOperandLen)}
|
||||
}
|
||||
ends, m := text.to[1], math.Pow(10, float64(size))
|
||||
b := calcBound{hi: m, nonZero: 1 / m, integral: ends&decimalFractional == 0}
|
||||
if ends&decimalNegative != 0 {
|
||||
b.lo = -m
|
||||
}
|
||||
if ends&decimalZero != 0 {
|
||||
b.nonZero = 0
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
// soleCalc reports a template that renders one calc and nothing else, with its args.
|
||||
func soleCalc(t *template) ([]string, bool) {
|
||||
if t.repeat != 1 || len(t.ops) != 1 || t.ops[0].kind != 'b' {
|
||||
return nil, false
|
||||
}
|
||||
name, args, _ := funcCall(t.format[1 : len(t.format)-1])
|
||||
return args, name == "calc"
|
||||
}
|
||||
|
||||
// rounded is b once printed to dp decimals, which moves a value by up to half a unit.
|
||||
func rounded(b calcBound, dp int) calcBound {
|
||||
if dp < 0 {
|
||||
return b
|
||||
}
|
||||
half := math.Pow(10, -float64(dp)) / 2
|
||||
return calcBound{b.lo - half, b.hi + half, math.Max(0, b.nonZero-half), b.integral || dp == 0}
|
||||
}
|
||||
|
||||
// length is the most bytes a render of n can take, anything past maxOperandLen
|
||||
// reported as maxOperandLen+1.
|
||||
func (p *calcProof) length(n node) int {
|
||||
if size, done := p.lengths[n]; done {
|
||||
return size
|
||||
}
|
||||
size := 0
|
||||
switch n := n.(type) {
|
||||
case *choice:
|
||||
for _, it := range n.items {
|
||||
size = max(size, p.length(it))
|
||||
}
|
||||
case *template:
|
||||
size = p.formatLength(n)*n.repeat + len(n.separator)*(n.repeat-1)
|
||||
}
|
||||
size = min(size, maxOperandLen+1)
|
||||
p.lengths[n] = size
|
||||
return size
|
||||
}
|
||||
|
||||
func (p *calcProof) formatLength(t *template) int {
|
||||
size := 0
|
||||
_ = eachToken(t.format, func(tok ftoken) error {
|
||||
if tok.kind == 'l' {
|
||||
size += utf8.RuneLen(tok.r)
|
||||
} else {
|
||||
size += p.tokenLength(t, tok.body)
|
||||
}
|
||||
size = min(size, maxOperandLen+1)
|
||||
return nil
|
||||
})
|
||||
return size
|
||||
}
|
||||
|
||||
// tokenLength is the most bytes one token can print. A transform never lengthens a
|
||||
// render that reads as a decimal: it maps each non-ASCII rune, two bytes or more, to at
|
||||
// most two ASCII letters.
|
||||
func (p *calcProof) tokenLength(t *template, body string) int {
|
||||
name, args, isFunc := funcCall(body)
|
||||
var arms []arm
|
||||
switch _, isTransform := transforms[name]; {
|
||||
case !isFunc:
|
||||
arms = splitArms(body, t.refs)
|
||||
case isTransform:
|
||||
leaf, _, _ := unwrapTransform(args[0])
|
||||
arms = []arm{splitArm(leaf, t.refs)}
|
||||
case name == "calc":
|
||||
b, d := p.call(t, args)
|
||||
if d != nil {
|
||||
return len(d.render)
|
||||
}
|
||||
return shapeLength(printedFloat(b.lo, b.hi, calcDecimals(args), b.integral))
|
||||
default:
|
||||
return shapeLength(builtins[name].emits(args))
|
||||
}
|
||||
size := 0
|
||||
for _, a := range arms {
|
||||
for _, leaf := range pathLeaves(t.fields[a.key], a.tail) {
|
||||
size = max(size, p.length(leaf))
|
||||
}
|
||||
}
|
||||
return size
|
||||
}
|
||||
|
||||
// shapeLength is the most bytes a shape can emit, anything past maxOperandLen reported
|
||||
// as maxOperandLen+1.
|
||||
func shapeLength(s textShape) int {
|
||||
longest := 0
|
||||
for _, alt := range s {
|
||||
size := 0
|
||||
for _, run := range alt {
|
||||
if run.max < 0 {
|
||||
return maxOperandLen + 1
|
||||
}
|
||||
size += run.max
|
||||
}
|
||||
longest = max(longest, size)
|
||||
}
|
||||
return min(longest, maxOperandLen+1)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user