// Use of this source code is governed by a BSD-style license that can be found // in the LICENSE file. package check import ( "fmt" "math/big" a "github.com/google/puffs/lang/ast" t "github.com/google/puffs/lang/token" ) func (q *checker) tcheckVars(block []*a.Node) error { for _, o := range block { q.errFilename, q.errLine = o.Raw().FilenameLine() switch o.Kind() { case a.KIf: for o := o.If(); o != nil; o = o.ElseIf() { if err := q.tcheckVars(o.BodyIfTrue()); err != nil { return err } if err := q.tcheckVars(o.BodyIfFalse()); err != nil { return err } } case a.KVar: o := o.Var() name := o.Name() if _, ok := q.f.LocalVars[name]; ok { return fmt.Errorf("check: duplicate var %q", name.String(q.tm)) } if err := q.tcheckTypeExpr(o.XType(), 0); err != nil { return err } q.f.LocalVars[name] = o.XType() case a.KWhile: if err := q.tcheckVars(o.While().Body()); err != nil { return err } } } return nil } func (q *checker) tcheckStatement(n *a.Node) error { q.errFilename, q.errLine = n.Raw().FilenameLine() switch n.Kind() { case a.KAssert: if err := q.tcheckAssert(n.Assert()); err != nil { return err } case a.KAssign: if err := q.tcheckAssign(n.Assign()); err != nil { return err } case a.KExpr: return q.tcheckExpr(n.Expr(), 0) case a.KIf: for n := n.If(); n != nil; n = n.ElseIf() { cond := n.Condition() if err := q.tcheckExpr(cond, 0); err != nil { return err } if !cond.MType().IsBool() { return fmt.Errorf("check: if condition %q, of type %q, does not have a boolean type", cond.String(q.tm), cond.MType().String(q.tm)) } for _, o := range n.BodyIfTrue() { if err := q.tcheckStatement(o); err != nil { return err } } for _, o := range n.BodyIfFalse() { if err := q.tcheckStatement(o); err != nil { return err } } } for n := n.If(); n != nil; n = n.ElseIf() { n.Node().SetTypeChecked() } return nil case a.KJump: n := n.Jump() jumpTarget := (*a.While)(nil) if id := n.Label(); id != 0 { for i := len(q.jumpTargets) - 1; i >= 0; i-- { if w := q.jumpTargets[i]; w.Label() == id { jumpTarget = w break } } } else if nj := len(q.jumpTargets); nj > 0 { jumpTarget = q.jumpTargets[nj-1] } if jumpTarget == nil { sepStr, labelStr := "", "" if id := n.Label(); id != 0 { sepStr, labelStr = ":", id.String(q.tm) } return fmt.Errorf("no matching while statement for %s%s%s", n.Keyword().String(q.tm), sepStr, labelStr) } if n.Keyword().Key() == t.KeyBreak { jumpTarget.SetHasBreak() } else { jumpTarget.SetHasContinue() } n.SetJumpTarget(jumpTarget) case a.KReturn: n := n.Return() if nk := n.Keyword(); nk != 0 { if s, ok := q.c.statuses[n.Message()]; !ok { return fmt.Errorf("check: no error or status with message %q", trimQuotes(n.Message().String(q.tm))) } else if sk := s.Status.Keyword(); nk != sk { return fmt.Errorf("check: return statement says %q but declaration says %q", nk.String(q.tm), sk.String(q.tm)) } } else if value := n.Value(); value != nil { if err := q.tcheckExpr(value, 0); err != nil { return err } // TODO: type-check that value is assignable to the return value. // This needs the context of what func we're in. } case a.KVar: n := n.Var() if !n.XType().Node().TypeChecked() { return fmt.Errorf("check: internal error: unchecked type expression %q", n.XType().String(q.tm)) } if value := n.Value(); value != nil { if err := q.tcheckExpr(value, 0); err != nil { return err } lTyp := n.XType() rTyp := value.MType() if (rTyp.IsIdeal() && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) { // No-op. } else { return fmt.Errorf("check: cannot assign %q of type %q to %q of type %q", value.String(q.tm), rTyp.String(q.tm), n.Name().String(q.tm), lTyp.String(q.tm)) } } else { // TODO: check that the default zero value is assignable to n.XType(). } case a.KWhile: n := n.While() cond := n.Condition() if err := q.tcheckExpr(cond, 0); err != nil { return err } if !cond.MType().IsBool() { return fmt.Errorf("check: for-loop condition %q, of type %q, does not have a boolean type", cond.String(q.tm), cond.MType().String(q.tm)) } for _, o := range n.Asserts() { if err := q.tcheckAssert(o.Assert()); err != nil { return err } o.SetTypeChecked() } q.jumpTargets = append(q.jumpTargets, n) defer func() { q.jumpTargets = q.jumpTargets[:len(q.jumpTargets)-1] }() for _, o := range n.Body() { if err := q.tcheckStatement(o); err != nil { return err } } default: return fmt.Errorf("check: unrecognized ast.Kind (%s) for tcheckStatement", n.Kind()) } n.SetTypeChecked() return nil } func (q *checker) tcheckAssert(n *a.Assert) error { cond := n.Condition() if err := q.tcheckExpr(cond, 0); err != nil { return err } if !cond.MType().IsBool() { return fmt.Errorf("check: assert condition %q, of type %q, does not have a boolean type", cond.String(q.tm), cond.MType().String(q.tm)) } for _, o := range n.Args() { if err := q.tcheckExpr(o.Arg().Value(), 0); err != nil { return err } o.SetTypeChecked() } // TODO: check that there are no side effects. return nil } func (q *checker) tcheckAssign(n *a.Assign) error { lhs := n.LHS() rhs := n.RHS() if err := q.tcheckExpr(lhs, 0); err != nil { return err } if err := q.tcheckExpr(rhs, 0); err != nil { return err } lTyp := lhs.MType() rTyp := rhs.MType() if n.Operator().Key() == t.KeyEq { if (rTyp.IsIdeal() && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) { return nil } return fmt.Errorf("check: cannot assign %q of type %q to %q of type %q", rhs.String(q.tm), rTyp.String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } if !lTyp.IsNumType() { return fmt.Errorf("check: assignment %q: assignee %q, of type %q, does not have numeric type", n.Operator().String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } switch n.Operator().Key() { case t.KeyShiftLEq, t.KeyShiftREq: if rTyp.IsNumType() { return nil } return fmt.Errorf("check: assignment %q: shift %q, of type %q, does not have numeric type", n.Operator().String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } if rTyp.IsIdeal() || lTyp.EqIgnoringRefinements(rTyp) { return nil } return fmt.Errorf("check: assignment %q: %q and %q, of types %q and %q, do not have compatible types", n.Operator().String(q.tm), lhs.String(q.tm), rhs.String(q.tm), lTyp.String(q.tm), rTyp.String(q.tm), ) } func (q *checker) tcheckArg(n *a.Arg, depth uint32) error { if err := q.tcheckExpr(n.Value(), depth); err != nil { return err } n.Node().SetTypeChecked() return nil } func (q *checker) tcheckExpr(n *a.Expr, depth uint32) error { if depth > a.MaxExprDepth { return fmt.Errorf("check: expression recursion depth too large") } depth++ switch n.ID0().Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) { case 0: if err := q.tcheckExprOther(n, depth); err != nil { return err } case t.FlagsUnaryOp: if err := q.tcheckExprUnaryOp(n, depth); err != nil { return err } case t.FlagsBinaryOp: if err := q.tcheckExprBinaryOp(n, depth); err != nil { return err } case t.FlagsAssociativeOp: if err := q.tcheckExprAssociativeOp(n, depth); err != nil { return err } default: return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExpr", n.ID0().Key()) } n.Node().SetTypeChecked() return nil } func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error { switch n.ID0().Key() { case 0: id1 := n.ID1() if id1.IsNumLiteral() { z := big.NewInt(0) s := id1.String(q.tm) if _, ok := z.SetString(s, 0); !ok { return fmt.Errorf("check: invalid numeric literal %q", s) } n.SetConstValue(z) n.SetMType(typeExprIdeal) return nil } else if id1.IsIdent() { if q.f.LocalVars != nil { if typ, ok := q.f.LocalVars[id1]; ok { n.SetMType(typ) return nil } } // TODO: look for (global) names (constants, funcs, structs). return fmt.Errorf("check: unrecognized identifier %q", id1.String(q.tm)) } switch id1.Key() { case t.KeyFalse: n.SetConstValue(zero) n.SetMType(typeExprBool) return nil case t.KeyTrue: n.SetConstValue(one) n.SetMType(typeExprBool) return nil case t.KeyUnderscore: // TODO. case t.KeyThis: // TODO. } case t.KeyOpenParen: // n is a function call. // TODO: delete this hack that only matches "in.src.read_u8?()" etc. if isInSrc(q.tm, n, t.KeyReadU8, 0) || isInSrc(q.tm, n, t.KeySkip32, 1) || isInDst(q.tm, n, t.KeyWrite, 1) || isInDst(q.tm, n, t.KeyWriteU8, 1) || isThisMethod(q.tm, n, "decode_header", 1) || isThisMethod(q.tm, n, "decode_lsd", 1) || isThisMethod(q.tm, n, "decode_extension", 1) || isThisMethod(q.tm, n, "decode_id", 2) { if err := q.tcheckExpr(n.LHS().Expr(), depth); err != nil { return err } for _, o := range n.Args() { if err := q.tcheckArg(o.Arg(), depth); err != nil { return err } } n.SetMType(typeExprPlaceholder) // HACK. return nil } // TODO: delete this hack that only matches "foo.low_bits(etc)". if isLowBits(q.tm, n) { foo := n.LHS().Expr().LHS().Expr() if err := q.tcheckExpr(foo, depth); err != nil { return err } n.LHS().SetTypeChecked() n.LHS().Expr().SetMType(typeExprPlaceholder) // HACK. for _, o := range n.Args() { if err := q.tcheckArg(o.Arg(), depth); err != nil { return err } } n.SetMType(foo.MType().Unrefined()) return nil } // TODO: delete this hack that only matches "foo.set_literal_width(etc)". if isSetLiteralWidth(q.tm, n) { foo := n.LHS().Expr().LHS().Expr() if err := q.tcheckExpr(foo, depth); err != nil { return err } n.LHS().SetTypeChecked() n.LHS().Expr().SetMType(typeExprPlaceholder) // HACK. for _, o := range n.Args() { if err := q.tcheckArg(o.Arg(), depth); err != nil { return err } } n.SetMType(typeExprPlaceholder) // HACK. return nil } // TODO: delete this hack that only matches "foo.decode(etc)". if isDecode(q.tm, n) { foo := n.LHS().Expr().LHS().Expr() if err := q.tcheckExpr(foo, depth); err != nil { return err } n.LHS().SetTypeChecked() n.LHS().Expr().SetMType(typeExprPlaceholder) // HACK. for _, o := range n.Args() { if err := q.tcheckArg(o.Arg(), depth); err != nil { return err } } n.SetMType(typeExprPlaceholder) // HACK. return nil } case t.KeyOpenBracket: // n is an index. lhs := n.LHS().Expr() if err := q.tcheckExpr(lhs, depth); err != nil { return err } rhs := n.RHS().Expr() if err := q.tcheckExpr(rhs, depth); err != nil { return err } lTyp := lhs.MType() if lTyp.Decorator().Key() != t.KeyOpenBracket { return fmt.Errorf("check: %s is an array-index expression but %s has type %s, not an array type", n.String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } rTyp := rhs.MType() if !rTyp.IsNumTypeOrIdeal() { return fmt.Errorf("check: %s is an array-index expression but %s has type %s, not a numeric type", n.String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } n.SetMType(lTyp.Inner()) return nil case t.KeyColon: // n is a slice. // TODO. case t.KeyDot: return q.tcheckDot(n, depth) case t.KeyLimit: lhs := n.LHS().Expr() if err := q.tcheckExpr(lhs, depth); err != nil { return err } if lhs.Impure() { return fmt.Errorf(`check: limit count %q is not pure`, lhs.String(q.tm)) } lTyp := lhs.MType() if !lTyp.IsIdeal() && !lTyp.EqIgnoringRefinements(typeExprU64) { return fmt.Errorf("check: limit count %q type %q not compatible with u64", lhs.String(q.tm), lTyp.String(q.tm)) } rhs := n.RHS().Expr() if err := q.tcheckExpr(rhs, depth); err != nil { return err } if rhs.Impure() { return fmt.Errorf("check: limit arg %q is not pure", rhs.String(q.tm)) } rTyp := rhs.MType() if rTyp.Decorator() != 0 || (rTyp.Name().Key() != t.KeyReader1 && rTyp.Name().Key() != t.KeyWriter1) { return fmt.Errorf(`check: limit arg %q type %q not "reader1" or "writer1"`, rhs.String(q.tm), rTyp.String(q.tm)) } n.SetMType(rTyp) return nil } return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExprOther", n.ID0().Key()) } func isInSrc(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool { if n.ID0().Key() != t.KeyOpenParen || !n.CallSuspendible() || len(n.Args()) != nArgs { return false } n = n.LHS().Expr() if n.ID0().Key() != t.KeyDot || n.ID1().Key() != methodName { return false } n = n.LHS().Expr() if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName("src") { return false } n = n.LHS().Expr() return n.ID0() == 0 && n.ID1().Key() == t.KeyIn } func isInDst(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool { // TODO: check that n.Args() is "(x:bar)". if n.ID0().Key() != t.KeyOpenParen || !n.CallSuspendible() || len(n.Args()) != nArgs { return false } n = n.LHS().Expr() if n.ID0().Key() != t.KeyDot || n.ID1().Key() != methodName { return false } n = n.LHS().Expr() if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName("dst") { return false } n = n.LHS().Expr() return n.ID0() == 0 && n.ID1().Key() == t.KeyIn } func isThisMethod(tm *t.Map, n *a.Expr, methodName string, nArgs int) bool { // TODO: check that n.Args() is "(src:in.src)". if n.ID0().Key() != t.KeyOpenParen || !n.CallSuspendible() || len(n.Args()) != nArgs { return false } n = n.LHS().Expr() if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName(methodName) { return false } n = n.LHS().Expr() return n.ID0() == 0 && n.ID1().Key() == t.KeyThis } func isLowBits(tm *t.Map, n *a.Expr) bool { // TODO: check that n.Args() is "(n:bar)". if n.ID0().Key() != t.KeyOpenParen || n.CallImpure() || len(n.Args()) != 1 { return false } n = n.LHS().Expr() return n.ID0().Key() == t.KeyDot && n.ID1().Key() == t.KeyLowBits } func isSetLiteralWidth(tm *t.Map, n *a.Expr) bool { // TODO: check that n.Args() is "(lw:bar)". if n.ID0().Key() != t.KeyOpenParen || n.CallImpure() || len(n.Args()) != 1 { return false } n = n.LHS().Expr() return n.ID0().Key() == t.KeyDot && n.ID1() == tm.ByName("set_literal_width") } func isDecode(tm *t.Map, n *a.Expr) bool { // TODO: check that n.Args() is "(dst:bar, src:baz)". if n.ID0().Key() != t.KeyOpenParen || !n.CallSuspendible() || len(n.Args()) != 2 { return false } n = n.LHS().Expr() return n.ID0().Key() == t.KeyDot && n.ID1() == tm.ByName("decode") } func (q *checker) tcheckDot(n *a.Expr, depth uint32) error { lhs := n.LHS().Expr() if err := q.tcheckExpr(lhs, depth); err != nil { return err } lTyp := lhs.MType() for ; lTyp.Decorator().Key() == t.KeyPtr; lTyp = lTyp.Inner() { } if lTyp.Decorator() != 0 { // TODO. return fmt.Errorf("check: unsupported decorator for tcheckDot") } s := (*a.Struct)(nil) if q.f.Func != nil { switch name := lTyp.Name(); name.Key() { case t.KeyIn: s = q.f.Func.In() case t.KeyOut: s = q.f.Func.Out() case t.KeyReader1, t.KeyWriter1: // TODO: remove this hack and be more principled about the built-in // buf1, reader1, writer1 types. // // Another hack is using typeExprPlaceholder until a TypeExpr can // represent function types. n.SetMType(typeExprPlaceholder) return nil default: s = q.c.structs[name].Struct } } if s == nil { return fmt.Errorf("check: no struct type %q found for expression %q", lTyp.Name().String(q.tm), lhs.String(q.tm)) } for _, field := range s.Fields() { f := field.Field() if f.Name() == n.ID1() { n.SetMType(f.XType()) return nil } } if f := q.c.funcs[t.QID{lTyp.Name(), n.ID1()}]; f.Func != nil { n.SetMType(typeExprPlaceholder) // HACK. return nil } return fmt.Errorf("check: no field or method named %q found in struct type %q for expression %q", n.ID1().String(q.tm), lTyp.Name().String(q.tm), n.String(q.tm)) } func (q *checker) tcheckExprUnaryOp(n *a.Expr, depth uint32) error { rhs := n.RHS().Expr() if err := q.tcheckExpr(rhs, depth); err != nil { return err } rTyp := rhs.MType() switch n.ID0().Key() { case t.KeyXUnaryPlus, t.KeyXUnaryMinus: if !rTyp.IsNumTypeOrIdeal() { return fmt.Errorf("check: unary %q: %q, of type %q, does not have a numeric type", n.ID0().AmbiguousForm().String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } if cv := rhs.ConstValue(); cv != nil { if n.ID0().Key() == t.KeyXUnaryMinus { cv = neg(cv) } n.SetConstValue(cv) } n.SetMType(rTyp.Unrefined()) return nil case t.KeyXUnaryNot: if !rTyp.IsBool() { return fmt.Errorf("check: unary %q: %q, of type %q, does not have a boolean type", n.ID0().AmbiguousForm().String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } if cv := rhs.ConstValue(); cv != nil { n.SetConstValue(btoi(cv.Cmp(zero) == 0)) } n.SetMType(typeExprBool) return nil } return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExprUnaryOp", n.ID0().Key()) } func (q *checker) tcheckExprBinaryOp(n *a.Expr, depth uint32) error { lhs := n.LHS().Expr() if err := q.tcheckExpr(lhs, depth); err != nil { return err } lTyp := lhs.MType() op := n.ID0() if op.Key() == t.KeyXBinaryAs { rhs := n.RHS().TypeExpr() if err := q.tcheckTypeExpr(rhs, 0); err != nil { return err } if lTyp.IsNumTypeOrIdeal() && rhs.IsNumType() { n.SetMType(rhs) return nil } return fmt.Errorf("check: cannot convert expression %q, of type %q, as type %q", lhs.String(q.tm), lTyp.String(q.tm), rhs.String(q.tm)) } rhs := n.RHS().Expr() if err := q.tcheckExpr(rhs, depth); err != nil { return err } rTyp := rhs.MType() switch op.Key() { default: if !lTyp.IsNumTypeOrIdeal() { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type", op.AmbiguousForm().String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } if !rTyp.IsNumTypeOrIdeal() { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type", op.AmbiguousForm().String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } case t.KeyXBinaryNotEq, t.KeyXBinaryEqEq: // No-op. case t.KeyXBinaryAnd, t.KeyXBinaryOr: if !lTyp.IsBool() { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a boolean type", op.AmbiguousForm().String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } if !rTyp.IsBool() { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a boolean type", op.AmbiguousForm().String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } } switch op.Key() { default: if !lTyp.EqIgnoringRefinements(rTyp) && !lTyp.IsIdeal() && !rTyp.IsIdeal() { return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q, do not have compatible types", op.AmbiguousForm().String(q.tm), lhs.String(q.tm), rhs.String(q.tm), lTyp.String(q.tm), rTyp.String(q.tm), ) } case t.KeyXBinaryShiftL, t.KeyXBinaryShiftR: if lTyp.IsIdeal() && !rTyp.IsIdeal() { return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q; "+ "cannot shift an ideal number by a non-ideal number", op.AmbiguousForm().String(q.tm), lhs.String(q.tm), rhs.String(q.tm), lTyp.String(q.tm), rTyp.String(q.tm), ) } } if l, r := lhs.ConstValue(), rhs.ConstValue(); l != nil && r != nil { if err := q.setConstValueBinaryOp(n, l, r); err != nil { return err } } if comparisonOps[0xFF&op.Key()] { n.SetMType(typeExprBool) } else if !lTyp.IsIdeal() { n.SetMType(lTyp.Unrefined()) } else { n.SetMType(rTyp.Unrefined()) } return nil } func (q *checker) setConstValueBinaryOp(n *a.Expr, l *big.Int, r *big.Int) error { switch n.ID0().Key() { case t.KeyXBinaryPlus: n.SetConstValue(big.NewInt(0).Add(l, r)) case t.KeyXBinaryMinus: n.SetConstValue(big.NewInt(0).Sub(l, r)) case t.KeyXBinaryStar: n.SetConstValue(big.NewInt(0).Mul(l, r)) case t.KeyXBinarySlash: if r.Cmp(zero) == 0 { return fmt.Errorf("check: division by zero in const expression %q", n.String(q.tm)) } // TODO: decide on Euclidean division vs other definitions. See "go doc // math/big int.divmod" for details. n.SetConstValue(big.NewInt(0).Div(l, r)) case t.KeyXBinaryShiftL: if r.Cmp(zero) < 0 || r.Cmp(ffff) > 0 { return fmt.Errorf("check: shift %q out of range in const expression %q", n.RHS().Expr().String(q.tm), n.String(q.tm)) } n.SetConstValue(big.NewInt(0).Lsh(l, uint(r.Uint64()))) case t.KeyXBinaryShiftR: if r.Cmp(zero) < 0 || r.Cmp(ffff) > 0 { return fmt.Errorf("check: shift %q out of range in const expression %q", n.RHS().Expr().String(q.tm), n.String(q.tm)) } n.SetConstValue(big.NewInt(0).Rsh(l, uint(r.Uint64()))) case t.KeyXBinaryAmp: n.SetConstValue(big.NewInt(0).And(l, r)) case t.KeyXBinaryAmpHat: n.SetConstValue(big.NewInt(0).AndNot(l, r)) case t.KeyXBinaryPipe: n.SetConstValue(big.NewInt(0).Or(l, r)) case t.KeyXBinaryHat: n.SetConstValue(big.NewInt(0).Xor(l, r)) case t.KeyXBinaryNotEq: n.SetConstValue(btoi(l.Cmp(r) != 0)) case t.KeyXBinaryLessThan: n.SetConstValue(btoi(l.Cmp(r) < 0)) case t.KeyXBinaryLessEq: n.SetConstValue(btoi(l.Cmp(r) <= 0)) case t.KeyXBinaryEqEq: n.SetConstValue(btoi(l.Cmp(r) == 0)) case t.KeyXBinaryGreaterEq: n.SetConstValue(btoi(l.Cmp(r) >= 0)) case t.KeyXBinaryGreaterThan: n.SetConstValue(btoi(l.Cmp(r) > 0)) case t.KeyXBinaryAnd: n.SetConstValue(btoi((l.Cmp(zero) != 0) && (r.Cmp(zero) != 0))) case t.KeyXBinaryOr: n.SetConstValue(btoi((l.Cmp(zero) != 0) || (r.Cmp(zero) != 0))) } return nil } func (q *checker) tcheckExprAssociativeOp(n *a.Expr, depth uint32) error { switch n.ID0().Key() { // TODO. case t.KeyXAssociativePlus: case t.KeyXAssociativeStar: case t.KeyXAssociativeAmp: case t.KeyXAssociativePipe: case t.KeyXAssociativeHat: case t.KeyXAssociativeAnd, t.KeyXAssociativeOr: for _, o := range n.Args() { o := o.Expr() if err := q.tcheckExpr(o, depth); err != nil { return err } if !o.MType().IsBool() { return fmt.Errorf("check: associative %q: %q, of type %q, does not have a boolean type", n.ID0().AmbiguousForm().String(q.tm), o.String(q.tm), o.MType().String(q.tm)) } } n.SetMType(typeExprBool) return nil } return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExprAssociativeOp", n.ID0().Key()) } func (q *checker) tcheckTypeExpr(n *a.TypeExpr, depth uint32) error { if depth > a.MaxTypeExprDepth { return fmt.Errorf("check: type expression recursion depth too large") } depth++ swtch: switch n.Decorator().Key() { case 0: if n.Name().IsNumType() { for _, b := range n.Bounds() { if b == nil { continue } if err := q.tcheckExpr(b, 0); err != nil { return err } if b.ConstValue() == nil { return fmt.Errorf("check: %q is not constant", b.String(q.tm)) } } break } if n.Min() != nil || n.Max() != nil { // TODO: reject. You can only refine numeric types. } if name := n.Name().Key(); name == t.KeyBool || name == t.KeyReader1 || name == t.KeyWriter1 { break } for _, s := range q.c.structs { if s.ID == n.Name() { break swtch } } return fmt.Errorf("check: %q is not a type", n.Name().String(q.tm)) case t.KeyPtr: if err := q.tcheckTypeExpr(n.Inner(), depth); err != nil { return err } case t.KeyOpenBracket: aLen := n.ArrayLength() if err := q.tcheckExpr(aLen, 0); err != nil { return err } if aLen.ConstValue() == nil { return fmt.Errorf("check: %q is not constant", aLen.String(q.tm)) } if err := q.tcheckTypeExpr(n.Inner(), depth); err != nil { return err } default: return fmt.Errorf("check: unrecognized node for tcheckTypeExpr") } n.Node().SetTypeChecked() return nil } var comparisonOps = [256]bool{ t.KeyXBinaryNotEq: true, t.KeyXBinaryLessThan: true, t.KeyXBinaryLessEq: true, t.KeyXBinaryEqEq: true, t.KeyXBinaryGreaterEq: true, t.KeyXBinaryGreaterThan: true, }