Files
wuffs/lang/token/list.go
T
2018-05-12 20:08:52 +10:00

944 lines
23 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
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
}
func (x ID) IsStrLiteral(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) IsOpen() bool { return x < ID(len(isOpen)) && isOpen[x] }
func (x ID) IsClose() bool { return x < ID(len(isClose)) && isClose[x] }
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) IsNumType() bool { return minNumType <= x && x <= maxNumType }
func (x ID) IsNumTypeOrIdeal() bool { return minNumTypeOrIdeal <= x && x <= maxNumTypeOrIdeal }
func (x ID) IsImplicitSemicolon(m *Map) bool {
return x.IsLiteral(m) || x.IsIdent(m) ||
(x < ID(len(isImplicitSemicolon)) && isImplicitSemicolon[x])
}
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) SmallPowerOf2Value() int {
switch x {
case ID1:
return 1
case ID2:
return 2
case ID4:
return 4
case ID8:
return 8
case ID16:
return 16
case ID32:
return 32
case ID64:
return 64
case ID128:
return 128
case ID256:
return 256
}
return 0
}
// 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{} }
// 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{} }
// 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])
}
// 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:
// - Zero is invalid.
// - [ 0x01, 0x0F] are squiggly punctuation, such as "(", ")" and ";".
// - [ 0x10, 0x1F] are squiggly assignments, such as "=" and "+=".
// - [ 0x20, 0x3F] are operators, such as "+", "==" and "not".
// - [ 0x40, 0x6F] are x-ops (disambiguation forms): unary vs binary "+".
// - [ 0x70, 0x8F] are keywords, such as "if" and "return".
// - [ 0x90, 0x93] are type modifiers, such as "ptr" and "slice".
// - [ 0x94, 0x9F] are literals, such as "false" and "true".
// - [ 0xA0, 0xFF] are reserved.
// - [0x100, 0x3FF] are identifiers, such as "bool", "u32" and "read_u8".
//
// "Squiggly" means a sequence of non-alpha-numeric characters, such as "+" and
// "&=". Roughly speaking, their IDs range in [0x01, 0x3F], or disambiguation
// forms range in [0x40, 0x6F], but vice versa does not necessarily hold. For
// example, the "and" operator is not "squiggly" but it is within [0x01, 0x3F].
const (
nBuiltInSymbolicIDs = ID(0x70) // 112
nBuiltInIDs = ID(0x400) // 1024
)
const (
IDInvalid = ID(0)
IDOpenParen = ID(0x02)
IDCloseParen = ID(0x03)
IDOpenBracket = ID(0x04)
IDCloseBracket = ID(0x05)
IDOpenCurly = ID(0x06)
IDCloseCurly = ID(0x07)
IDDot = ID(0x08)
IDDotDot = ID(0x09)
IDComma = ID(0x0A)
IDExclam = ID(0x0B)
IDQuestion = ID(0x0C)
IDColon = ID(0x0D)
IDSemicolon = ID(0x0E)
IDDollar = ID(0x0F)
)
const (
minAssign = 0x10
maxAssign = 0x1F
IDEq = ID(0x10)
IDPlusEq = ID(0x11)
IDMinusEq = ID(0x12)
IDStarEq = ID(0x13)
IDSlashEq = ID(0x14)
IDShiftLEq = ID(0x15)
IDShiftREq = ID(0x16)
IDAmpEq = ID(0x17)
IDPipeEq = ID(0x18)
IDHatEq = ID(0x19)
IDPercentEq = ID(0x1A)
IDTildeModPlusEq = ID(0x1B)
IDTildeModMinusEq = ID(0x1C)
IDTildeSatPlusEq = ID(0x1D)
IDTildeSatMinusEq = ID(0x1E)
IDEqColon = ID(0x1F)
)
const (
minOp = 0x20
minAmbiguousOp = 0x20
maxAmbiguousOp = 0x3F
minXOp = 0x40
maxXOp = 0x6F
maxOp = 0x6F
IDPlus = ID(0x21)
IDMinus = ID(0x22)
IDStar = ID(0x23)
IDSlash = ID(0x24)
IDShiftL = ID(0x25)
IDShiftR = ID(0x26)
IDAmp = ID(0x27)
IDPipe = ID(0x28)
IDHat = ID(0x29)
IDPercent = ID(0x2A)
IDTildeModPlus = ID(0x2B)
IDTildeModMinus = ID(0x2C)
IDTildeSatPlus = ID(0x2D)
IDTildeSatMinus = ID(0x2E)
IDNotEq = ID(0x30)
IDLessThan = ID(0x31)
IDLessEq = ID(0x32)
IDEqEq = ID(0x33)
IDGreaterEq = ID(0x34)
IDGreaterThan = ID(0x35)
IDAnd = ID(0x38)
IDOr = ID(0x39)
IDNot = ID(0x3A)
IDAs = ID(0x3B)
// TODO: are these unused? Can we drop them (and their XUnary forms)?
IDRef = ID(0x3C)
IDDeref = ID(0x3D)
// 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.
IDXUnaryPlus = ID(0x40)
IDXUnaryMinus = ID(0x41)
IDXUnaryNot = ID(0x42)
IDXUnaryRef = ID(0x43)
IDXUnaryDeref = ID(0x44)
IDXBinaryPlus = ID(0x48)
IDXBinaryMinus = ID(0x49)
IDXBinaryStar = ID(0x4A)
IDXBinarySlash = ID(0x4B)
IDXBinaryShiftL = ID(0x4C)
IDXBinaryShiftR = ID(0x4D)
IDXBinaryAmp = ID(0x4E)
IDXBinaryPipe = ID(0x4F)
IDXBinaryHat = ID(0x50)
IDXBinaryPercent = ID(0x51)
IDXBinaryTildeModPlus = ID(0x52)
IDXBinaryTildeModMinus = ID(0x53)
IDXBinaryTildeSatPlus = ID(0x54)
IDXBinaryTildeSatMinus = ID(0x55)
IDXBinaryNotEq = ID(0x56)
IDXBinaryLessThan = ID(0x57)
IDXBinaryLessEq = ID(0x58)
IDXBinaryEqEq = ID(0x59)
IDXBinaryGreaterEq = ID(0x5A)
IDXBinaryGreaterThan = ID(0x5B)
IDXBinaryAnd = ID(0x5C)
IDXBinaryOr = ID(0x5D)
IDXBinaryAs = ID(0x5E)
IDXAssociativePlus = ID(0x60)
IDXAssociativeStar = ID(0x61)
IDXAssociativeAmp = ID(0x62)
IDXAssociativePipe = ID(0x63)
IDXAssociativeHat = ID(0x64)
IDXAssociativeAnd = ID(0x65)
IDXAssociativeOr = ID(0x66)
)
const (
minKeyword = 0x70
maxKeyword = 0x8F
// TODO: sort these by name, when the list has stabilized.
IDFunc = ID(0x70)
IDAssert = ID(0x71)
IDWhile = ID(0x72)
IDIf = ID(0x73)
IDElse = ID(0x74)
IDReturn = ID(0x75)
IDBreak = ID(0x76)
IDContinue = ID(0x77)
IDStruct = ID(0x78)
IDUse = ID(0x79)
IDVar = ID(0x7A)
IDPre = ID(0x7B)
IDInv = ID(0x7C)
IDPost = ID(0x7D)
IDVia = ID(0x7E)
IDPub = ID(0x7F)
IDPri = ID(0x80)
IDError = ID(0x81)
IDSuspension = ID(0x82)
IDPackageID = ID(0x83)
IDConst = ID(0x84)
IDTry = ID(0x85)
IDIterate = ID(0x86)
IDYield = ID(0x87)
IDIOBind = ID(0x88)
)
const (
minTypeModifier = 0x90
maxTypeModifier = 0x93
IDArray = ID(0x90)
IDNptr = ID(0x91)
IDPtr = ID(0x92)
IDSlice = ID(0x93)
)
const (
minBuiltInLiteral = 0x94
minBuiltInNumLiteral = 0x96
maxBuiltInNumLiteral = 0x9F
maxBuiltInLiteral = 0x9F
IDFalse = ID(0x94)
IDTrue = ID(0x95)
ID0 = ID(0x96)
ID1 = ID(0x97)
ID2 = ID(0x98)
ID4 = ID(0x99)
ID8 = ID(0x9A)
ID16 = ID(0x9B)
ID32 = ID(0x9C)
ID64 = ID(0x9D)
ID128 = ID(0x9E)
ID256 = ID(0x9F)
)
const (
minBuiltInIdent = 0x100
minNumTypeOrIdeal = 0x10F
minNumType = 0x110
maxNumType = 0x117
maxNumTypeOrIdeal = 0x117
maxBuiltInIdent = 0x3FF
// -------- 0x100 block.
IDEmptyStruct = ID(0x100)
IDBool = ID(0x101)
IDStatus = ID(0x102)
IDIOReader = ID(0x103)
IDIOWriter = ID(0x104)
IDCapitalT = ID(0x105)
IDImageConfig = ID(0x106)
IDDiamond = ID(0x10E)
// It is important that IDDoubleZ is right next to the IDI8..IDU64 block.
// See the ID.IsNumTypeOrIdeal method.
IDDoubleZ = 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)
// TODO Read/Write 24 bits? It might be useful for RGB triples.
IDUnreadU8 = ID(0x120)
IDReadU8 = ID(0x121)
IDReadU16BE = ID(0x122)
IDReadU16LE = ID(0x123)
IDReadU32BE = ID(0x124)
IDReadU32LE = ID(0x125)
IDReadU64BE = ID(0x126)
IDReadU64LE = ID(0x127)
// TODO: IDUnwriteU8?
IDWriteU8 = ID(0x131)
IDWriteU16BE = ID(0x132)
IDWriteU16LE = ID(0x133)
IDWriteU32BE = ID(0x134)
IDWriteU32LE = ID(0x135)
IDWriteU64BE = ID(0x136)
IDWriteU64LE = ID(0x137)
IDUnderscore = ID(0x140)
IDThis = ID(0x141)
IDIn = ID(0x142)
IDOut = ID(0x143)
IDBase = ID(0x144)
IDReset = ID(0x145)
// -------- 0x200 block.
IDIsError = ID(0x200)
IDIsOK = ID(0x201)
IDIsSuspension = ID(0x202)
IDCopyFromHistory32 = ID(0x203)
IDCopyFromReader32 = ID(0x204)
IDCopyFromSlice = ID(0x205)
IDCopyFromSlice32 = ID(0x206)
IDSkip32 = ID(0x207)
IDSkip64 = ID(0x208)
IDLength = ID(0x209)
IDAvailable = ID(0x20A)
IDPrefix = ID(0x20B)
IDSuffix = ID(0x20C)
IDSetLimit = ID(0x20D)
IDLowBits = ID(0x20E)
IDHighBits = ID(0x20F)
IDUnroll = ID(0x210)
IDSetMark = ID(0x211)
IDSinceMark = ID(0x212)
IDMax = ID(0x213)
IDMin = ID(0x214)
)
var builtInsByID = [nBuiltInIDs]string{
IDOpenParen: "(",
IDCloseParen: ")",
IDOpenBracket: "[",
IDCloseBracket: "]",
IDOpenCurly: "{",
IDCloseCurly: "}",
IDDot: ".",
IDDotDot: "..",
IDComma: ",",
IDExclam: "!",
IDQuestion: "?",
IDColon: ":",
IDSemicolon: ";",
IDDollar: "$",
IDEq: "=",
IDPlusEq: "+=",
IDMinusEq: "-=",
IDStarEq: "*=",
IDSlashEq: "/=",
IDShiftLEq: "<<=",
IDShiftREq: ">>=",
IDAmpEq: "&=",
IDPipeEq: "|=",
IDHatEq: "^=",
IDPercentEq: "%=",
IDTildeModPlusEq: "~mod+=",
IDTildeModMinusEq: "~mod-=",
IDTildeSatPlusEq: "~sat+=",
IDTildeSatMinusEq: "~sat-=",
IDEqColon: "=:",
IDPlus: "+",
IDMinus: "-",
IDStar: "*",
IDSlash: "/",
IDShiftL: "<<",
IDShiftR: ">>",
IDAmp: "&",
IDPipe: "|",
IDHat: "^",
IDPercent: "%",
IDTildeModPlus: "~mod+",
IDTildeModMinus: "~mod-",
IDTildeSatPlus: "~sat+",
IDTildeSatMinus: "~sat-",
IDNotEq: "!=",
IDLessThan: "<",
IDLessEq: "<=",
IDEqEq: "==",
IDGreaterEq: ">=",
IDGreaterThan: ">",
IDAnd: "and",
IDOr: "or",
IDNot: "not",
IDAs: "as",
IDRef: "ref",
IDDeref: "deref",
IDFunc: "func",
IDAssert: "assert",
IDWhile: "while",
IDIf: "if",
IDElse: "else",
IDReturn: "return",
IDBreak: "break",
IDContinue: "continue",
IDStruct: "struct",
IDUse: "use",
IDVar: "var",
IDPre: "pre",
IDInv: "inv",
IDPost: "post",
IDVia: "via",
IDPub: "pub",
IDPri: "pri",
IDError: "error",
IDSuspension: "suspension",
IDPackageID: "packageid",
IDConst: "const",
IDTry: "try",
IDIterate: "iterate",
IDYield: "yield",
IDIOBind: "io_bind",
IDArray: "array",
IDNptr: "nptr",
IDPtr: "ptr",
IDSlice: "slice",
IDFalse: "false",
IDTrue: "true",
ID0: "0",
ID1: "1",
ID2: "2",
ID4: "4",
ID8: "8",
ID16: "16",
ID32: "32",
ID64: "64",
ID128: "128",
ID256: "256",
// -------- 0x100 block.
IDEmptyStruct: "empty_struct",
IDBool: "bool",
IDStatus: "status",
IDIOReader: "io_reader",
IDIOWriter: "io_writer",
IDCapitalT: "T",
IDImageConfig: "image_config",
// IDDiamond and IDDoubleZ are never returned by the tokenizer, as the
// tokenizer rejects non-ASCII input.
//
// The string representations ""◊ and "ℤ" are specifically non-ASCII so
// that no user-defined (non built-in) identifier will conflict with them.
// IDDiamond is used by the type checker as a dummy-valued built-in ID to
// represent a generic type.
IDDiamond: "◊", // U+25C7 WHITE DIAMOND
// IDDoubleZ is used by the type checker as a dummy-valued built-in ID to
// represent an ideal integer type (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].
IDDoubleZ: "ℤ", // U+2124 DOUBLE-STRUCK CAPITAL Z
// 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",
IDUnreadU8: "unread_u8",
IDReadU8: "read_u8",
IDReadU16BE: "read_u16be",
IDReadU16LE: "read_u16le",
IDReadU32BE: "read_u32be",
IDReadU32LE: "read_u32le",
IDReadU64BE: "read_u64be",
IDReadU64LE: "read_u64le",
IDWriteU8: "write_u8",
IDWriteU16BE: "write_u16be",
IDWriteU16LE: "write_u16le",
IDWriteU32BE: "write_u32be",
IDWriteU32LE: "write_u32le",
IDWriteU64BE: "write_u64be",
IDWriteU64LE: "write_u64le",
IDUnderscore: "_",
IDThis: "this",
IDIn: "in",
IDOut: "out",
IDBase: "base",
IDReset: "reset",
// -------- 0x200 block.
IDIsError: "is_error",
IDIsOK: "is_ok",
IDIsSuspension: "is_suspension",
IDCopyFromHistory32: "copy_from_history32",
IDCopyFromReader32: "copy_from_reader32",
IDCopyFromSlice: "copy_from_slice",
IDCopyFromSlice32: "copy_from_slice32",
IDSkip32: "skip32",
IDSkip64: "skip64",
IDLength: "length",
IDAvailable: "available",
IDPrefix: "prefix",
IDSuffix: "suffix",
IDSetLimit: "set_limit",
IDLowBits: "low_bits",
IDHighBits: "high_bits",
IDUnroll: "unroll",
IDSetMark: "set_mark",
IDSinceMark: "since_mark",
IDMax: "max",
IDMin: "min",
}
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,
'{': IDOpenCurly,
'}': IDCloseCurly,
',': IDComma,
'?': IDQuestion,
':': IDColon,
';': IDSemicolon,
'$': IDDollar,
}
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{
'.': {
{".", IDDotDot},
{"", IDDot},
},
'!': {
{"=", IDNotEq},
{"", IDExclam},
},
'&': {
{"=", IDAmpEq},
{"", IDAmp},
},
'|': {
{"=", IDPipeEq},
{"", IDPipe},
},
'^': {
{"=", IDHatEq},
{"", IDHat},
},
'+': {
{"=", IDPlusEq},
{"", IDPlus},
},
'-': {
{"=", IDMinusEq},
{"", IDMinus},
},
'*': {
{"=", IDStarEq},
{"", IDStar},
},
'/': {
{"=", IDSlashEq},
{"", IDSlash},
},
'%': {
{"=", IDPercentEq},
{"", IDPercent},
},
'=': {
{"=", IDEqEq},
{":", IDEqColon},
{"", IDEq},
},
'<': {
{"<=", IDShiftLEq},
{"<", IDShiftL},
{"=", IDLessEq},
{"", IDLessThan},
},
'>': {
{">=", IDShiftREq},
{">", IDShiftR},
{"=", IDGreaterEq},
{"", IDGreaterThan},
},
'~': {
{"mod+=", IDTildeModPlusEq},
{"mod+", IDTildeModPlus},
{"mod-=", IDTildeModMinusEq},
{"mod-", IDTildeModMinus},
{"sat+=", IDTildeSatPlusEq},
{"sat+", IDTildeSatPlus},
{"sat-=", IDTildeSatMinusEq},
{"sat-", IDTildeSatMinus},
},
}
var ambiguousForms = [nBuiltInSymbolicIDs]ID{
IDXUnaryPlus: IDPlus,
IDXUnaryMinus: IDMinus,
IDXUnaryNot: IDNot,
IDXUnaryRef: IDRef,
IDXUnaryDeref: IDDeref,
IDXBinaryPlus: IDPlus,
IDXBinaryMinus: IDMinus,
IDXBinaryStar: IDStar,
IDXBinarySlash: IDSlash,
IDXBinaryShiftL: IDShiftL,
IDXBinaryShiftR: IDShiftR,
IDXBinaryAmp: IDAmp,
IDXBinaryPipe: IDPipe,
IDXBinaryHat: IDHat,
IDXBinaryPercent: IDPercent,
IDXBinaryTildeModPlus: IDTildeModPlus,
IDXBinaryTildeModMinus: IDTildeModMinus,
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,
}
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 unaryForms = [nBuiltInSymbolicIDs]ID{
IDPlus: IDXUnaryPlus,
IDMinus: IDXUnaryMinus,
IDNot: IDXUnaryNot,
IDRef: IDXUnaryRef,
IDDeref: IDXUnaryDeref,
}
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,
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,
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 isOpen = [...]bool{
IDOpenParen: true,
IDOpenBracket: true,
IDOpenCurly: true,
}
var isClose = [...]bool{
IDCloseParen: true,
IDCloseBracket: true,
IDCloseCurly: true,
}
var isTightLeft = [...]bool{
IDCloseParen: true,
IDOpenBracket: true,
IDCloseBracket: true,
IDDot: true,
IDDotDot: true,
IDComma: true,
IDExclam: true,
IDQuestion: true,
IDColon: true,
IDSemicolon: true,
}
var isTightRight = [...]bool{
IDOpenParen: true,
IDOpenBracket: true,
IDDot: true,
IDDotDot: true,
IDExclam: true,
IDQuestion: true,
IDColon: true,
IDDollar: true,
}
var isImplicitSemicolon = [...]bool{
IDCloseParen: true,
IDCloseBracket: true,
IDCloseCurly: true,
IDReturn: true,
IDBreak: true,
IDContinue: true,
}