// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT

package token

// MaxIntBits is the largest size (in bits) of the i8, u8, i16, u16, etc.
// integer types.
const MaxIntBits = 64

// ID is a token type. Every identifier (in the programming language sense),
// keyword, operator and literal has its own ID.
//
// Some IDs are built-in: the "func" keyword always has the same numerical ID
// value. Others are mapped at runtime. For example, the ID value for the
// "foobar" identifier (e.g. a variable name) is looked up in a Map.
type ID uint32

// Str returns a string form of x.
func (x ID) Str(m *Map) string { return m.ByID(x) }

func (x ID) AmbiguousForm() ID {
	if x >= ID(len(ambiguousForms)) {
		return 0
	}
	return ambiguousForms[x]
}

func (x ID) UnaryForm() ID {
	if x >= ID(len(unaryForms)) {
		return 0
	}
	return unaryForms[x]
}

func (x ID) BinaryForm() ID {
	if x >= ID(len(binaryForms)) {
		return 0
	}
	return binaryForms[x]
}

func (x ID) AssociativeForm() ID {
	if x >= ID(len(associativeForms)) {
		return 0
	}
	return associativeForms[x]
}

func (x ID) IsBuiltIn() bool { return x < nBuiltInIDs }

func (x ID) IsUnaryOp() bool       { return minOp <= x && x <= maxOp && unaryForms[x] != 0 }
func (x ID) IsBinaryOp() bool      { return minOp <= x && x <= maxOp && binaryForms[x] != 0 }
func (x ID) IsAssociativeOp() bool { return minOp <= x && x <= maxOp && associativeForms[x] != 0 }

func (x ID) IsLiteral(m *Map) bool {
	if x < nBuiltInIDs {
		return minBuiltInLiteral <= x && x <= maxBuiltInLiteral
	} else if s := m.ByID(x); s != "" {
		return !alpha(s[0])
	}
	return false
}

func (x ID) IsNumLiteral(m *Map) bool {
	if x < nBuiltInIDs {
		return minBuiltInNumLiteral <= x && x <= maxBuiltInNumLiteral
	} else if s := m.ByID(x); s != "" {
		return numeric(s[0])
	}
	return false
}

// IsDQStrLiteral returns whether x is a double-quote string literal.
func (x ID) IsDQStrLiteral(m *Map) bool {
	if x < nBuiltInIDs {
		return false
	} else if s := m.ByID(x); s != "" {
		return s[0] == '"'
	}
	return false
}

// IsSQStrLiteral returns whether x is a single-quote string literal.
func (x ID) IsSQStrLiteral(m *Map) bool {
	if x < nBuiltInIDs {
		return false
	} else if s := m.ByID(x); s != "" {
		return s[0] == '\''
	}
	return false
}

func (x ID) IsIdent(m *Map) bool {
	if x < nBuiltInIDs {
		return minBuiltInIdent <= x && x <= maxBuiltInIdent
	} else if s := m.ByID(x); s != "" {
		return alpha(s[0])
	}
	return false
}

func (x ID) IsTightLeft() bool  { return x < ID(len(isTightLeft)) && isTightLeft[x] }
func (x ID) IsTightRight() bool { return x < ID(len(isTightRight)) && isTightRight[x] }

func (x ID) IsAssign() bool         { return minAssign <= x && x <= maxAssign }
func (x ID) IsBuiltInCPUArch() bool { return minBuiltInCPUArch <= x && x <= maxBuiltInCPUArch }
func (x ID) IsBuiltInCPUArchARMNeon() bool {
	return minBuiltInCPUArchARMNeon <= x && x <= maxBuiltInCPUArchARMNeon
}
func (x ID) IsCannotAssignTo() bool { return minCannotAssignTo <= x && x <= maxCannotAssignTo }
func (x ID) IsClose() bool          { return minClose <= x && x <= maxClose }
func (x ID) IsKeyword() bool        { return minKeyword <= x && x <= maxKeyword }
func (x ID) IsNumType() bool        { return minNumType <= x && x <= maxNumType }
func (x ID) IsNumTypeOrIdeal() bool { return minNumTypeOrIdeal <= x && x <= maxNumTypeOrIdeal }
func (x ID) IsRangeType() bool      { return minRangeType <= x && x <= maxRangeType }
func (x ID) IsRectType() bool       { return minRectType <= x && x <= maxRectType }
func (x ID) IsOpen() bool           { return minOpen <= x && x <= maxOpen }

func (x ID) IsImplicitSemicolon(m *Map) bool {
	return x.IsClose() || x.IsKeyword() || x.IsIdent(m) || x.IsLiteral(m)
}

func (x ID) IsXOp() bool            { return minXOp <= x && x <= maxXOp }
func (x ID) IsXUnaryOp() bool       { return minXOp <= x && x <= maxXOp && unaryForms[x] != 0 }
func (x ID) IsXBinaryOp() bool      { return minXOp <= x && x <= maxXOp && binaryForms[x] != 0 }
func (x ID) IsXAssociativeOp() bool { return minXOp <= x && x <= maxXOp && associativeForms[x] != 0 }

func (x ID) IsEtcUtility() bool {
	if (minBuiltInCPUArch <= x) && (x <= maxBuiltInCPUArch) {
		switch x {
		case IDARMCRC32Utility,
			IDARMNeonUtility,
			IDX86SSE42Utility,
			IDX86AVX2Utility:
			return true
		}
	}
	return x == IDUtility
}

// QID is a qualified ID, such as "foo.bar". QID[0] is "foo"'s ID and QID[1] is
// "bar"'s. QID[0] may be 0 for a plain "bar".
type QID [2]ID

func (x QID) IsZero() bool { return x == QID{} }

func (x QID) LessThan(y QID) bool {
	if x[0] != y[0] {
		return x[0] < y[0]
	}
	return x[1] < y[1]
}

// Str returns a string form of x.
func (x QID) Str(m *Map) string {
	if x[0] != 0 {
		return m.ByID(x[0]) + "." + m.ByID(x[1])
	}
	return m.ByID(x[1])
}

// QQID is a double-qualified ID, such as "receiverPkg.receiverName.funcName".
type QQID [3]ID

func (x QQID) IsZero() bool { return x == QQID{} }

func (x QQID) LessThan(y QQID) bool {
	if x[0] != y[0] {
		return x[0] < y[0]
	}
	if x[1] != y[1] {
		return x[1] < y[1]
	}
	return x[2] < y[2]
}

// Str returns a string form of x.
func (x QQID) Str(m *Map) string {
	if x[0] != 0 {
		return m.ByID(x[0]) + "." + m.ByID(x[1]) + "." + m.ByID(x[2])
	}
	if x[1] != 0 {
		return m.ByID(x[1]) + "." + m.ByID(x[2])
	}
	return m.ByID(x[2])
}

func (x QQID) QIDSuffix() QID {
	return QID{x[1], x[2]}
}

// Token combines an ID and the line number it was seen.
type Token struct {
	ID   ID
	Line uint32
}

// nBuiltInIDs is the number of built-in IDs. The packing is:
//   - 0x00 is invalid.
//   - 0x01 ..=  0x0F are squiggly punctuation, such as ";", "." and "?".
//   - 0x10 ..=  0x1F are squiggly bookends, such as "(", ")" and "]".
//   - 0x20 ..=  0x3F are squiggly assignments, such as "=" and "+=".
//   - 0x40 ..=  0x6F are operators, such as "+", "==" and "not".
//   - 0x70 ..=  0xAF are x-ops (disambiguation forms): unary vs binary "+".
//   - 0xB0 ..=  0xCF are keywords, such as "if" and "return".
//   - 0xD0 ..=  0xDF are type modifiers, such as "ptr" and "slice".
//   - 0xE0 ..=  0xFF are literals, such as "ok" and "true".
//   - 0x100 ..= 0x3FF are identifiers, such as "bool", "u32" and "read_u8".
//
// Squiggly means a sequence of non-alpha-numeric bytes, such as "+" and "&=".
const (
	nBuiltInSymbolicIDs = ID(0xB0)  // 176
	nBuiltInIDs         = ID(0x400) // 1024
)

const (
	IDInvalid = ID(0x00)

	IDSemicolon = ID(0x01)
	IDDot       = ID(0x02)
	IDDotDot    = ID(0x03)
	IDDotDotEq  = ID(0x04)
	IDComma     = ID(0x05)
	IDExclam    = ID(0x06)
	IDQuestion  = ID(0x07)
	IDColon     = ID(0x08)
)

const (
	minOpen = 0x10
	maxOpen = 0x17

	IDOpenParen       = ID(0x10)
	IDOpenBracket     = ID(0x11)
	IDOpenCurly       = ID(0x12)
	IDOpenDoubleCurly = ID(0x13)

	minClose = 0x18
	maxClose = 0x1F

	IDCloseParen       = ID(0x18)
	IDCloseBracket     = ID(0x19)
	IDCloseCurly       = ID(0x1A)
	IDCloseDoubleCurly = ID(0x1B)
)

const (
	minAssign = 0x20
	maxAssign = 0x3F

	IDPlusEq    = ID(0x20)
	IDMinusEq   = ID(0x21)
	IDStarEq    = ID(0x22)
	IDSlashEq   = ID(0x23)
	IDShiftLEq  = ID(0x24)
	IDShiftREq  = ID(0x25)
	IDAmpEq     = ID(0x26)
	IDPipeEq    = ID(0x27)
	IDHatEq     = ID(0x28)
	IDPercentEq = ID(0x29)

	IDTildeModPlusEq   = ID(0x30)
	IDTildeModMinusEq  = ID(0x31)
	IDTildeModStarEq   = ID(0x32)
	IDTildeModShiftLEq = ID(0x34)

	IDTildeSatPlusEq  = ID(0x38)
	IDTildeSatMinusEq = ID(0x39)

	IDEq         = ID(0x3E)
	IDEqQuestion = ID(0x3F)
)

const (
	minOp          = 0x40
	minAmbiguousOp = 0x40
	maxAmbiguousOp = 0x6F
	minXOp         = 0x70
	maxXOp         = 0xAF
	maxOp          = 0xAF

	IDPlus    = ID(0x40)
	IDMinus   = ID(0x41)
	IDStar    = ID(0x42)
	IDSlash   = ID(0x43)
	IDShiftL  = ID(0x44)
	IDShiftR  = ID(0x45)
	IDAmp     = ID(0x46)
	IDPipe    = ID(0x47)
	IDHat     = ID(0x48)
	IDPercent = ID(0x49)

	IDTildeModPlus   = ID(0x50)
	IDTildeModMinus  = ID(0x51)
	IDTildeModStar   = ID(0x52)
	IDTildeModShiftL = ID(0x54)

	IDTildeSatPlus  = ID(0x58)
	IDTildeSatMinus = ID(0x59)

	IDNotEq       = ID(0x60)
	IDLessThan    = ID(0x61)
	IDLessEq      = ID(0x62)
	IDEqEq        = ID(0x63)
	IDGreaterEq   = ID(0x64)
	IDGreaterThan = ID(0x65)

	IDAnd = ID(0x68)
	IDOr  = ID(0x69)
	IDAs  = ID(0x6A)

	IDNot = ID(0x6F)

	// The IDXFoo IDs are not returned by the tokenizer. They are used by the
	// ast.Node ID-typed fields to disambiguate e.g. unary vs binary plus.

	IDXBinaryPlus    = ID(0x70)
	IDXBinaryMinus   = ID(0x71)
	IDXBinaryStar    = ID(0x72)
	IDXBinarySlash   = ID(0x73)
	IDXBinaryShiftL  = ID(0x74)
	IDXBinaryShiftR  = ID(0x75)
	IDXBinaryAmp     = ID(0x76)
	IDXBinaryPipe    = ID(0x77)
	IDXBinaryHat     = ID(0x78)
	IDXBinaryPercent = ID(0x79)

	IDXBinaryTildeModPlus   = ID(0x80)
	IDXBinaryTildeModMinus  = ID(0x81)
	IDXBinaryTildeModStar   = ID(0x82)
	IDXBinaryTildeModShiftL = ID(0x84)

	IDXBinaryTildeSatPlus  = ID(0x88)
	IDXBinaryTildeSatMinus = ID(0x89)

	IDXBinaryNotEq       = ID(0x90)
	IDXBinaryLessThan    = ID(0x91)
	IDXBinaryLessEq      = ID(0x92)
	IDXBinaryEqEq        = ID(0x93)
	IDXBinaryGreaterEq   = ID(0x94)
	IDXBinaryGreaterThan = ID(0x95)

	IDXBinaryAnd = ID(0x98)
	IDXBinaryOr  = ID(0x99)
	IDXBinaryAs  = ID(0x9A)

	IDXAssociativePlus = ID(0xA0)
	IDXAssociativeStar = ID(0xA1)
	IDXAssociativeAmp  = ID(0xA2)
	IDXAssociativePipe = ID(0xA3)
	IDXAssociativeHat  = ID(0xA4)
	IDXAssociativeAnd  = ID(0xA5)
	IDXAssociativeOr   = ID(0xA6)

	IDXUnaryPlus  = ID(0xAC)
	IDXUnaryMinus = ID(0xAD)
	IDXUnaryNot   = ID(0xAF)
)

const (
	minKeyword = 0xB0
	maxKeyword = 0xCF

	IDAssert          = ID(0xB0)
	IDBreak           = ID(0xB1)
	IDChoose          = ID(0xB2)
	IDChoosy          = ID(0xB3)
	IDConst           = ID(0xB4)
	IDContinue        = ID(0xB5)
	IDElse            = ID(0xB6)
	IDEndwhile        = ID(0xB7)
	IDFunc            = ID(0xB8)
	IDIOBind          = ID(0xB9)
	IDIOForgetHistory = ID(0xBA)
	IDIOLimit         = ID(0xBB)
	IDIf              = ID(0xBC)
	IDImplements      = ID(0xBD)
	IDInv             = ID(0xBE)
	IDIterate         = ID(0xBF)
	IDPost            = ID(0xC0)
	IDPre             = ID(0xC1)
	IDPri             = ID(0xC2)
	IDPub             = ID(0xC3)
	IDReturn          = ID(0xC4)
	IDStruct          = ID(0xC5)
	IDUse             = ID(0xC6)
	IDVar             = ID(0xC7)
	IDVia             = ID(0xC8)
	IDWhile           = ID(0xC9)
	IDYield           = ID(0xCA)
)

const (
	minTypeModifier = 0xD0
	maxTypeModifier = 0xDF

	IDArray   = ID(0xD0)
	IDNptr    = ID(0xD1)
	IDPtr     = ID(0xD2)
	IDRoarray = ID(0xD3)
	IDRoslice = ID(0xD4)
	IDRotable = ID(0xD5)
	IDSlice   = ID(0xD6)
	IDTable   = ID(0xD7)
)

const (
	minBuiltInLiteral    = 0xE0
	minBuiltInNumLiteral = 0xF0
	maxBuiltInNumLiteral = 0xFF
	maxBuiltInLiteral    = 0xFF

	IDFalse   = ID(0xE0)
	IDTrue    = ID(0xE1)
	IDNothing = ID(0xE2)
	IDNullptr = ID(0xE3)
	IDOk      = ID(0xE4)

	ID0 = ID(0xF0)
)

const (
	minBuiltInIdent   = 0x100
	minCannotAssignTo = 0x100
	maxCannotAssignTo = 0x102
	minNumTypeOrIdeal = 0x10F
	minNumType        = 0x110
	maxNumType        = 0x117
	maxNumTypeOrIdeal = 0x117
	minRangeType      = 0x130
	maxRangeType      = 0x133
	minRectType       = 0x134
	maxRectType       = 0x135
	maxBuiltInIdent   = 0x3FF

	// -------- 0x100 block.

	IDArgs             = ID(0x100)
	IDCoroutineResumed = ID(0x101)
	IDThis             = ID(0x102)

	IDR1      = ID(0x104)
	IDT1      = ID(0x105)
	IDT2      = ID(0x106)
	IDRho1    = ID(0x107)
	IDDagger1 = ID(0x108)
	IDDagger2 = ID(0x109)

	IDQNonNullptr  = ID(0x10A)
	IDQNullptr     = ID(0x10B)
	IDQPackage     = ID(0x10C)
	IDQPlaceholder = ID(0x10D)
	IDQTypeExpr    = ID(0x10E)

	// It is important that IDQIdeal is right next to the IDI8..IDU64 block.
	// See the ID.IsNumTypeOrIdeal method.
	IDQIdeal = ID(0x10F)

	IDI8  = ID(0x110)
	IDI16 = ID(0x111)
	IDI32 = ID(0x112)
	IDI64 = ID(0x113)
	IDU8  = ID(0x114)
	IDU16 = ID(0x115)
	IDU32 = ID(0x116)
	IDU64 = ID(0x117)

	IDBitvec128 = ID(0x118)
	IDBitvec256 = ID(0x119)

	IDOptionalU63 = ID(0x11C)

	IDBase            = ID(0x120)
	IDBool            = ID(0x121)
	IDEmptyIOReader   = ID(0x122)
	IDEmptyIOWriter   = ID(0x123)
	IDEmptyStruct     = ID(0x124)
	IDMoreInformation = ID(0x125)
	IDIOReader        = ID(0x126)
	IDIOWriter        = ID(0x127)
	IDStatus          = ID(0x128)
	IDTokenReader     = ID(0x129)
	IDTokenWriter     = ID(0x12A)
	IDUtility         = ID(0x12B)

	IDRangeIEU32 = ID(0x130)
	IDRangeIIU32 = ID(0x131)
	IDRangeIEU64 = ID(0x132)
	IDRangeIIU64 = ID(0x133)
	IDRectIEU32  = ID(0x134)
	IDRectIIU32  = ID(0x135)

	IDFrameConfig   = ID(0x150)
	IDImageConfig   = ID(0x151)
	IDPixelBlend    = ID(0x152)
	IDPixelBuffer   = ID(0x153)
	IDPixelConfig   = ID(0x154)
	IDPixelFormat   = ID(0x155)
	IDPixelSwizzler = ID(0x156)

	IDDecodeFrameOptions = ID(0x158)

	IDCanUndoByte     = ID(0x160)
	IDCountSince      = ID(0x161)
	IDHistoryLength   = ID(0x162)
	IDHistoryPosition = ID(0x163)
	IDIsClosed        = ID(0x164)
	IDMark            = ID(0x165)
	IDMatch15         = ID(0x166)
	IDMatch31         = ID(0x167)
	IDMatch7          = ID(0x168)
	IDPosition        = ID(0x169)
	IDSince           = ID(0x16A)
	IDSkip            = ID(0x16B)
	IDSkipU32         = ID(0x16C)
	IDSkipU32Fast     = ID(0x16D)

	IDCopyFromSlice                                               = ID(0x170)
	IDLimitedCopyU32FromHistory                                   = ID(0x171)
	IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast           = ID(0x172)
	IDLimitedCopyU32FromHistory8ByteChunksDistance1FastReturnCusp = ID(0x173)
	IDLimitedCopyU32FromHistory8ByteChunksFast                    = ID(0x174)
	IDLimitedCopyU32FromHistory8ByteChunksFastReturnCusp          = ID(0x175)
	IDLimitedCopyU32FromHistoryFast                               = ID(0x176)
	IDLimitedCopyU32FromHistoryFastReturnCusp                     = ID(0x177)
	IDLimitedCopyU32FromReader                                    = ID(0x178)
	IDLimitedCopyU32FromSlice                                     = ID(0x179)
	IDLimitedCopyU32ToSlice                                       = ID(0x17A)

	// -------- 0x180 block.

	IDUndoByte = ID(0x180)
	IDReadU8   = ID(0x181)

	IDReadU8AsU16 = ID(0x185)
	IDReadU16BE   = ID(0x186)
	IDReadU16LE   = ID(0x187)

	IDReadU8AsU32    = ID(0x189)
	IDReadU16BEAsU32 = ID(0x18A)
	IDReadU16LEAsU32 = ID(0x18B)
	IDReadU24BEAsU32 = ID(0x18C)
	IDReadU24LEAsU32 = ID(0x18D)
	IDReadU32BE      = ID(0x18E)
	IDReadU32LE      = ID(0x18F)

	IDReadU8AsU64    = ID(0x191)
	IDReadU16BEAsU64 = ID(0x192)
	IDReadU16LEAsU64 = ID(0x193)
	IDReadU24BEAsU64 = ID(0x194)
	IDReadU24LEAsU64 = ID(0x195)
	IDReadU32BEAsU64 = ID(0x196)
	IDReadU32LEAsU64 = ID(0x197)
	IDReadU40BEAsU64 = ID(0x198)
	IDReadU40LEAsU64 = ID(0x199)
	IDReadU48BEAsU64 = ID(0x19A)
	IDReadU48LEAsU64 = ID(0x19B)
	IDReadU56BEAsU64 = ID(0x19C)
	IDReadU56LEAsU64 = ID(0x19D)
	IDReadU64BE      = ID(0x19E)
	IDReadU64LE      = ID(0x19F)

	// --------

	IDPeekUndoByte = ID(0x1A0)
	IDPeekU8       = ID(0x1A1)

	IDPeekU8AsU16 = ID(0x1A5)
	IDPeekU16BE   = ID(0x1A6)
	IDPeekU16LE   = ID(0x1A7)

	IDPeekU8AsU32    = ID(0x1A9)
	IDPeekU16BEAsU32 = ID(0x1AA)
	IDPeekU16LEAsU32 = ID(0x1AB)
	IDPeekU24BEAsU32 = ID(0x1AC)
	IDPeekU24LEAsU32 = ID(0x1AD)
	IDPeekU32BE      = ID(0x1AE)
	IDPeekU32LE      = ID(0x1AF)

	IDPeekU8AsU64    = ID(0x1B1)
	IDPeekU16BEAsU64 = ID(0x1B2)
	IDPeekU16LEAsU64 = ID(0x1B3)
	IDPeekU24BEAsU64 = ID(0x1B4)
	IDPeekU24LEAsU64 = ID(0x1B5)
	IDPeekU32BEAsU64 = ID(0x1B6)
	IDPeekU32LEAsU64 = ID(0x1B7)
	IDPeekU40BEAsU64 = ID(0x1B8)
	IDPeekU40LEAsU64 = ID(0x1B9)
	IDPeekU48BEAsU64 = ID(0x1BA)
	IDPeekU48LEAsU64 = ID(0x1BB)
	IDPeekU56BEAsU64 = ID(0x1BC)
	IDPeekU56LEAsU64 = ID(0x1BD)
	IDPeekU64BE      = ID(0x1BE)
	IDPeekU64LE      = ID(0x1BF)

	IDPeekU64LEAt = ID(0x1C0)

	// --------

	IDWriteU8    = ID(0x1C1)
	IDWriteU16BE = ID(0x1C2)
	IDWriteU16LE = ID(0x1C3)
	IDWriteU24BE = ID(0x1C4)
	IDWriteU24LE = ID(0x1C5)
	IDWriteU32BE = ID(0x1C6)
	IDWriteU32LE = ID(0x1C7)
	IDWriteU40BE = ID(0x1C8)
	IDWriteU40LE = ID(0x1C9)
	IDWriteU48BE = ID(0x1CA)
	IDWriteU48LE = ID(0x1CB)
	IDWriteU56BE = ID(0x1CC)
	IDWriteU56LE = ID(0x1CD)
	IDWriteU64BE = ID(0x1CE)
	IDWriteU64LE = ID(0x1CF)

	// --------

	IDPokeU8    = ID(0x1D1)
	IDPokeU16BE = ID(0x1D2)
	IDPokeU16LE = ID(0x1D3)
	IDPokeU24BE = ID(0x1D4)
	IDPokeU24LE = ID(0x1D5)
	IDPokeU32BE = ID(0x1D6)
	IDPokeU32LE = ID(0x1D7)
	IDPokeU40BE = ID(0x1D8)
	IDPokeU40LE = ID(0x1D9)
	IDPokeU48BE = ID(0x1DA)
	IDPokeU48LE = ID(0x1DB)
	IDPokeU56BE = ID(0x1DC)
	IDPokeU56LE = ID(0x1DD)
	IDPokeU64BE = ID(0x1DE)
	IDPokeU64LE = ID(0x1DF)

	// --------

	IDWriteU8Fast    = ID(0x1E1)
	IDWriteU16BEFast = ID(0x1E2)
	IDWriteU16LEFast = ID(0x1E3)
	IDWriteU24BEFast = ID(0x1E4)
	IDWriteU24LEFast = ID(0x1E5)
	IDWriteU32BEFast = ID(0x1E6)
	IDWriteU32LEFast = ID(0x1E7)
	IDWriteU40BEFast = ID(0x1E8)
	IDWriteU40LEFast = ID(0x1E9)
	IDWriteU48BEFast = ID(0x1EA)
	IDWriteU48LEFast = ID(0x1EB)
	IDWriteU56BEFast = ID(0x1EC)
	IDWriteU56LEFast = ID(0x1ED)
	IDWriteU64BEFast = ID(0x1EE)
	IDWriteU64LEFast = ID(0x1EF)

	// --------

	IDWriteSimpleTokenFast   = ID(0x1F1)
	IDWriteExtendedTokenFast = ID(0x1F2)

	// -------- 0x200 block.

	IDAdvance        = ID(0x200)
	IDCPUArch        = ID(0x201)
	IDCPUArchIs32Bit = ID(0x202)
	IDInitialize     = ID(0x203)
	IDLength         = ID(0x204)
	IDLikely         = ID(0x205)
	IDReset          = ID(0x206)
	IDSet            = ID(0x207)
	IDUnlikely       = ID(0x208)
	IDUnroll         = ID(0x209)
	IDUpdate         = ID(0x20A)

	// TODO: range/rect methods like intersection and contains?

	IDHighBits = ID(0x220)
	IDLowBits  = ID(0x221)
	IDMax      = ID(0x222)
	IDMin      = ID(0x223)

	IDIsError      = ID(0x230)
	IDIsOK         = ID(0x231)
	IDIsSuspension = ID(0x232)

	IDBulkLoadHostEndian = ID(0x238)
	IDBulkMemset         = ID(0x239)
	IDBulkSaveHostEndian = ID(0x23A)

	IDData             = ID(0x240)
	IDHeight           = ID(0x241)
	IDIO               = ID(0x242)
	IDLimit            = ID(0x243)
	IDPrefix           = ID(0x244)
	IDRowU32           = ID(0x245)
	IDStride           = ID(0x246)
	IDSubtable         = ID(0x247)
	IDSuffix           = ID(0x248)
	IDUintptrLow12Bits = ID(0x249)
	IDValidUTF8Length  = ID(0x24A)
	IDWidth            = ID(0x24B)

	IDLimitedSwizzleU32InterleavedFromReader = ID(0x280)
	IDSwizzleInterleavedFromReader           = ID(0x281)

	// -------- 0x300 block.

	minBuiltInCPUArch        = 0x300
	minBuiltInCPUArchARMNeon = 0x30E
	maxBuiltInCPUArchARMNeon = 0x38F
	maxBuiltInCPUArch        = 0x3AF

	// If adding more CPUArch utility types, also update IsEtcUtility.

	IDARMCRC32        = ID(0x300)
	IDARMCRC32Utility = ID(0x301)

	IDARMCRC32U32 = ID(0x302)

	IDARMNeon        = ID(0x30E)
	IDARMNeonUtility = ID(0x30F)

	// ARM Neon D register (64-bit double-word) types.
	IDARMNeonU8x8  = ID(0x310)
	IDARMNeonU16x4 = ID(0x311)
	IDARMNeonU32x2 = ID(0x312)
	IDARMNeonU64x1 = ID(0x313)

	// ARM Neon Q register (128-bit quad-word) types.
	IDARMNeonU8x16 = ID(0x320)
	IDARMNeonU16x8 = ID(0x321)
	IDARMNeonU32x4 = ID(0x322)
	IDARMNeonU64x2 = ID(0x323)

	IDX86SSE42        = ID(0x390)
	IDX86SSE42Utility = ID(0x391)
	IDX86AVX2         = ID(0x392)
	IDX86AVX2Utility  = ID(0x393)
	IDX86BMI2         = ID(0x394)

	IDX86M128I = ID(0x3A0)
	IDX86M256I = ID(0x3A1)
)

var builtInsByID = [nBuiltInIDs]string{
	IDSemicolon: ";",
	IDDot:       ".",
	IDDotDot:    "..",
	IDDotDotEq:  "..=",
	IDComma:     ",",
	IDExclam:    "!",
	IDQuestion:  "?",
	IDColon:     ":",

	IDOpenParen:       "(",
	IDOpenBracket:     "[",
	IDOpenCurly:       "{",
	IDOpenDoubleCurly: "{{",

	IDCloseParen:       ")",
	IDCloseBracket:     "]",
	IDCloseCurly:       "}",
	IDCloseDoubleCurly: "}}",

	IDPlusEq:    "+=",
	IDMinusEq:   "-=",
	IDStarEq:    "*=",
	IDSlashEq:   "/=",
	IDShiftLEq:  "<<=",
	IDShiftREq:  ">>=",
	IDAmpEq:     "&=",
	IDPipeEq:    "|=",
	IDHatEq:     "^=",
	IDPercentEq: "%=",

	IDTildeModPlusEq:   "~mod+=",
	IDTildeModMinusEq:  "~mod-=",
	IDTildeModStarEq:   "~mod*=",
	IDTildeModShiftLEq: "~mod<<=",

	IDTildeSatPlusEq:  "~sat+=",
	IDTildeSatMinusEq: "~sat-=",

	IDEq:         "=",
	IDEqQuestion: "=?",

	IDPlus:    "+",
	IDMinus:   "-",
	IDStar:    "*",
	IDSlash:   "/",
	IDShiftL:  "<<",
	IDShiftR:  ">>",
	IDAmp:     "&",
	IDPipe:    "|",
	IDHat:     "^",
	IDPercent: "%",

	IDTildeModPlus:   "~mod+",
	IDTildeModMinus:  "~mod-",
	IDTildeModStar:   "~mod*",
	IDTildeModShiftL: "~mod<<",

	IDTildeSatPlus:  "~sat+",
	IDTildeSatMinus: "~sat-",

	IDNotEq:       "<>",
	IDLessThan:    "<",
	IDLessEq:      "<=",
	IDEqEq:        "==",
	IDGreaterEq:   ">=",
	IDGreaterThan: ">",

	IDAnd: "and",
	IDOr:  "or",
	IDAs:  "as",

	IDNot: "not",

	IDAssert:          "assert",
	IDBreak:           "break",
	IDChoose:          "choose",
	IDChoosy:          "choosy",
	IDConst:           "const",
	IDContinue:        "continue",
	IDElse:            "else",
	IDEndwhile:        "endwhile",
	IDFunc:            "func",
	IDIOBind:          "io_bind",
	IDIOForgetHistory: "io_forget_history",
	IDIOLimit:         "io_limit",
	IDIf:              "if",
	IDImplements:      "implements",
	IDInv:             "inv",
	IDIterate:         "iterate",
	IDPost:            "post",
	IDPre:             "pre",
	IDPri:             "pri",
	IDPub:             "pub",
	IDReturn:          "return",
	IDStruct:          "struct",
	IDUse:             "use",
	IDVar:             "var",
	IDVia:             "via",
	IDWhile:           "while",
	IDYield:           "yield",

	IDArray:   "array",
	IDNptr:    "nptr",
	IDPtr:     "ptr",
	IDRoarray: "roarray",
	IDRoslice: "roslice",
	IDRotable: "rotable",
	IDSlice:   "slice",
	IDTable:   "table",

	IDFalse:   "false",
	IDTrue:    "true",
	IDNothing: "nothing",
	IDNullptr: "nullptr",
	IDOk:      "ok",

	ID0: "0",

	// -------- 0x100 block.

	IDArgs:             "args",
	IDCoroutineResumed: "coroutine_resumed",
	IDThis:             "this",

	// Some of the next few IDs are never returned by the tokenizer, as it
	// rejects non-ASCII input. The string representations "¶", "ℤ" etc. are
	// specifically non-ASCII so that no user-defined (non built-in) identifier
	// will conflict with them.

	// IDRhoN and IDDaggerN are used by the type checker as placeholder
	// built-in IDs to represent generic 1-dimensional (slice) or 2-dimensional
	// (table) types. The Rho flavor is read-only.
	IDR1:      "R1",
	IDT1:      "T1",
	IDT2:      "T2",
	IDRho1:    "ρ", // U+03C1 GREEK SMALL LETTER RHO
	IDDagger1: "†", // U+2020 DAGGER
	IDDagger2: "‡", // U+2021 DOUBLE DAGGER

	// IDQNonNullptr is used by the type checker to build an artificial MType
	// for function pointers.
	IDQNonNullptr: "«NonNullptr»",

	// IDQNullptr is used by the type checker to build an artificial MType for
	// the nullptr literal.
	IDQNullptr: "«Nullptr»",

	// IDQPackage is used by the type checker to build an artificial MType for
	// used (imported) packages.
	IDQPackage: "«Package»",

	// IDQPlaceholder is used by the type checker to build an artificial MType
	// for AST nodes that aren't expression nodes or type expression nodes,
	// such as struct definition nodes and statement nodes. Its presence means
	// that the node is type checked.
	IDQPlaceholder: "«Placeholder»",

	// IDQTypeExpr is used by the type checker to build an artificial MType for
	// type expression AST nodes.
	IDQTypeExpr: "«TypeExpr»",

	// IDQIdeal is used by the type checker to build an artificial MType for
	// ideal integers (in mathematical terms, the integer ring ℤ), as opposed
	// to a realized integer type whose range is restricted. For example, the
	// base.u16 type is restricted to [0x0000, 0xFFFF].
	IDQIdeal: "«Ideal»",

	// Change MaxIntBits if a future update adds an i128 or u128 type.
	IDI8:  "i8",
	IDI16: "i16",
	IDI32: "i32",
	IDI64: "i64",
	IDU8:  "u8",
	IDU16: "u16",
	IDU32: "u32",
	IDU64: "u64",

	IDBitvec128: "bitvec128",
	IDBitvec256: "bitvec256",

	IDOptionalU63: "optional_u63",

	IDBase:            "base",
	IDBool:            "bool",
	IDEmptyIOReader:   "empty_io_reader",
	IDEmptyIOWriter:   "empty_io_writer",
	IDEmptyStruct:     "empty_struct",
	IDMoreInformation: "more_information",
	IDIOReader:        "io_reader",
	IDIOWriter:        "io_writer",
	IDStatus:          "status",
	IDTokenReader:     "token_reader",
	IDTokenWriter:     "token_writer",
	IDUtility:         "utility",

	IDRangeIEU32: "range_ie_u32",
	IDRangeIIU32: "range_ii_u32",
	IDRangeIEU64: "range_ie_u64",
	IDRangeIIU64: "range_ii_u64",
	IDRectIEU32:  "rect_ie_u32",
	IDRectIIU32:  "rect_ii_u32",

	IDFrameConfig:   "frame_config",
	IDImageConfig:   "image_config",
	IDPixelBlend:    "pixel_blend",
	IDPixelBuffer:   "pixel_buffer",
	IDPixelConfig:   "pixel_config",
	IDPixelFormat:   "pixel_format",
	IDPixelSwizzler: "pixel_swizzler",

	IDDecodeFrameOptions: "decode_frame_options",

	IDCanUndoByte:     "can_undo_byte",
	IDCountSince:      "count_since",
	IDHistoryLength:   "history_length",
	IDHistoryPosition: "history_position",
	IDIsClosed:        "is_closed",
	IDMark:            "mark",
	IDMatch15:         "match15",
	IDMatch31:         "match31",
	IDMatch7:          "match7",
	IDPosition:        "position",
	IDSince:           "since",
	IDSkip:            "skip",
	IDSkipU32:         "skip_u32",
	IDSkipU32Fast:     "skip_u32_fast",

	IDCopyFromSlice:             "copy_from_slice",
	IDLimitedCopyU32FromHistory: "limited_copy_u32_from_history",
	IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast:           "limited_copy_u32_from_history_8_byte_chunks_distance_1_fast",
	IDLimitedCopyU32FromHistory8ByteChunksDistance1FastReturnCusp: "limited_copy_u32_from_history_8_byte_chunks_distance_1_fast_return_cusp",
	IDLimitedCopyU32FromHistory8ByteChunksFast:                    "limited_copy_u32_from_history_8_byte_chunks_fast",
	IDLimitedCopyU32FromHistory8ByteChunksFastReturnCusp:          "limited_copy_u32_from_history_8_byte_chunks_fast_return_cusp",
	IDLimitedCopyU32FromHistoryFast:                               "limited_copy_u32_from_history_fast",
	IDLimitedCopyU32FromHistoryFastReturnCusp:                     "limited_copy_u32_from_history_fast_return_cusp",
	IDLimitedCopyU32FromReader:                                    "limited_copy_u32_from_reader",
	IDLimitedCopyU32FromSlice:                                     "limited_copy_u32_from_slice",
	IDLimitedCopyU32ToSlice:                                       "limited_copy_u32_to_slice",

	// -------- 0x180 block.

	IDUndoByte: "undo_byte",
	IDReadU8:   "read_u8",

	IDReadU8AsU16: "read_u8_as_u16",
	IDReadU16BE:   "read_u16be",
	IDReadU16LE:   "read_u16le",

	IDReadU8AsU32:    "read_u8_as_u32",
	IDReadU16BEAsU32: "read_u16be_as_u32",
	IDReadU16LEAsU32: "read_u16le_as_u32",
	IDReadU24BEAsU32: "read_u24be_as_u32",
	IDReadU24LEAsU32: "read_u24le_as_u32",
	IDReadU32BE:      "read_u32be",
	IDReadU32LE:      "read_u32le",

	IDReadU8AsU64:    "read_u8_as_u64",
	IDReadU16BEAsU64: "read_u16be_as_u64",
	IDReadU16LEAsU64: "read_u16le_as_u64",
	IDReadU24BEAsU64: "read_u24be_as_u64",
	IDReadU24LEAsU64: "read_u24le_as_u64",
	IDReadU32BEAsU64: "read_u32be_as_u64",
	IDReadU32LEAsU64: "read_u32le_as_u64",
	IDReadU40BEAsU64: "read_u40be_as_u64",
	IDReadU40LEAsU64: "read_u40le_as_u64",
	IDReadU48BEAsU64: "read_u48be_as_u64",
	IDReadU48LEAsU64: "read_u48le_as_u64",
	IDReadU56BEAsU64: "read_u56be_as_u64",
	IDReadU56LEAsU64: "read_u56le_as_u64",
	IDReadU64BE:      "read_u64be",
	IDReadU64LE:      "read_u64le",

	// --------

	IDPeekUndoByte: "peek_undo_byte",
	IDPeekU8:       "peek_u8",

	IDPeekU8AsU16: "peek_u8_as_u16",
	IDPeekU16BE:   "peek_u16be",
	IDPeekU16LE:   "peek_u16le",

	IDPeekU8AsU32:    "peek_u8_as_u32",
	IDPeekU16BEAsU32: "peek_u16be_as_u32",
	IDPeekU16LEAsU32: "peek_u16le_as_u32",
	IDPeekU24BEAsU32: "peek_u24be_as_u32",
	IDPeekU24LEAsU32: "peek_u24le_as_u32",
	IDPeekU32BE:      "peek_u32be",
	IDPeekU32LE:      "peek_u32le",

	IDPeekU8AsU64:    "peek_u8_as_u64",
	IDPeekU16BEAsU64: "peek_u16be_as_u64",
	IDPeekU16LEAsU64: "peek_u16le_as_u64",
	IDPeekU24BEAsU64: "peek_u24be_as_u64",
	IDPeekU24LEAsU64: "peek_u24le_as_u64",
	IDPeekU32BEAsU64: "peek_u32be_as_u64",
	IDPeekU32LEAsU64: "peek_u32le_as_u64",
	IDPeekU40BEAsU64: "peek_u40be_as_u64",
	IDPeekU40LEAsU64: "peek_u40le_as_u64",
	IDPeekU48BEAsU64: "peek_u48be_as_u64",
	IDPeekU48LEAsU64: "peek_u48le_as_u64",
	IDPeekU56BEAsU64: "peek_u56be_as_u64",
	IDPeekU56LEAsU64: "peek_u56le_as_u64",
	IDPeekU64BE:      "peek_u64be",
	IDPeekU64LE:      "peek_u64le",

	IDPeekU64LEAt: "peek_u64le_at",

	// --------

	IDWriteU8:    "write_u8",
	IDWriteU16BE: "write_u16be",
	IDWriteU16LE: "write_u16le",
	IDWriteU24BE: "write_u24be",
	IDWriteU24LE: "write_u24le",
	IDWriteU32BE: "write_u32be",
	IDWriteU32LE: "write_u32le",
	IDWriteU40BE: "write_u40be",
	IDWriteU40LE: "write_u40le",
	IDWriteU48BE: "write_u48be",
	IDWriteU48LE: "write_u48le",
	IDWriteU56BE: "write_u56be",
	IDWriteU56LE: "write_u56le",
	IDWriteU64BE: "write_u64be",
	IDWriteU64LE: "write_u64le",

	// --------

	IDPokeU8:    "poke_u8",
	IDPokeU16BE: "poke_u16be",
	IDPokeU16LE: "poke_u16le",
	IDPokeU24BE: "poke_u24be",
	IDPokeU24LE: "poke_u24le",
	IDPokeU32BE: "poke_u32be",
	IDPokeU32LE: "poke_u32le",
	IDPokeU40BE: "poke_u40be",
	IDPokeU40LE: "poke_u40le",
	IDPokeU48BE: "poke_u48be",
	IDPokeU48LE: "poke_u48le",
	IDPokeU56BE: "poke_u56be",
	IDPokeU56LE: "poke_u56le",
	IDPokeU64BE: "poke_u64be",
	IDPokeU64LE: "poke_u64le",

	// --------

	IDWriteU8Fast:    "write_u8_fast",
	IDWriteU16BEFast: "write_u16be_fast",
	IDWriteU16LEFast: "write_u16le_fast",
	IDWriteU24BEFast: "write_u24be_fast",
	IDWriteU24LEFast: "write_u24le_fast",
	IDWriteU32BEFast: "write_u32be_fast",
	IDWriteU32LEFast: "write_u32le_fast",
	IDWriteU40BEFast: "write_u40be_fast",
	IDWriteU40LEFast: "write_u40le_fast",
	IDWriteU48BEFast: "write_u48be_fast",
	IDWriteU48LEFast: "write_u48le_fast",
	IDWriteU56BEFast: "write_u56be_fast",
	IDWriteU56LEFast: "write_u56le_fast",
	IDWriteU64BEFast: "write_u64be_fast",
	IDWriteU64LEFast: "write_u64le_fast",

	// --------

	IDWriteSimpleTokenFast:   "write_simple_token_fast",
	IDWriteExtendedTokenFast: "write_extended_token_fast",

	// -------- 0x200 block.

	IDAdvance:        "advance",
	IDCPUArch:        "cpu_arch",
	IDCPUArchIs32Bit: "cpu_arch_is_32_bit",
	IDInitialize:     "initialize",
	IDLength:         "length",
	IDLikely:         "likely",
	IDReset:          "reset",
	IDSet:            "set",
	IDUnlikely:       "unlikely",
	IDUnroll:         "unroll",
	IDUpdate:         "update",

	IDHighBits: "high_bits",
	IDLowBits:  "low_bits",
	IDMax:      "max",
	IDMin:      "min",

	IDIsError:      "is_error",
	IDIsOK:         "is_ok",
	IDIsSuspension: "is_suspension",

	IDBulkLoadHostEndian: "bulk_load_host_endian",
	IDBulkMemset:         "bulk_memset",
	IDBulkSaveHostEndian: "bulk_save_host_endian",

	IDData:             "data",
	IDHeight:           "height",
	IDIO:               "io",
	IDLimit:            "limit",
	IDPrefix:           "prefix",
	IDRowU32:           "row_u32",
	IDStride:           "stride",
	IDSubtable:         "subtable",
	IDSuffix:           "suffix",
	IDUintptrLow12Bits: "uintptr_low_12_bits",
	IDValidUTF8Length:  "valid_utf_8_length",
	IDWidth:            "width",

	IDLimitedSwizzleU32InterleavedFromReader: "limited_swizzle_u32_interleaved_from_reader",
	IDSwizzleInterleavedFromReader:           "swizzle_interleaved_from_reader",

	// -------- 0x300 block.

	IDARMCRC32:        "arm_crc32",
	IDARMCRC32Utility: "arm_crc32_utility",

	IDARMCRC32U32: "arm_crc32_u32",

	IDARMNeon:        "arm_neon",
	IDARMNeonUtility: "arm_neon_utility",

	IDARMNeonU8x8:  "arm_neon_u8x8",
	IDARMNeonU16x4: "arm_neon_u16x4",
	IDARMNeonU32x2: "arm_neon_u32x2",
	IDARMNeonU64x1: "arm_neon_u64x1",

	IDARMNeonU8x16: "arm_neon_u8x16",
	IDARMNeonU16x8: "arm_neon_u16x8",
	IDARMNeonU32x4: "arm_neon_u32x4",
	IDARMNeonU64x2: "arm_neon_u64x2",

	IDX86SSE42:        "x86_sse42",
	IDX86SSE42Utility: "x86_sse42_utility",
	IDX86AVX2:         "x86_avx2",
	IDX86AVX2Utility:  "x86_avx2_utility",
	IDX86BMI2:         "x86_bmi2",

	IDX86M128I: "x86_m128i",
	IDX86M256I: "x86_m256i",
}

var builtInsByName = map[string]ID{}

func init() {
	for i, name := range builtInsByID {
		if name != "" {
			builtInsByName[name] = ID(i)
		}
	}
}

// squiggles are built-in IDs that aren't alpha-numeric.
var squiggles = [256]ID{
	'(': IDOpenParen,
	')': IDCloseParen,
	'[': IDOpenBracket,
	']': IDCloseBracket,

	',': IDComma,
	'!': IDExclam,
	'?': IDQuestion,
	':': IDColon,
	';': IDSemicolon,
}

type suffixLexer struct {
	suffix string
	id     ID
}

// lexers lex ambiguous 1-byte squiggles. For example, "&" might be the start
// of "&^" or "&=".
//
// The order of the []suffixLexer elements matters. The first match wins. Since
// we want to lex greedily, longer suffixes should be earlier in the slice.
var lexers = [256][]suffixLexer{
	'.': {
		{".=", IDDotDotEq},
		{".", IDDotDot},
		{"", IDDot},
	},
	'&': {
		{"=", IDAmpEq},
		{"", IDAmp},
	},
	'|': {
		{"=", IDPipeEq},
		{"", IDPipe},
	},
	'^': {
		{"=", IDHatEq},
		{"", IDHat},
	},
	'+': {
		{"=", IDPlusEq},
		{"", IDPlus},
	},
	'-': {
		{"=", IDMinusEq},
		{"", IDMinus},
	},
	'*': {
		{"=", IDStarEq},
		{"", IDStar},
	},
	'/': {
		{"=", IDSlashEq},
		{"", IDSlash},
	},
	'%': {
		{"=", IDPercentEq},
		{"", IDPercent},
	},
	'=': {
		{"=", IDEqEq},
		{"?", IDEqQuestion},
		{"", IDEq},
	},
	'<': {
		{"<=", IDShiftLEq},
		{"<", IDShiftL},
		{"=", IDLessEq},
		{">", IDNotEq},
		{"", IDLessThan},
	},
	'>': {
		{">=", IDShiftREq},
		{">", IDShiftR},
		{"=", IDGreaterEq},
		{"", IDGreaterThan},
	},
	'{': {
		{"{", IDOpenDoubleCurly},
		{"", IDOpenCurly},
	},
	'}': {
		{"}", IDCloseDoubleCurly},
		{"", IDCloseCurly},
	},
	'~': {
		{"mod<<=", IDTildeModShiftLEq},
		{"mod<<", IDTildeModShiftL},
		{"mod+=", IDTildeModPlusEq},
		{"mod+", IDTildeModPlus},
		{"mod-=", IDTildeModMinusEq},
		{"mod-", IDTildeModMinus},
		{"mod*=", IDTildeModStarEq},
		{"mod*", IDTildeModStar},
		{"sat+=", IDTildeSatPlusEq},
		{"sat+", IDTildeSatPlus},
		{"sat-=", IDTildeSatMinusEq},
		{"sat-", IDTildeSatMinus},
	},
}

var ambiguousForms = [nBuiltInSymbolicIDs]ID{
	IDXBinaryPlus:           IDPlus,
	IDXBinaryMinus:          IDMinus,
	IDXBinaryStar:           IDStar,
	IDXBinarySlash:          IDSlash,
	IDXBinaryShiftL:         IDShiftL,
	IDXBinaryShiftR:         IDShiftR,
	IDXBinaryAmp:            IDAmp,
	IDXBinaryPipe:           IDPipe,
	IDXBinaryHat:            IDHat,
	IDXBinaryPercent:        IDPercent,
	IDXBinaryTildeModPlus:   IDTildeModPlus,
	IDXBinaryTildeModMinus:  IDTildeModMinus,
	IDXBinaryTildeModStar:   IDTildeModStar,
	IDXBinaryTildeModShiftL: IDTildeModShiftL,
	IDXBinaryTildeSatPlus:   IDTildeSatPlus,
	IDXBinaryTildeSatMinus:  IDTildeSatMinus,
	IDXBinaryNotEq:          IDNotEq,
	IDXBinaryLessThan:       IDLessThan,
	IDXBinaryLessEq:         IDLessEq,
	IDXBinaryEqEq:           IDEqEq,
	IDXBinaryGreaterEq:      IDGreaterEq,
	IDXBinaryGreaterThan:    IDGreaterThan,
	IDXBinaryAnd:            IDAnd,
	IDXBinaryOr:             IDOr,
	IDXBinaryAs:             IDAs,

	IDXAssociativePlus: IDPlus,
	IDXAssociativeStar: IDStar,
	IDXAssociativeAmp:  IDAmp,
	IDXAssociativePipe: IDPipe,
	IDXAssociativeHat:  IDHat,
	IDXAssociativeAnd:  IDAnd,
	IDXAssociativeOr:   IDOr,

	IDXUnaryPlus:  IDPlus,
	IDXUnaryMinus: IDMinus,
	IDXUnaryNot:   IDNot,
}

func init() {
	addXForms(&unaryForms)
	addXForms(&binaryForms)
	addXForms(&associativeForms)
}

// addXForms modifies table so that, if table[x] == y, then table[y] = y.
//
// For example, for the unaryForms table, the explicit entries are like:
//
//	IDPlus:        IDXUnaryPlus,
//
// and this function implicitly addes entries like:
//
//	IDXUnaryPlus:  IDXUnaryPlus,
func addXForms(table *[nBuiltInSymbolicIDs]ID) {
	implicitEntries := [nBuiltInSymbolicIDs]bool{}
	for _, y := range table {
		if y != 0 {
			implicitEntries[y] = true
		}
	}
	for y, implicit := range implicitEntries {
		if implicit {
			table[y] = ID(y)
		}
	}
}

var binaryForms = [nBuiltInSymbolicIDs]ID{
	IDPlusEq:           IDXBinaryPlus,
	IDMinusEq:          IDXBinaryMinus,
	IDStarEq:           IDXBinaryStar,
	IDSlashEq:          IDXBinarySlash,
	IDShiftLEq:         IDXBinaryShiftL,
	IDShiftREq:         IDXBinaryShiftR,
	IDAmpEq:            IDXBinaryAmp,
	IDPipeEq:           IDXBinaryPipe,
	IDHatEq:            IDXBinaryHat,
	IDPercentEq:        IDXBinaryPercent,
	IDTildeModPlusEq:   IDXBinaryTildeModPlus,
	IDTildeModMinusEq:  IDXBinaryTildeModMinus,
	IDTildeModStarEq:   IDXBinaryTildeModStar,
	IDTildeModShiftLEq: IDXBinaryTildeModShiftL,
	IDTildeSatPlusEq:   IDXBinaryTildeSatPlus,
	IDTildeSatMinusEq:  IDXBinaryTildeSatMinus,

	IDPlus:           IDXBinaryPlus,
	IDMinus:          IDXBinaryMinus,
	IDStar:           IDXBinaryStar,
	IDSlash:          IDXBinarySlash,
	IDShiftL:         IDXBinaryShiftL,
	IDShiftR:         IDXBinaryShiftR,
	IDAmp:            IDXBinaryAmp,
	IDPipe:           IDXBinaryPipe,
	IDHat:            IDXBinaryHat,
	IDPercent:        IDXBinaryPercent,
	IDTildeModPlus:   IDXBinaryTildeModPlus,
	IDTildeModMinus:  IDXBinaryTildeModMinus,
	IDTildeModStar:   IDXBinaryTildeModStar,
	IDTildeModShiftL: IDXBinaryTildeModShiftL,
	IDTildeSatPlus:   IDXBinaryTildeSatPlus,
	IDTildeSatMinus:  IDXBinaryTildeSatMinus,

	IDNotEq:       IDXBinaryNotEq,
	IDLessThan:    IDXBinaryLessThan,
	IDLessEq:      IDXBinaryLessEq,
	IDEqEq:        IDXBinaryEqEq,
	IDGreaterEq:   IDXBinaryGreaterEq,
	IDGreaterThan: IDXBinaryGreaterThan,
	IDAnd:         IDXBinaryAnd,
	IDOr:          IDXBinaryOr,
	IDAs:          IDXBinaryAs,
}

var associativeForms = [nBuiltInSymbolicIDs]ID{
	IDPlus: IDXAssociativePlus,
	IDStar: IDXAssociativeStar,
	IDAmp:  IDXAssociativeAmp,
	IDPipe: IDXAssociativePipe,
	IDHat:  IDXAssociativeHat,
	// TODO: IDTildeModPlus, IDTildeSatPlus?
	IDAnd: IDXAssociativeAnd,
	IDOr:  IDXAssociativeOr,
}

var unaryForms = [nBuiltInSymbolicIDs]ID{
	IDPlus:  IDXUnaryPlus,
	IDMinus: IDXUnaryMinus,
	IDNot:   IDXUnaryNot,
}

var isTightLeft = [...]bool{
	IDSemicolon: true,

	IDCloseParen:   true,
	IDOpenBracket:  true,
	IDCloseBracket: true,

	IDDot:      true,
	IDComma:    true,
	IDExclam:   true,
	IDQuestion: true,
	IDColon:    true,
}

var isTightRight = [...]bool{
	IDOpenParen:   true,
	IDOpenBracket: true,

	IDDot:    true,
	IDExclam: true,
}