Add Token.KeyFoo constants.

This commit is contained in:
Nigel Tao committed 2017-05-18 16:04:26 +10:00
1 parent 05a217e8a3
commit 90c5f4758e
8 files changed
+483 -358

No files matched your search

+5 -3
View File
@@ -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() }
+2 -2
View File
@@ -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
}
+38 -38
View File
@@ -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, "] "...)
+33 -33
View File
@@ -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())
}
+60 -59
View File
@@ -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,
}
+86 -87
View File
@@ -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 {
+3 -3
View File
@@ -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")
}
+256 -133
View File
@@ -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,
}