mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Add Token.KeyFoo constants.
This commit is contained in:
1 parent
05a217e8a3
commit
90c5f4758e
8 files changed
+483
-358
No files matched your search
+5
-3
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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 {
|
||||
|
||||
@@ -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
@@ -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,
|
||||
}
|
||||
Reference in new issue
Block a user