diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 49c102b2..26cd930d 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -378,9 +378,11 @@ const MaxTypeExprDepth = 63 // example, the MHS for "u32[:4096]" is nil. type TypeExpr Node -func (n *TypeExpr) Node() *Node { return (*Node)(n) } -func (n *TypeExpr) IsNumType() bool { return n.id0 == 0 && n.id1.IsNumType() } -func (n *TypeExpr) IsRefined() bool { return n.id0 != t.IDOpenBracket && (n.lhs != nil || n.mhs != nil) } +func (n *TypeExpr) Node() *Node { return (*Node)(n) } +func (n *TypeExpr) IsNumType() bool { return n.id0 == 0 && n.id1.IsNumType() } +func (n *TypeExpr) IsRefined() bool { + return t.Key(n.id0>>t.KeyShift) != t.KeyOpenBracket && (n.lhs != nil || n.mhs != nil) +} func (n *TypeExpr) PackageOrDecorator() t.ID { return n.id0 } func (n *TypeExpr) Name() t.ID { return n.id1 } func (n *TypeExpr) ArrayLength() *Expr { return n.lhs.Expr() } diff --git a/lang/ast/eq.go b/lang/ast/eq.go index 4344f0f9..0f0e4cab 100644 --- a/lang/ast/eq.go +++ b/lang/ast/eq.go @@ -34,7 +34,7 @@ func (n *Expr) Eq(o *Expr) bool { return false } - if n.id0 == t.IDXBinaryAs { + if n.id0.Key() == t.KeyXBinaryAs { if !n.rhs.TypeExpr().Eq(o.rhs.TypeExpr()) { return false } @@ -75,7 +75,7 @@ func (n *TypeExpr) eq(o *TypeExpr, ignoreRefinements bool) bool { if n.id0 != o.id0 || n.id1 != o.id1 { return false } - if n.id0 == t.IDOpenBracket || !ignoreRefinements { + if n.id0.Key() == t.KeyOpenBracket || !ignoreRefinements { if !n.lhs.Expr().Eq(o.lhs.Expr()) || !n.mhs.Expr().Eq(o.mhs.Expr()) { return false } diff --git a/lang/ast/string.go b/lang/ast/string.go index 18a3dc4b..d52fbf51 100644 --- a/lang/ast/string.go +++ b/lang/ast/string.go @@ -27,11 +27,11 @@ func (n *Expr) appendString(buf []byte, m *t.IDMap, parenthesize bool, depth uin if n != nil { switch n.id0.Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) { case 0: - switch n.id0 { + switch n.id0.Key() { case 0: buf = append(buf, m.ByID(n.id1)...) - case t.IDOpenParen: + case t.KeyOpenParen: buf = n.lhs.Expr().appendString(buf, m, true, depth) if n.flags&FlagsSuspendible != 0 { buf = append(buf, '?') @@ -45,13 +45,13 @@ func (n *Expr) appendString(buf []byte, m *t.IDMap, parenthesize bool, depth uin } buf = append(buf, ')') - case t.IDOpenBracket: + case t.KeyOpenBracket: buf = n.lhs.Expr().appendString(buf, m, true, depth) buf = append(buf, '[') buf = n.rhs.Expr().appendString(buf, m, false, depth) buf = append(buf, ']') - case t.IDColon: + case t.KeyColon: buf = n.lhs.Expr().appendString(buf, m, true, depth) buf = append(buf, '[') buf = n.mhs.Expr().appendString(buf, m, false, depth) @@ -59,7 +59,7 @@ func (n *Expr) appendString(buf []byte, m *t.IDMap, parenthesize bool, depth uin buf = n.rhs.Expr().appendString(buf, m, false, depth) buf = append(buf, ']') - case t.IDDot: + case t.KeyDot: buf = n.lhs.Expr().appendString(buf, m, true, depth) buf = append(buf, '.') buf = append(buf, m.ByID(n.id1)...) @@ -75,7 +75,7 @@ func (n *Expr) appendString(buf []byte, m *t.IDMap, parenthesize bool, depth uin } buf = n.lhs.Expr().appendString(buf, m, true, depth) buf = append(buf, opStrings[0xFF&n.id0.Key()]...) - if n.id0 == t.IDXBinaryAs { + if n.id0.Key() == t.KeyXBinaryAs { buf = append(buf, n.rhs.TypeExpr().String(m)...) } else { buf = n.rhs.Expr().appendString(buf, m, true, depth) @@ -105,37 +105,37 @@ func (n *Expr) appendString(buf []byte, m *t.IDMap, parenthesize bool, depth uin } var opStrings = [256]string{ - t.IDXUnaryPlus >> t.KeyShift: "+", - t.IDXUnaryMinus >> t.KeyShift: "-", - t.IDXUnaryNot >> t.KeyShift: "not ", + t.KeyXUnaryPlus: "+", + t.KeyXUnaryMinus: "-", + t.KeyXUnaryNot: "not ", - t.IDXBinaryPlus >> t.KeyShift: " + ", - t.IDXBinaryMinus >> t.KeyShift: " - ", - t.IDXBinaryStar >> t.KeyShift: " * ", - t.IDXBinarySlash >> t.KeyShift: " / ", - t.IDXBinaryShiftL >> t.KeyShift: " << ", - t.IDXBinaryShiftR >> t.KeyShift: " >> ", - t.IDXBinaryAmp >> t.KeyShift: " & ", - t.IDXBinaryAmpHat >> t.KeyShift: " &^ ", - t.IDXBinaryPipe >> t.KeyShift: " | ", - t.IDXBinaryHat >> t.KeyShift: " ^ ", - t.IDXBinaryNotEq >> t.KeyShift: " != ", - t.IDXBinaryLessThan >> t.KeyShift: " < ", - t.IDXBinaryLessEq >> t.KeyShift: " <= ", - t.IDXBinaryEqEq >> t.KeyShift: " == ", - t.IDXBinaryGreaterEq >> t.KeyShift: " >= ", - t.IDXBinaryGreaterThan >> t.KeyShift: " > ", - t.IDXBinaryAnd >> t.KeyShift: " and ", - t.IDXBinaryOr >> t.KeyShift: " or ", - t.IDXBinaryAs >> t.KeyShift: " as ", + t.KeyXBinaryPlus: " + ", + t.KeyXBinaryMinus: " - ", + t.KeyXBinaryStar: " * ", + t.KeyXBinarySlash: " / ", + t.KeyXBinaryShiftL: " << ", + t.KeyXBinaryShiftR: " >> ", + t.KeyXBinaryAmp: " & ", + t.KeyXBinaryAmpHat: " &^ ", + t.KeyXBinaryPipe: " | ", + t.KeyXBinaryHat: " ^ ", + t.KeyXBinaryNotEq: " != ", + t.KeyXBinaryLessThan: " < ", + t.KeyXBinaryLessEq: " <= ", + t.KeyXBinaryEqEq: " == ", + t.KeyXBinaryGreaterEq: " >= ", + t.KeyXBinaryGreaterThan: " > ", + t.KeyXBinaryAnd: " and ", + t.KeyXBinaryOr: " or ", + t.KeyXBinaryAs: " as ", - t.IDXAssociativePlus >> t.KeyShift: " + ", - t.IDXAssociativeStar >> t.KeyShift: " * ", - t.IDXAssociativeAmp >> t.KeyShift: " & ", - t.IDXAssociativePipe >> t.KeyShift: " | ", - t.IDXAssociativeHat >> t.KeyShift: " ^ ", - t.IDXAssociativeAnd >> t.KeyShift: " and ", - t.IDXAssociativeOr >> t.KeyShift: " or ", + t.KeyXAssociativePlus: " + ", + t.KeyXAssociativeStar: " * ", + t.KeyXAssociativeAmp: " & ", + t.KeyXAssociativePipe: " | ", + t.KeyXAssociativeHat: " ^ ", + t.KeyXAssociativeAnd: " and ", + t.KeyXAssociativeOr: " or ", } // String returns a string form of n. @@ -158,13 +158,13 @@ func (n *TypeExpr) appendString(buf []byte, m *t.IDMap, depth uint32) []byte { return append(buf, "!invalid_type!"...) } - switch n.PackageOrDecorator() { + switch n.PackageOrDecorator().Key() { case 0: buf = append(buf, m.ByID(n.Name())...) - case t.IDPtr: + case t.KeyPtr: buf = append(buf, "ptr "...) return n.Inner().appendString(buf, m, depth) - case t.IDOpenBracket: + case t.KeyOpenBracket: buf = append(buf, '[') buf = n.ArrayLength().appendString(buf, m, false, 0) buf = append(buf, "] "...) diff --git a/lang/check/bounds.go b/lang/check/bounds.go index c52550d6..ce1d9c8a 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -12,15 +12,15 @@ import ( ) var numTypeBounds = [256][2]*big.Int{ - t.IDI8 >> t.KeyShift: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, - t.IDI16 >> t.KeyShift: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, - t.IDI32 >> t.KeyShift: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, - t.IDI64 >> t.KeyShift: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, - t.IDU8 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, - t.IDU16 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, - t.IDU32 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, - t.IDU64 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, - t.IDUsize >> t.KeyShift: {zero, zero}, + t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)}, + t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)}, + t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)}, + t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)}, + t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)}, + t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)}, + t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)}, + t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)}, + t.KeyUsize: {zero, zero}, } var ( @@ -70,15 +70,15 @@ func (c *typeChecker) bcheckStatement(n *a.Node) error { } func (c *typeChecker) bcheckAssignment(lTyp *a.TypeExpr, rhs *a.Expr) error { - switch lTyp.PackageOrDecorator() { - case t.IDPtr: + switch lTyp.PackageOrDecorator().Key() { + case t.KeyPtr: // TODO: handle. return nil - case t.IDOpenBracket: + case t.KeyOpenBracket: // TODO: handle. return nil } - if lTyp.Name() == t.IDBool { + if lTyp.Name().Key() == t.KeyBool { return nil } @@ -145,27 +145,27 @@ func (c *typeChecker) bcheckExprBinaryOp(n *a.Expr, depth uint32) (*big.Int, *bi return nil, nil, err } - switch n.ID0() { - case t.IDXBinaryPlus: + switch n.ID0().Key() { + case t.KeyXBinaryPlus: return big.NewInt(0).Add(l0, r0), big.NewInt(0).Add(l1, r1), nil - case t.IDXBinaryMinus: - case t.IDXBinaryStar: - case t.IDXBinarySlash: - case t.IDXBinaryShiftL: - case t.IDXBinaryShiftR: - case t.IDXBinaryAmp: - case t.IDXBinaryAmpHat: - case t.IDXBinaryPipe: - case t.IDXBinaryHat: - case t.IDXBinaryNotEq: - case t.IDXBinaryLessThan: - case t.IDXBinaryLessEq: - case t.IDXBinaryEqEq: - case t.IDXBinaryGreaterEq: - case t.IDXBinaryGreaterThan: - case t.IDXBinaryAnd: - case t.IDXBinaryOr: - case t.IDXBinaryAs: + case t.KeyXBinaryMinus: + case t.KeyXBinaryStar: + case t.KeyXBinarySlash: + case t.KeyXBinaryShiftL: + case t.KeyXBinaryShiftR: + case t.KeyXBinaryAmp: + case t.KeyXBinaryAmpHat: + case t.KeyXBinaryPipe: + case t.KeyXBinaryHat: + case t.KeyXBinaryNotEq: + case t.KeyXBinaryLessThan: + case t.KeyXBinaryLessEq: + case t.KeyXBinaryEqEq: + case t.KeyXBinaryGreaterEq: + case t.KeyXBinaryGreaterThan: + case t.KeyXBinaryAnd: + case t.KeyXBinaryOr: + case t.KeyXBinaryAs: } return nil, nil, fmt.Errorf("check: unrecognized token.Key (0x%X) for bcheckExprBinaryOp", n.ID0().Key()) } diff --git a/lang/check/type.go b/lang/check/type.go index c01f5647..3048b410 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -162,7 +162,7 @@ func (c *typeChecker) checkAssign(n *a.Assign) error { lTyp := lhs.MType() rTyp := rhs.MType() - if n.Operator() == t.IDEq { + if n.Operator().Key() == t.KeyEq { if (rTyp == TypeExprIdealNumber && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) { return nil } @@ -175,8 +175,8 @@ func (c *typeChecker) checkAssign(n *a.Assign) error { c.idMap.ByID(n.Operator()), lhs.String(c.idMap), lTyp.String(c.idMap)) } - switch n.Operator() { - case t.IDShiftLEq, t.IDShiftREq: + switch n.Operator().Key() { + case t.KeyShiftLEq, t.KeyShiftREq: if rTyp.IsNumType() { return nil } @@ -225,10 +225,10 @@ func (c *typeChecker) checkExpr(n *a.Expr, depth uint32) error { } func (c *typeChecker) checkExprOther(n *a.Expr, depth uint32) error { - switch n.ID0() { + switch n.ID0().Key() { case 0: - switch id1 := n.ID1(); { - case id1.IsNumLiteral(): + id1 := n.ID1() + if id1.IsNumLiteral() { z := big.NewInt(0) s := c.idMap.ByID(id1) if _, ok := z.SetString(s, 0); !ok { @@ -238,7 +238,7 @@ func (c *typeChecker) checkExprOther(n *a.Expr, depth uint32) error { n.SetMType(TypeExprIdealNumber) return nil - case id1.IsIdent(): + } else if id1.IsIdent() { if c.f.LocalVars != nil { if typ, ok := c.f.LocalVars[id1]; ok { n.SetMType(typ) @@ -247,37 +247,38 @@ func (c *typeChecker) checkExprOther(n *a.Expr, depth uint32) error { } // TODO: look for (global) names (constants, funcs, structs). return fmt.Errorf("check: unrecognized identifier %q", c.idMap.ByID(id1)) - - case id1 == t.IDFalse: + } + switch id1.Key() { + case t.KeyFalse: n.SetConstValue(zero) n.SetMType(TypeExprBoolean) return nil - case id1 == t.IDTrue: + case t.KeyTrue: n.SetConstValue(one) n.SetMType(TypeExprBoolean) return nil - case id1 == t.IDUnderscore: + case t.KeyUnderscore: // TODO. - case id1 == t.IDThis: + case t.KeyThis: // TODO. } - case t.IDOpenParen: + case t.KeyOpenParen: // n is a function call. // TODO. - case t.IDOpenBracket: + case t.KeyOpenBracket: // n is an index. // TODO. - case t.IDColon: + case t.KeyColon: // n is a slice. // TODO. - case t.IDDot: + case t.KeyDot: return c.checkDot(n, depth) } return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprOther", n.ID0().Key()) @@ -289,7 +290,7 @@ func (c *typeChecker) checkDot(n *a.Expr, depth uint32) error { return err } lTyp := lhs.MType() - for ; lTyp.PackageOrDecorator() == t.IDPtr; lTyp = lTyp.Inner() { + for ; lTyp.PackageOrDecorator().Key() == t.KeyPtr; lTyp = lTyp.Inner() { } if lTyp.PackageOrDecorator() != 0 { @@ -299,10 +300,10 @@ func (c *typeChecker) checkDot(n *a.Expr, depth uint32) error { s := (*a.Struct)(nil) if c.f.Func != nil { - switch name := lTyp.Name(); name { - case t.IDIn: + switch name := lTyp.Name(); name.Key() { + case t.KeyIn: s = c.f.Func.In() - case t.IDOut: + case t.KeyOut: s = c.f.Func.Out() default: s = c.c.structs[name].Struct @@ -331,14 +332,14 @@ func (c *typeChecker) checkExprUnaryOp(n *a.Expr, depth uint32) error { } rTyp := rhs.MType() - switch n.ID0() { - case t.IDXUnaryPlus, t.IDXUnaryMinus: + switch n.ID0().Key() { + case t.KeyXUnaryPlus, t.KeyXUnaryMinus: if !numeric(rTyp) { return fmt.Errorf("check: unary %q: %q, of type %q, does not have a numeric type", c.idMap.ByID(n.ID0().AmbiguousForm()), rhs.String(c.idMap), rTyp.String(c.idMap)) } if cv := rhs.ConstValue(); cv != nil { - if n.ID0() == t.IDXUnaryMinus { + if n.ID0().Key() == t.KeyXUnaryMinus { cv = big.NewInt(0).Neg(cv) } n.SetConstValue(cv) @@ -346,7 +347,7 @@ func (c *typeChecker) checkExprUnaryOp(n *a.Expr, depth uint32) error { n.SetMType(rTyp) return nil - case t.IDXUnaryNot: + case t.KeyXUnaryNot: if !rTyp.Eq(TypeExprBoolean) { return fmt.Errorf("check: unary %q: %q, of type %q, does not have a boolean type", c.idMap.ByID(n.ID0().AmbiguousForm()), rhs.String(c.idMap), rTyp.String(c.idMap)) @@ -367,7 +368,7 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { } lTyp := lhs.MType() op := n.ID0() - if op == t.IDXBinaryAs { + if op.Key() == t.KeyXBinaryAs { rhs := n.RHS().TypeExpr() if err := c.checkTypeExpr(rhs, 0); err != nil { return err @@ -385,7 +386,7 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { } rTyp := rhs.MType() - switch op { + switch op.Key() { default: if !numeric(lTyp) { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type", @@ -395,9 +396,9 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type", c.idMap.ByID(op.AmbiguousForm()), rhs.String(c.idMap), rTyp.String(c.idMap)) } - case t.IDXBinaryNotEq, t.IDXBinaryEqEq: + case t.KeyXBinaryNotEq, t.KeyXBinaryEqEq: // No-op. - case t.IDXBinaryAnd, t.IDXBinaryOr: + case t.KeyXBinaryAnd, t.KeyXBinaryOr: if lTyp != TypeExprBoolean { return fmt.Errorf("check: binary %q: %q, of type %q, does not have a boolean type", c.idMap.ByID(op.AmbiguousForm()), lhs.String(c.idMap), lTyp.String(c.idMap)) @@ -408,7 +409,7 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { } } - switch op { + switch op.Key() { default: if !lTyp.EqIgnoringRefinements(rTyp) && lTyp != TypeExprIdealNumber && rTyp != TypeExprIdealNumber { return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q, do not have compatible types", @@ -417,7 +418,7 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { lTyp.String(c.idMap), rTyp.String(c.idMap), ) } - case t.IDXBinaryShiftL, t.IDXBinaryShiftR: + case t.KeyXBinaryShiftL, t.KeyXBinaryShiftR: if (lTyp == TypeExprIdealNumber) && (rTyp != TypeExprIdealNumber) { return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q; "+ "cannot shift an ideal number by a non-ideal number", @@ -446,55 +447,55 @@ func (c *typeChecker) checkExprBinaryOp(n *a.Expr, depth uint32) error { } func (c *typeChecker) setConstValueBinaryOp(n *a.Expr, l *big.Int, r *big.Int) error { - switch n.ID0() { - case t.IDXBinaryPlus: + switch n.ID0().Key() { + case t.KeyXBinaryPlus: n.SetConstValue(big.NewInt(0).Add(l, r)) - case t.IDXBinaryMinus: + case t.KeyXBinaryMinus: n.SetConstValue(big.NewInt(0).Sub(l, r)) - case t.IDXBinaryStar: + case t.KeyXBinaryStar: n.SetConstValue(big.NewInt(0).Mul(l, r)) - case t.IDXBinarySlash: + case t.KeyXBinarySlash: if r.Cmp(zero) == 0 { return fmt.Errorf("check: division by zero in const expression %q", n.String(c.idMap)) } // 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.IDXBinaryShiftL: + 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(c.idMap), n.String(c.idMap)) } n.SetConstValue(big.NewInt(0).Lsh(l, uint(r.Uint64()))) - case t.IDXBinaryShiftR: + 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(c.idMap), n.String(c.idMap)) } n.SetConstValue(big.NewInt(0).Rsh(l, uint(r.Uint64()))) - case t.IDXBinaryAmp: + case t.KeyXBinaryAmp: n.SetConstValue(big.NewInt(0).And(l, r)) - case t.IDXBinaryAmpHat: + case t.KeyXBinaryAmpHat: n.SetConstValue(big.NewInt(0).AndNot(l, r)) - case t.IDXBinaryPipe: + case t.KeyXBinaryPipe: n.SetConstValue(big.NewInt(0).Or(l, r)) - case t.IDXBinaryHat: + case t.KeyXBinaryHat: n.SetConstValue(big.NewInt(0).Xor(l, r)) - case t.IDXBinaryNotEq: + case t.KeyXBinaryNotEq: n.SetConstValue(btoi(l.Cmp(r) != 0)) - case t.IDXBinaryLessThan: + case t.KeyXBinaryLessThan: n.SetConstValue(btoi(l.Cmp(r) < 0)) - case t.IDXBinaryLessEq: + case t.KeyXBinaryLessEq: n.SetConstValue(btoi(l.Cmp(r) <= 0)) - case t.IDXBinaryEqEq: + case t.KeyXBinaryEqEq: n.SetConstValue(btoi(l.Cmp(r) == 0)) - case t.IDXBinaryGreaterEq: + case t.KeyXBinaryGreaterEq: n.SetConstValue(btoi(l.Cmp(r) >= 0)) - case t.IDXBinaryGreaterThan: + case t.KeyXBinaryGreaterThan: n.SetConstValue(btoi(l.Cmp(r) > 0)) - case t.IDXBinaryAnd: + case t.KeyXBinaryAnd: n.SetConstValue(btoi((l.Cmp(zero) != 0) && (r.Cmp(zero) != 0))) - case t.IDXBinaryOr: + case t.KeyXBinaryOr: n.SetConstValue(btoi((l.Cmp(zero) != 0) || (r.Cmp(zero) != 0))) } return nil @@ -511,9 +512,9 @@ func (c *typeChecker) checkTypeExpr(n *a.TypeExpr, depth uint32) error { } depth++ - switch n.PackageOrDecorator() { + switch n.PackageOrDecorator().Key() { case 0: - if name := n.Name(); name.IsNumType() || name == t.IDBool { + if name := n.Name(); name.IsNumType() || name.Key() == t.KeyBool { for _, bound := range n.Bounds() { if bound == nil { continue @@ -533,12 +534,12 @@ func (c *typeChecker) checkTypeExpr(n *a.TypeExpr, depth uint32) error { // TODO: see if name refers to a struct type. return fmt.Errorf("check: %q is not a type", c.idMap.ByID(n.Name())) - case t.IDPtr: + case t.KeyPtr: if err := c.checkTypeExpr(n.Inner(), depth); err != nil { return err } - case t.IDOpenBracket: + case t.KeyOpenBracket: aLen := n.ArrayLength() if err := c.checkExpr(aLen, 0); err != nil { return err @@ -563,10 +564,10 @@ func (c *typeChecker) checkTypeExpr(n *a.TypeExpr, depth uint32) error { } var comparisonOps = [256]bool{ - t.IDXBinaryNotEq >> t.KeyShift: true, - t.IDXBinaryLessThan >> t.KeyShift: true, - t.IDXBinaryLessEq >> t.KeyShift: true, - t.IDXBinaryEqEq >> t.KeyShift: true, - t.IDXBinaryGreaterEq >> t.KeyShift: true, - t.IDXBinaryGreaterThan >> t.KeyShift: true, + t.KeyXBinaryNotEq: true, + t.KeyXBinaryLessThan: true, + t.KeyXBinaryLessEq: true, + t.KeyXBinaryEqEq: true, + t.KeyXBinaryGreaterEq: true, + t.KeyXBinaryGreaterThan: true, } diff --git a/lang/parse/parse.go b/lang/parse/parse.go index 5c318ad0..a28a3ed1 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -50,7 +50,7 @@ func (p *parser) line() uint32 { return p.lastLine } -func (p *parser) peekID() t.ID { +func (p *parser) peek() t.ID { if len(p.src) > 0 { return p.src[0].ID } @@ -71,8 +71,8 @@ func (p *parser) parseFile() (*a.File, error) { func (p *parser) parseTopLevelDecl() (*a.Node, error) { line := p.src[0].Line - switch p.src[0].ID { - case t.IDFunc: + switch p.src[0].ID.Key() { + case t.KeyFunc: flags := a.Flags(0) p.src = p.src[1:] id0, id1, err := p.parseQualifiedIdent() @@ -87,22 +87,22 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) { return nil, fmt.Errorf(`parse: built-in %q used for func name at %s:%d`, p.m.ByID(id1), p.filename, p.line()) } - if p.peekID() == t.IDQuestion { + if p.peek().Key() == t.KeyQuestion { flags |= a.FlagsSuspendible p.src = p.src[1:] } - inFields, err := p.parseList(t.IDCloseParen, (*parser).parseFieldNode) + inFields, err := p.parseList(t.KeyCloseParen, (*parser).parseFieldNode) if err != nil { return nil, err } - outFields, err := p.parseList(t.IDCloseParen, (*parser).parseFieldNode) + outFields, err := p.parseList(t.KeyCloseParen, (*parser).parseFieldNode) if err != nil { return nil, err } asserts := []*a.Node(nil) - if p.peekID() == t.IDComma { + if p.peek().Key() == t.KeyComma { p.src = p.src[1:] - asserts, err = p.parseList(t.IDOpenCurly, (*parser).parseAssertNode) + asserts, err = p.parseList(t.KeyOpenCurly, (*parser).parseAssertNode) if err != nil { return nil, err } @@ -114,8 +114,8 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) { if err != nil { return nil, err } - if x := p.peekID(); x != t.IDSemicolon { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeySemicolon { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -123,7 +123,7 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) { out := a.NewStruct(0, p.filename, line, t.IDOut, outFields) return a.NewFunc(flags, p.filename, line, id0, id1, in, out, asserts, body).Node(), nil - case t.IDStruct: + case t.KeyStruct: flags := a.Flags(0) p.src = p.src[1:] name, err := p.parseIdent() @@ -134,31 +134,31 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) { return nil, fmt.Errorf(`parse: built-in %q used for struct name at %s:%d`, p.m.ByID(name), p.filename, p.line()) } - if p.peekID() == t.IDQuestion { + if p.peek().Key() == t.KeyQuestion { flags |= a.FlagsSuspendible p.src = p.src[1:] } - fields, err := p.parseList(t.IDCloseParen, (*parser).parseFieldNode) + fields, err := p.parseList(t.KeyCloseParen, (*parser).parseFieldNode) if err != nil { return nil, err } - if x := p.peekID(); x != t.IDSemicolon { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeySemicolon { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] return a.NewStruct(flags, p.filename, line, name, fields).Node(), nil - case t.IDUse: + case t.KeyUse: p.src = p.src[1:] - path := p.peekID() + path := p.peek() if !path.IsStrLiteral() { got := p.m.ByID(path) return nil, fmt.Errorf(`parse: expected string literal, got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] - if x := p.peekID(); x != t.IDSemicolon { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeySemicolon { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -175,7 +175,7 @@ func (p *parser) parseQualifiedIdent() (t.ID, t.ID, error) { return 0, 0, err } - if p.peekID() != t.IDDot { + if p.peek().Key() != t.KeyDot { return 0, x, nil } p.src = p.src[1:] @@ -200,19 +200,19 @@ func (p *parser) parseIdent() (t.ID, error) { return x.ID, nil } -func (p *parser) parseList(stop t.ID, parseElem func(*parser) (*a.Node, error)) ([]*a.Node, error) { - if stop == t.IDCloseParen { - if x := p.peekID(); x != t.IDOpenParen { +func (p *parser) parseList(stop t.Key, parseElem func(*parser) (*a.Node, error)) ([]*a.Node, error) { + if stop == t.KeyCloseParen { + if x := p.peek().Key(); x != t.KeyOpenParen { return nil, fmt.Errorf(`parse: expected "(", got %q at %s:%d`, - p.m.ByID(x), p.filename, p.line()) + p.m.ByKey(x), p.filename, p.line()) } p.src = p.src[1:] } ret := []*a.Node(nil) for len(p.src) > 0 { - if p.src[0].ID == stop { - if stop == t.IDCloseParen { + if p.src[0].ID.Key() == stop { + if stop == t.KeyCloseParen { p.src = p.src[1:] } return ret, nil @@ -224,20 +224,20 @@ func (p *parser) parseList(stop t.ID, parseElem func(*parser) (*a.Node, error)) } ret = append(ret, elem) - switch x := p.peekID(); x { + switch x := p.peek().Key(); x { case stop: - if stop == t.IDCloseParen { + if stop == t.KeyCloseParen { p.src = p.src[1:] } return ret, nil - case t.IDComma: + case t.KeyComma: p.src = p.src[1:] default: return nil, fmt.Errorf(`parse: expected %q, got %q at %s:%d`, - p.m.ByID(stop), p.m.ByID(x), p.filename, p.line()) + p.m.ByKey(stop), p.m.ByKey(x), p.filename, p.line()) } } - return nil, fmt.Errorf(`parse: expected %q at %s:%d`, p.m.ByID(stop), p.filename, p.line()) + return nil, fmt.Errorf(`parse: expected %q at %s:%d`, p.m.ByKey(stop), p.filename, p.line()) } func (p *parser) parseFieldNode() (*a.Node, error) { @@ -253,8 +253,7 @@ func (p *parser) parseFieldNode() (*a.Node, error) { } func (p *parser) parseTypeExpr() (*a.TypeExpr, error) { - switch p.peekID() { - case t.IDPtr: + if p.peek().Key() == t.KeyPtr { p.src = p.src[1:] rhs, err := p.parseTypeExpr() if err != nil { @@ -263,14 +262,14 @@ func (p *parser) parseTypeExpr() (*a.TypeExpr, error) { return a.NewTypeExpr(t.IDPtr, 0, nil, nil, rhs), nil } - if x := p.peekID(); x == t.IDOpenBracket { + if p.peek().Key() == t.KeyOpenBracket { p.src = p.src[1:] lhs, err := p.parseExpr() if err != nil { return nil, err } - if x := p.peekID(); x != t.IDCloseBracket { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyCloseBracket { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected "]", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -287,7 +286,7 @@ func (p *parser) parseTypeExpr() (*a.TypeExpr, error) { } lhs, mhs := (*a.Expr)(nil), (*a.Expr)(nil) - if x := p.peekID(); x == t.IDOpenBracket { + if p.peek().Key() == t.KeyOpenBracket { _, lhs, mhs, err = p.parseRangeOrIndex(false) if err != nil { return nil, err @@ -301,24 +300,24 @@ func (p *parser) parseTypeExpr() (*a.TypeExpr, error) { // it also parses "[x]". The returned op is t.IDColon for a range and // t.IDOpenBracket for an index. func (p *parser) parseRangeOrIndex(allowIndex bool) (op t.ID, ei *a.Expr, ej *a.Expr, err error) { - if x := p.peekID(); x != t.IDOpenBracket { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyOpenBracket { + got := p.m.ByKey(x) return 0, nil, nil, fmt.Errorf(`parse: expected "[", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] - if p.peekID() != t.IDColon { + if p.peek().Key() != t.KeyColon { ei, err = p.parseExpr() if err != nil { return 0, nil, nil, err } } - switch x := p.peekID(); { - case x == t.IDColon: + switch x := p.peek().Key(); { + case x == t.KeyColon: p.src = p.src[1:] - case x == t.IDCloseBracket && allowIndex: + case x == t.KeyCloseBracket && allowIndex: p.src = p.src[1:] return t.IDOpenBracket, nil, ei, nil @@ -327,19 +326,19 @@ func (p *parser) parseRangeOrIndex(allowIndex bool) (op t.ID, ei *a.Expr, ej *a. if allowIndex { expected = `":" or "]"` } - got := p.m.ByID(x) + got := p.m.ByKey(x) return 0, nil, nil, fmt.Errorf(`parse: expected %s, got %q at %s:%d`, expected, got, p.filename, p.line()) } - if p.peekID() != t.IDCloseBracket { + if p.peek().Key() != t.KeyCloseBracket { ej, err = p.parseExpr() if err != nil { return 0, nil, nil, err } } - if x := p.peekID(); x != t.IDCloseBracket { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyCloseBracket { + got := p.m.ByKey(x) return 0, nil, nil, fmt.Errorf(`parse: expected "]", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -348,15 +347,15 @@ func (p *parser) parseRangeOrIndex(allowIndex bool) (op t.ID, ei *a.Expr, ej *a. } func (p *parser) parseBlock() ([]*a.Node, error) { - if x := p.peekID(); x != t.IDOpenCurly { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyOpenCurly { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected "{", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] block := []*a.Node(nil) for len(p.src) > 0 { - if p.src[0].ID == t.IDCloseCurly { + if p.src[0].ID.Key() == t.KeyCloseCurly { p.src = p.src[1:] return block, nil } @@ -367,8 +366,8 @@ func (p *parser) parseBlock() ([]*a.Node, error) { } block = append(block, s) - if x := p.peekID(); x != t.IDSemicolon { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeySemicolon { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected (implicit) ";", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -379,13 +378,13 @@ func (p *parser) parseBlock() ([]*a.Node, error) { func (p *parser) assertsSorted(asserts []*a.Node) error { seenAssert, seenPost := false, false for _, a := range asserts { - switch a.Assert().Keyword() { - case t.IDPre: + switch a.Assert().Keyword().Key() { + case t.KeyPre: if seenPost || seenAssert { break } continue - case t.IDAssert: + case t.KeyAssert: if seenPost { break } @@ -402,8 +401,8 @@ func (p *parser) assertsSorted(asserts []*a.Node) error { } func (p *parser) parseAssertNode() (*a.Node, error) { - switch x := p.peekID(); x { - case t.IDAssert, t.IDPre, t.IDPost: + switch x := p.peek(); x.Key() { + case t.KeyAssert, t.KeyPre, t.KeyPost: p.src = p.src[1:] rhs, err := p.parseExpr() if err != nil { @@ -427,24 +426,24 @@ func (p *parser) parseStatement() (*a.Node, error) { } func (p *parser) parseStatement1() (*a.Node, error) { - switch x := p.peekID(); x { - case t.IDAssert, t.IDPre, t.IDPost: + switch x := p.peek(); x.Key() { + case t.KeyAssert, t.KeyPre, t.KeyPost: return p.parseAssertNode() - case t.IDBreak, t.IDContinue: + case t.KeyBreak, t.KeyContinue: p.src = p.src[1:] return a.NewJump(x).Node(), nil - case t.IDWhile: + case t.KeyWhile: p.src = p.src[1:] condition, err := p.parseExpr() if err != nil { return nil, err } asserts := []*a.Node(nil) - if p.peekID() == t.IDComma { + if p.peek().Key() == t.KeyComma { p.src = p.src[1:] - asserts, err = p.parseList(t.IDOpenCurly, (*parser).parseAssertNode) + asserts, err = p.parseList(t.KeyOpenCurly, (*parser).parseAssertNode) if err != nil { return nil, err } @@ -458,14 +457,14 @@ func (p *parser) parseStatement1() (*a.Node, error) { } return a.NewWhile(condition, asserts, body).Node(), nil - case t.IDIf: + case t.KeyIf: o, err := p.parseIf() return o.Node(), err - case t.IDReturn: + case t.KeyReturn: p.src = p.src[1:] value, err := (*a.Expr)(nil), error(nil) - if p.peekID() != t.IDSemicolon { + if p.peek().Key() != t.KeySemicolon { value, err = p.parseExpr() if err != nil { return nil, err @@ -473,7 +472,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { } return a.NewReturn(value).Node(), nil - case t.IDVar: + case t.KeyVar: p.src = p.src[1:] id, err := p.parseIdent() if err != nil { @@ -484,7 +483,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { return nil, err } value := (*a.Expr)(nil) - if p.peekID() == t.IDEq { + if p.peek().Key() == t.KeyEq { p.src = p.src[1:] value, err = p.parseExpr() if err != nil { @@ -499,7 +498,7 @@ func (p *parser) parseStatement1() (*a.Node, error) { return nil, err } - if op := p.peekID(); op.IsAssign() { + if op := p.peek(); op.IsAssign() { p.src = p.src[1:] rhs, err := p.parseExpr() if err != nil { @@ -512,8 +511,8 @@ func (p *parser) parseStatement1() (*a.Node, error) { } func (p *parser) parseIf() (*a.If, error) { - if x := p.peekID(); x != t.IDIf { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyIf { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected "if", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -526,9 +525,9 @@ func (p *parser) parseIf() (*a.If, error) { return nil, err } elseIf, bodyIfFalse := (*a.If)(nil), ([]*a.Node)(nil) - if p.peekID() == t.IDElse { + if p.peek().Key() == t.KeyElse { p.src = p.src[1:] - if p.peekID() == t.IDIf { + if p.peek().Key() == t.KeyIf { elseIf, err = p.parseIf() if err != nil { return nil, err @@ -553,10 +552,10 @@ func (p *parser) parseExpr() (*a.Expr, error) { if err != nil { return nil, err } - if x := p.peekID(); x.IsBinaryOp() { + if x := p.peek(); x.IsBinaryOp() { p.src = p.src[1:] rhs := (*a.Node)(nil) - if x == t.IDAs { + if x.Key() == t.KeyAs { o, err := p.parseTypeExpr() if err != nil { return nil, err @@ -570,7 +569,7 @@ func (p *parser) parseExpr() (*a.Expr, error) { rhs = o.Node() } - if !x.IsAssociativeOp() || x != p.peekID() { + if !x.IsAssociativeOp() || x != p.peek() { op := x.BinaryForm() if op == 0 { return nil, fmt.Errorf(`parse: internal error: no binary form for token.Key 0x%#02x`, x.Key()) @@ -579,7 +578,7 @@ func (p *parser) parseExpr() (*a.Expr, error) { } args := []*a.Node{lhs.Node(), rhs} - for p.peekID() == x { + for p.peek() == x { p.src = p.src[1:] arg, err := p.parseOperand() if err != nil { @@ -597,15 +596,15 @@ func (p *parser) parseExpr() (*a.Expr, error) { } func (p *parser) parseOperand() (*a.Expr, error) { - switch x := p.peekID(); { - case x == t.IDOpenParen: + switch x := p.peek(); { + case x.Key() == t.KeyOpenParen: p.src = p.src[1:] expr, err := p.parseExpr() if err != nil { return nil, err } - if x := p.peekID(); x != t.IDCloseParen { - got := p.m.ByID(x) + if x := p.peek().Key(); x != t.KeyCloseParen { + got := p.m.ByKey(x) return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line()) } p.src = p.src[1:] @@ -636,17 +635,17 @@ func (p *parser) parseOperand() (*a.Expr, error) { for { flags := a.Flags(0) - switch p.peekID() { + switch p.peek().Key() { default: return lhs, nil - case t.IDQuestion: + case t.KeyQuestion: p.src = p.src[1:] flags |= a.FlagsSuspendible fallthrough - case t.IDOpenParen: - args, err := p.parseList(t.IDCloseParen, func(p *parser) (*a.Node, error) { + case t.KeyOpenParen: + args, err := p.parseList(t.KeyCloseParen, func(p *parser) (*a.Node, error) { n, err := p.parseExpr() return n.Node(), err }) @@ -655,14 +654,14 @@ func (p *parser) parseOperand() (*a.Expr, error) { } lhs = a.NewExpr(flags, t.IDOpenParen, 0, lhs.Node(), nil, nil, args) - case t.IDOpenBracket: + case t.KeyOpenBracket: id0, mhs, rhs, err := p.parseRangeOrIndex(true) if err != nil { return nil, err } lhs = a.NewExpr(0, id0, 0, lhs.Node(), mhs.Node(), rhs.Node(), nil) - case t.IDDot: + case t.KeyDot: p.src = p.src[1:] selector, err := p.parseIdent() if err != nil { diff --git a/lang/render/render.go b/lang/render/render.go index 8d93a120..cc89bbff 100644 --- a/lang/render/render.go +++ b/lang/render/render.go @@ -104,19 +104,19 @@ func Render(w io.Writer, m *token.IDMap, src []token.Token, comments []string) ( if prevID != 0 && !prevIsTightRight && !t.IsTightLeft() { // The "(" token's tight-left-ness is context dependent. For // "f(x)", the "(" is tight-left. For "a * (b + c)", it is not. - if t.ID != token.IDOpenParen || prevID.Flags()&flagsLIC == 0 { + if t.ID.Key() != token.KeyOpenParen || prevID.Flags()&flagsLIC == 0 { buf = append(buf, ' ') } } buf = append(buf, m.ByToken(t)...) - if t.ID == token.IDOpenCurly { + if t.ID.Key() == token.KeyOpenCurly { if indent == maxIndent { return errors.New("render: too many \"{\" tokens") } indent++ - } else if t.ID == token.IDCloseCurly { + } else if t.ID.Key() == token.KeyCloseCurly { if indent == 0 { return errors.New("render: too many \"}\" tokens") } diff --git a/lang/token/list.go b/lang/token/list.go index 342b6300..e1027224 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -126,6 +126,129 @@ func (t Token) IsNumType() bool { return Flags(t.ID)&FlagsNumType != 0 // "&=". Their Keys range in [0x01, 0x7F]. const nBuiltInKeys = Key(256) +const ( + KeyInvalid = Key(0) + + KeyOpenParen = Key(IDOpenParen >> KeyShift) + KeyCloseParen = Key(IDCloseParen >> KeyShift) + KeyOpenBracket = Key(IDOpenBracket >> KeyShift) + KeyCloseBracket = Key(IDCloseBracket >> KeyShift) + KeyOpenCurly = Key(IDOpenCurly >> KeyShift) + KeyCloseCurly = Key(IDCloseCurly >> KeyShift) + + KeyDot = Key(IDDot >> KeyShift) + KeyComma = Key(IDComma >> KeyShift) + KeyQuestion = Key(IDQuestion >> KeyShift) + KeyColon = Key(IDColon >> KeyShift) + KeySemicolon = Key(IDSemicolon >> KeyShift) + + KeyEq = Key(IDEq >> KeyShift) + KeyPlusEq = Key(IDPlusEq >> KeyShift) + KeyMinusEq = Key(IDMinusEq >> KeyShift) + KeyStarEq = Key(IDStarEq >> KeyShift) + KeySlashEq = Key(IDSlashEq >> KeyShift) + KeyShiftLEq = Key(IDShiftLEq >> KeyShift) + KeyShiftREq = Key(IDShiftREq >> KeyShift) + KeyAmpEq = Key(IDAmpEq >> KeyShift) + KeyAmpHatEq = Key(IDAmpHatEq >> KeyShift) + KeyPipeEq = Key(IDPipeEq >> KeyShift) + KeyHatEq = Key(IDHatEq >> KeyShift) + + KeyPlus = Key(IDPlus >> KeyShift) + KeyMinus = Key(IDMinus >> KeyShift) + KeyStar = Key(IDStar >> KeyShift) + KeySlash = Key(IDSlash >> KeyShift) + KeyShiftL = Key(IDShiftL >> KeyShift) + KeyShiftR = Key(IDShiftR >> KeyShift) + KeyAmp = Key(IDAmp >> KeyShift) + KeyAmpHat = Key(IDAmpHat >> KeyShift) + KeyPipe = Key(IDPipe >> KeyShift) + KeyHat = Key(IDHat >> KeyShift) + + KeyNotEq = Key(IDNotEq >> KeyShift) + KeyLessThan = Key(IDLessThan >> KeyShift) + KeyLessEq = Key(IDLessEq >> KeyShift) + KeyEqEq = Key(IDEqEq >> KeyShift) + KeyGreaterEq = Key(IDGreaterEq >> KeyShift) + KeyGreaterThan = Key(IDGreaterThan >> KeyShift) + + // TODO: sort these by name, when the list has stabilized. + KeyAnd = Key(IDAnd >> KeyShift) + KeyOr = Key(IDOr >> KeyShift) + KeyNot = Key(IDNot >> KeyShift) + KeyAs = Key(IDAs >> KeyShift) + + // TODO: sort these by name, when the list has stabilized. + KeyFunc = Key(IDFunc >> KeyShift) + KeyPtr = Key(IDPtr >> KeyShift) + KeyAssert = Key(IDAssert >> KeyShift) + KeyWhile = Key(IDWhile >> KeyShift) + KeyIf = Key(IDIf >> KeyShift) + KeyElse = Key(IDElse >> KeyShift) + KeyReturn = Key(IDReturn >> KeyShift) + KeyBreak = Key(IDBreak >> KeyShift) + KeyContinue = Key(IDContinue >> KeyShift) + KeyStruct = Key(IDStruct >> KeyShift) + KeyUse = Key(IDUse >> KeyShift) + KeyVar = Key(IDVar >> KeyShift) + KeyIdeal = Key(IDIdeal >> KeyShift) + KeyPre = Key(IDPre >> KeyShift) + KeyPost = Key(IDPost >> KeyShift) + + KeyFalse = Key(IDFalse >> KeyShift) + KeyTrue = Key(IDTrue >> KeyShift) + + KeyI8 = Key(IDI8 >> KeyShift) + KeyI16 = Key(IDI16 >> KeyShift) + KeyI32 = Key(IDI32 >> KeyShift) + KeyI64 = Key(IDI64 >> KeyShift) + KeyU8 = Key(IDU8 >> KeyShift) + KeyU16 = Key(IDU16 >> KeyShift) + KeyU32 = Key(IDU32 >> KeyShift) + KeyU64 = Key(IDU64 >> KeyShift) + KeyUsize = Key(IDUsize >> KeyShift) + KeyBool = Key(IDBool >> KeyShift) + KeyBuf1 = Key(IDBuf1 >> KeyShift) + KeyBuf2 = Key(IDBuf2 >> KeyShift) + + KeyUnderscore = Key(IDUnderscore >> KeyShift) + KeyThis = Key(IDThis >> KeyShift) + KeyIn = Key(IDIn >> KeyShift) + KeyOut = Key(IDOut >> KeyShift) + + KeyXUnaryPlus = Key(IDXUnaryPlus >> KeyShift) + KeyXUnaryMinus = Key(IDXUnaryMinus >> KeyShift) + KeyXUnaryNot = Key(IDXUnaryNot >> KeyShift) + + KeyXBinaryPlus = Key(IDXBinaryPlus >> KeyShift) + KeyXBinaryMinus = Key(IDXBinaryMinus >> KeyShift) + KeyXBinaryStar = Key(IDXBinaryStar >> KeyShift) + KeyXBinarySlash = Key(IDXBinarySlash >> KeyShift) + KeyXBinaryShiftL = Key(IDXBinaryShiftL >> KeyShift) + KeyXBinaryShiftR = Key(IDXBinaryShiftR >> KeyShift) + KeyXBinaryAmp = Key(IDXBinaryAmp >> KeyShift) + KeyXBinaryAmpHat = Key(IDXBinaryAmpHat >> KeyShift) + KeyXBinaryPipe = Key(IDXBinaryPipe >> KeyShift) + KeyXBinaryHat = Key(IDXBinaryHat >> KeyShift) + KeyXBinaryNotEq = Key(IDXBinaryNotEq >> KeyShift) + KeyXBinaryLessThan = Key(IDXBinaryLessThan >> KeyShift) + KeyXBinaryLessEq = Key(IDXBinaryLessEq >> KeyShift) + KeyXBinaryEqEq = Key(IDXBinaryEqEq >> KeyShift) + KeyXBinaryGreaterEq = Key(IDXBinaryGreaterEq >> KeyShift) + KeyXBinaryGreaterThan = Key(IDXBinaryGreaterThan >> KeyShift) + KeyXBinaryAnd = Key(IDXBinaryAnd >> KeyShift) + KeyXBinaryOr = Key(IDXBinaryOr >> KeyShift) + KeyXBinaryAs = Key(IDXBinaryAs >> KeyShift) + + KeyXAssociativePlus = Key(IDXAssociativePlus >> KeyShift) + KeyXAssociativeStar = Key(IDXAssociativeStar >> KeyShift) + KeyXAssociativeAmp = Key(IDXAssociativeAmp >> KeyShift) + KeyXAssociativePipe = Key(IDXAssociativePipe >> KeyShift) + KeyXAssociativeHat = Key(IDXAssociativeHat >> KeyShift) + KeyXAssociativeAnd = Key(IDXAssociativeAnd >> KeyShift) + KeyXAssociativeOr = Key(IDXAssociativeOr >> KeyShift) +) + const ( IDInvalid = ID(0) @@ -260,90 +383,90 @@ var builtInsByKey = [nBuiltInKeys]struct { name string id ID }{ - IDOpenParen >> KeyShift: {"(", IDOpenParen}, - IDCloseParen >> KeyShift: {")", IDCloseParen}, - IDOpenBracket >> KeyShift: {"[", IDOpenBracket}, - IDCloseBracket >> KeyShift: {"]", IDCloseBracket}, - IDOpenCurly >> KeyShift: {"{", IDOpenCurly}, - IDCloseCurly >> KeyShift: {"}", IDCloseCurly}, + KeyOpenParen: {"(", IDOpenParen}, + KeyCloseParen: {")", IDCloseParen}, + KeyOpenBracket: {"[", IDOpenBracket}, + KeyCloseBracket: {"]", IDCloseBracket}, + KeyOpenCurly: {"{", IDOpenCurly}, + KeyCloseCurly: {"}", IDCloseCurly}, - IDDot >> KeyShift: {".", IDDot}, - IDComma >> KeyShift: {",", IDComma}, - IDQuestion >> KeyShift: {"?", IDQuestion}, - IDColon >> KeyShift: {":", IDColon}, - IDSemicolon >> KeyShift: {";", IDSemicolon}, + KeyDot: {".", IDDot}, + KeyComma: {",", IDComma}, + KeyQuestion: {"?", IDQuestion}, + KeyColon: {":", IDColon}, + KeySemicolon: {";", IDSemicolon}, - IDEq >> KeyShift: {"=", IDEq}, - IDPlusEq >> KeyShift: {"+=", IDPlusEq}, - IDMinusEq >> KeyShift: {"-=", IDMinusEq}, - IDStarEq >> KeyShift: {"*=", IDStarEq}, - IDSlashEq >> KeyShift: {"/=", IDSlashEq}, - IDShiftLEq >> KeyShift: {"<<=", IDShiftLEq}, - IDShiftREq >> KeyShift: {">>=", IDShiftREq}, - IDAmpEq >> KeyShift: {"&=", IDAmpEq}, - IDAmpHatEq >> KeyShift: {"&^=", IDAmpHatEq}, - IDPipeEq >> KeyShift: {"|=", IDPipeEq}, - IDHatEq >> KeyShift: {"^=", IDHatEq}, + KeyEq: {"=", IDEq}, + KeyPlusEq: {"+=", IDPlusEq}, + KeyMinusEq: {"-=", IDMinusEq}, + KeyStarEq: {"*=", IDStarEq}, + KeySlashEq: {"/=", IDSlashEq}, + KeyShiftLEq: {"<<=", IDShiftLEq}, + KeyShiftREq: {">>=", IDShiftREq}, + KeyAmpEq: {"&=", IDAmpEq}, + KeyAmpHatEq: {"&^=", IDAmpHatEq}, + KeyPipeEq: {"|=", IDPipeEq}, + KeyHatEq: {"^=", IDHatEq}, - IDPlus >> KeyShift: {"+", IDPlus}, - IDMinus >> KeyShift: {"-", IDMinus}, - IDStar >> KeyShift: {"*", IDStar}, - IDSlash >> KeyShift: {"/", IDSlash}, - IDShiftL >> KeyShift: {"<<", IDShiftL}, - IDShiftR >> KeyShift: {">>", IDShiftR}, - IDAmp >> KeyShift: {"&", IDAmp}, - IDAmpHat >> KeyShift: {"&^", IDAmpHat}, - IDPipe >> KeyShift: {"|", IDPipe}, - IDHat >> KeyShift: {"^", IDHat}, + KeyPlus: {"+", IDPlus}, + KeyMinus: {"-", IDMinus}, + KeyStar: {"*", IDStar}, + KeySlash: {"/", IDSlash}, + KeyShiftL: {"<<", IDShiftL}, + KeyShiftR: {">>", IDShiftR}, + KeyAmp: {"&", IDAmp}, + KeyAmpHat: {"&^", IDAmpHat}, + KeyPipe: {"|", IDPipe}, + KeyHat: {"^", IDHat}, - IDNotEq >> KeyShift: {"!=", IDNotEq}, - IDLessThan >> KeyShift: {"<", IDLessThan}, - IDLessEq >> KeyShift: {"<=", IDLessEq}, - IDEqEq >> KeyShift: {"==", IDEqEq}, - IDGreaterEq >> KeyShift: {">=", IDGreaterEq}, - IDGreaterThan >> KeyShift: {">", IDGreaterThan}, + KeyNotEq: {"!=", IDNotEq}, + KeyLessThan: {"<", IDLessThan}, + KeyLessEq: {"<=", IDLessEq}, + KeyEqEq: {"==", IDEqEq}, + KeyGreaterEq: {">=", IDGreaterEq}, + KeyGreaterThan: {">", IDGreaterThan}, - IDAnd >> KeyShift: {"and", IDAnd}, - IDOr >> KeyShift: {"or", IDOr}, - IDNot >> KeyShift: {"not", IDNot}, - IDAs >> KeyShift: {"as", IDAs}, + KeyAnd: {"and", IDAnd}, + KeyOr: {"or", IDOr}, + KeyNot: {"not", IDNot}, + KeyAs: {"as", IDAs}, - IDFunc >> KeyShift: {"func", IDFunc}, - IDPtr >> KeyShift: {"ptr", IDPtr}, - IDAssert >> KeyShift: {"assert", IDAssert}, - IDWhile >> KeyShift: {"while", IDWhile}, - IDIf >> KeyShift: {"if", IDIf}, - IDElse >> KeyShift: {"else", IDElse}, - IDReturn >> KeyShift: {"return", IDReturn}, - IDBreak >> KeyShift: {"break", IDBreak}, - IDContinue >> KeyShift: {"continue", IDContinue}, - IDStruct >> KeyShift: {"struct", IDStruct}, - IDUse >> KeyShift: {"use", IDUse}, - IDVar >> KeyShift: {"var", IDVar}, - IDIdeal >> KeyShift: {"ideal", IDIdeal}, - IDPre >> KeyShift: {"pre", IDPre}, - IDPost >> KeyShift: {"post", IDPost}, + KeyFunc: {"func", IDFunc}, + KeyPtr: {"ptr", IDPtr}, + KeyAssert: {"assert", IDAssert}, + KeyWhile: {"while", IDWhile}, + KeyIf: {"if", IDIf}, + KeyElse: {"else", IDElse}, + KeyReturn: {"return", IDReturn}, + KeyBreak: {"break", IDBreak}, + KeyContinue: {"continue", IDContinue}, + KeyStruct: {"struct", IDStruct}, + KeyUse: {"use", IDUse}, + KeyVar: {"var", IDVar}, + KeyIdeal: {"ideal", IDIdeal}, + KeyPre: {"pre", IDPre}, + KeyPost: {"post", IDPost}, - IDFalse >> KeyShift: {"false", IDFalse}, - IDTrue >> KeyShift: {"true", IDTrue}, + KeyFalse: {"false", IDFalse}, + KeyTrue: {"true", IDTrue}, - IDI8 >> KeyShift: {"i8", IDI8}, - IDI16 >> KeyShift: {"i16", IDI16}, - IDI32 >> KeyShift: {"i32", IDI32}, - IDI64 >> KeyShift: {"i64", IDI64}, - IDU8 >> KeyShift: {"u8", IDU8}, - IDU16 >> KeyShift: {"u16", IDU16}, - IDU32 >> KeyShift: {"u32", IDU32}, - IDU64 >> KeyShift: {"u64", IDU64}, - IDUsize >> KeyShift: {"usize", IDUsize}, - IDBool >> KeyShift: {"bool", IDBool}, - IDBuf1 >> KeyShift: {"buf1", IDBuf1}, - IDBuf2 >> KeyShift: {"buf2", IDBuf2}, + KeyI8: {"i8", IDI8}, + KeyI16: {"i16", IDI16}, + KeyI32: {"i32", IDI32}, + KeyI64: {"i64", IDI64}, + KeyU8: {"u8", IDU8}, + KeyU16: {"u16", IDU16}, + KeyU32: {"u32", IDU32}, + KeyU64: {"u64", IDU64}, + KeyUsize: {"usize", IDUsize}, + KeyBool: {"bool", IDBool}, + KeyBuf1: {"buf1", IDBuf1}, + KeyBuf2: {"buf2", IDBuf2}, - IDUnderscore >> KeyShift: {"_", IDUnderscore}, - IDThis >> KeyShift: {"this", IDThis}, - IDIn >> KeyShift: {"in", IDIn}, - IDOut >> KeyShift: {"out", IDOut}, + KeyUnderscore: {"_", IDUnderscore}, + KeyThis: {"this", IDThis}, + KeyIn: {"in", IDIn}, + KeyOut: {"out", IDOut}, } var builtInsByName = map[string]ID{} @@ -450,73 +573,73 @@ var lexers = [256][]suffixLexer{ } var ambiguousForms = [256]ID{ - IDXUnaryPlus >> KeyShift: IDPlus, - IDXUnaryMinus >> KeyShift: IDMinus, - IDXUnaryNot >> KeyShift: IDNot, + KeyXUnaryPlus: IDPlus, + KeyXUnaryMinus: IDMinus, + KeyXUnaryNot: IDNot, - IDXBinaryPlus >> KeyShift: IDPlus, - IDXBinaryMinus >> KeyShift: IDMinus, - IDXBinaryStar >> KeyShift: IDStar, - IDXBinarySlash >> KeyShift: IDSlash, - IDXBinaryShiftL >> KeyShift: IDShiftL, - IDXBinaryShiftR >> KeyShift: IDShiftR, - IDXBinaryAmp >> KeyShift: IDAmp, - IDXBinaryAmpHat >> KeyShift: IDAmpHat, - IDXBinaryPipe >> KeyShift: IDPipe, - IDXBinaryHat >> KeyShift: IDHat, - IDXBinaryNotEq >> KeyShift: IDNotEq, - IDXBinaryLessThan >> KeyShift: IDLessThan, - IDXBinaryLessEq >> KeyShift: IDLessEq, - IDXBinaryEqEq >> KeyShift: IDEqEq, - IDXBinaryGreaterEq >> KeyShift: IDGreaterEq, - IDXBinaryGreaterThan >> KeyShift: IDGreaterThan, - IDXBinaryAnd >> KeyShift: IDAnd, - IDXBinaryOr >> KeyShift: IDOr, - IDXBinaryAs >> KeyShift: IDAs, + KeyXBinaryPlus: IDPlus, + KeyXBinaryMinus: IDMinus, + KeyXBinaryStar: IDStar, + KeyXBinarySlash: IDSlash, + KeyXBinaryShiftL: IDShiftL, + KeyXBinaryShiftR: IDShiftR, + KeyXBinaryAmp: IDAmp, + KeyXBinaryAmpHat: IDAmpHat, + KeyXBinaryPipe: IDPipe, + KeyXBinaryHat: IDHat, + KeyXBinaryNotEq: IDNotEq, + KeyXBinaryLessThan: IDLessThan, + KeyXBinaryLessEq: IDLessEq, + KeyXBinaryEqEq: IDEqEq, + KeyXBinaryGreaterEq: IDGreaterEq, + KeyXBinaryGreaterThan: IDGreaterThan, + KeyXBinaryAnd: IDAnd, + KeyXBinaryOr: IDOr, + KeyXBinaryAs: IDAs, - IDXAssociativePlus >> KeyShift: IDPlus, - IDXAssociativeStar >> KeyShift: IDStar, - IDXAssociativeAmp >> KeyShift: IDAmp, - IDXAssociativePipe >> KeyShift: IDPipe, - IDXAssociativeHat >> KeyShift: IDHat, - IDXAssociativeAnd >> KeyShift: IDAnd, - IDXAssociativeOr >> KeyShift: IDOr, + KeyXAssociativePlus: IDPlus, + KeyXAssociativeStar: IDStar, + KeyXAssociativeAmp: IDAmp, + KeyXAssociativePipe: IDPipe, + KeyXAssociativeHat: IDHat, + KeyXAssociativeAnd: IDAnd, + KeyXAssociativeOr: IDOr, } var unaryForms = [256]ID{ - IDPlus >> KeyShift: IDXUnaryPlus, - IDMinus >> KeyShift: IDXUnaryMinus, - IDNot >> KeyShift: IDXUnaryNot, + KeyPlus: IDXUnaryPlus, + KeyMinus: IDXUnaryMinus, + KeyNot: IDXUnaryNot, } var binaryForms = [256]ID{ - IDPlus >> KeyShift: IDXBinaryPlus, - IDMinus >> KeyShift: IDXBinaryMinus, - IDStar >> KeyShift: IDXBinaryStar, - IDSlash >> KeyShift: IDXBinarySlash, - IDShiftL >> KeyShift: IDXBinaryShiftL, - IDShiftR >> KeyShift: IDXBinaryShiftR, - IDAmp >> KeyShift: IDXBinaryAmp, - IDAmpHat >> KeyShift: IDXBinaryAmpHat, - IDPipe >> KeyShift: IDXBinaryPipe, - IDHat >> KeyShift: IDXBinaryHat, - IDNotEq >> KeyShift: IDXBinaryNotEq, - IDLessThan >> KeyShift: IDXBinaryLessThan, - IDLessEq >> KeyShift: IDXBinaryLessEq, - IDEqEq >> KeyShift: IDXBinaryEqEq, - IDGreaterEq >> KeyShift: IDXBinaryGreaterEq, - IDGreaterThan >> KeyShift: IDXBinaryGreaterThan, - IDAnd >> KeyShift: IDXBinaryAnd, - IDOr >> KeyShift: IDXBinaryOr, - IDAs >> KeyShift: IDXBinaryAs, + KeyPlus: IDXBinaryPlus, + KeyMinus: IDXBinaryMinus, + KeyStar: IDXBinaryStar, + KeySlash: IDXBinarySlash, + KeyShiftL: IDXBinaryShiftL, + KeyShiftR: IDXBinaryShiftR, + KeyAmp: IDXBinaryAmp, + KeyAmpHat: IDXBinaryAmpHat, + KeyPipe: IDXBinaryPipe, + KeyHat: IDXBinaryHat, + KeyNotEq: IDXBinaryNotEq, + KeyLessThan: IDXBinaryLessThan, + KeyLessEq: IDXBinaryLessEq, + KeyEqEq: IDXBinaryEqEq, + KeyGreaterEq: IDXBinaryGreaterEq, + KeyGreaterThan: IDXBinaryGreaterThan, + KeyAnd: IDXBinaryAnd, + KeyOr: IDXBinaryOr, + KeyAs: IDXBinaryAs, } var associativeForms = [256]ID{ - IDPlus >> KeyShift: IDXAssociativePlus, - IDStar >> KeyShift: IDXAssociativeStar, - IDAmp >> KeyShift: IDXAssociativeAmp, - IDPipe >> KeyShift: IDXAssociativePipe, - IDHat >> KeyShift: IDXAssociativeHat, - IDAnd >> KeyShift: IDXAssociativeAnd, - IDOr >> KeyShift: IDXAssociativeOr, + KeyPlus: IDXAssociativePlus, + KeyStar: IDXAssociativeStar, + KeyAmp: IDXAssociativeAmp, + KeyPipe: IDXAssociativePipe, + KeyHat: IDXAssociativeHat, + KeyAnd: IDXAssociativeAnd, + KeyOr: IDXAssociativeOr, }