token

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2017 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	FlagsOther             = Flags(0x0001)
	FlagsUnaryOp           = Flags(0x0002)
	FlagsBinaryOp          = Flags(0x0004)
	FlagsAssociativeOp     = Flags(0x0008)
	FlagsLiteral           = Flags(0x0010)
	FlagsNumLiteral        = Flags(0x0020)
	FlagsStrLiteral        = Flags(0x0040)
	FlagsIdent             = Flags(0x0080)
	FlagsOpen              = Flags(0x0100)
	FlagsClose             = Flags(0x0200)
	FlagsTightLeft         = Flags(0x0400)
	FlagsTightRight        = Flags(0x0800)
	FlagsAssign            = Flags(0x1000)
	FlagsImplicitSemicolon = Flags(0x2000)
	FlagsNumType           = Flags(0x4000)
)
View Source 
const (
	FlagsBits = 16
	FlagsMask = 1<<FlagsBits - 1
	KeyBits   = 32 - FlagsBits
	KeyShift  = FlagsBits
)
View Source 
const (
	KeyInvalid = Key(0)

	KeyDoubleZ = Key(IDDoubleZ >> KeyShift)

	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)
	KeyDotDot    = Key(IDDotDot >> KeyShift)
	KeyComma     = Key(IDComma >> KeyShift)
	KeyExclam    = Key(IDExclam >> KeyShift)
	KeyQuestion  = Key(IDQuestion >> KeyShift)
	KeyColon     = Key(IDColon >> KeyShift)
	KeySemicolon = Key(IDSemicolon >> KeyShift)
	KeyDollar    = Key(IDDollar >> 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)
	KeyPercentEq   = Key(IDPercentEq >> KeyShift)
	KeyTildePlusEq = Key(IDTildePlusEq >> 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)
	KeyPercent   = Key(IDPercent >> KeyShift)
	KeyTildePlus = Key(IDTildePlus >> 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)
	KeyRef   = Key(IDRef >> KeyShift)
	KeyDeref = Key(IDDeref >> 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)
	KeyNptr       = Key(IDNptr >> KeyShift)
	KeyPre        = Key(IDPre >> KeyShift)
	KeyInv        = Key(IDInv >> KeyShift)
	KeyPost       = Key(IDPost >> KeyShift)
	KeyVia        = Key(IDVia >> KeyShift)
	KeyPub        = Key(IDPub >> KeyShift)
	KeyPri        = Key(IDPri >> KeyShift)
	KeyError      = Key(IDError >> KeyShift)
	KeySuspension = Key(IDSuspension >> KeyShift)
	KeyPackageID  = Key(IDPackageID >> KeyShift)
	KeyConst      = Key(IDConst >> KeyShift)
	KeyTry        = Key(IDTry >> KeyShift)
	KeyIterate    = Key(IDIterate >> KeyShift)

	KeyFalse = Key(IDFalse >> KeyShift)
	KeyTrue  = Key(IDTrue >> KeyShift)
	KeyZero  = Key(IDZero >> KeyShift)

	KeyUnderscore = Key(IDUnderscore >> KeyShift)
	KeyThis       = Key(IDThis >> KeyShift)
	KeyIn         = Key(IDIn >> KeyShift)
	KeyOut        = Key(IDOut >> 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)
	KeyReader1 = Key(IDReader1 >> KeyShift)
	KeyWriter1 = Key(IDWriter1 >> KeyShift)
	KeyBuf2    = Key(IDBuf2 >> KeyShift)
	KeyStatus  = Key(IDStatus >> KeyShift)

	KeyMark       = Key(IDMark >> KeyShift)
	KeyReadU8     = Key(IDReadU8 >> KeyShift)
	KeyReadU16BE  = Key(IDReadU16BE >> KeyShift)
	KeyReadU16LE  = Key(IDReadU16LE >> KeyShift)
	KeyReadU32BE  = Key(IDReadU32BE >> KeyShift)
	KeyReadU32LE  = Key(IDReadU32LE >> KeyShift)
	KeyReadU64BE  = Key(IDReadU64BE >> KeyShift)
	KeyReadU64LE  = Key(IDReadU64LE >> KeyShift)
	KeySinceMark  = Key(IDSinceMark >> KeyShift)
	KeyWriteU8    = Key(IDWriteU8 >> KeyShift)
	KeyWriteU16BE = Key(IDWriteU16BE >> KeyShift)
	KeyWriteU16LE = Key(IDWriteU16LE >> KeyShift)
	KeyWriteU32BE = Key(IDWriteU32BE >> KeyShift)
	KeyWriteU32LE = Key(IDWriteU32LE >> KeyShift)
	KeyWriteU64BE = Key(IDWriteU64BE >> KeyShift)
	KeyWriteU64LE = Key(IDWriteU64LE >> KeyShift)

	KeyIsError           = Key(IDIsError >> KeyShift)
	KeyIsOK              = Key(IDIsOK >> KeyShift)
	KeyIsSuspension      = Key(IDIsSuspension >> KeyShift)
	KeyCopyFromHistory32 = Key(IDCopyFromHistory32 >> KeyShift)
	KeyCopyFromReader32  = Key(IDCopyFromReader32 >> KeyShift)
	KeyCopyFromSlice     = Key(IDCopyFromSlice >> KeyShift)
	KeyCopyFromSlice32   = Key(IDCopyFromSlice32 >> KeyShift)
	KeySkip32            = Key(IDSkip32 >> KeyShift)
	KeySkip64            = Key(IDSkip64 >> KeyShift)
	KeyLength            = Key(IDLength >> KeyShift)
	KeyAvailable         = Key(IDAvailable >> KeyShift)
	KeyPrefix            = Key(IDPrefix >> KeyShift)
	KeySuffix            = Key(IDSuffix >> KeyShift)
	KeyLimit             = Key(IDLimit >> KeyShift)
	KeyLowBits           = Key(IDLowBits >> KeyShift)
	KeyHighBits          = Key(IDHighBits >> KeyShift)
	KeyUnreadU8          = Key(IDUnreadU8 >> KeyShift)
	KeyIsMarked          = Key(IDIsMarked >> KeyShift)

	KeyXUnaryPlus  = Key(IDXUnaryPlus >> KeyShift)
	KeyXUnaryMinus = Key(IDXUnaryMinus >> KeyShift)
	KeyXUnaryNot   = Key(IDXUnaryNot >> KeyShift)
	KeyXUnaryRef   = Key(IDXUnaryRef >> KeyShift)
	KeyXUnaryDeref = Key(IDXUnaryDeref >> 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)
	KeyXBinaryPercent     = Key(IDXBinaryPercent >> 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)
	KeyXBinaryTildePlus   = Key(IDXBinaryTildePlus >> 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)
)
View Source 
const (
	IDInvalid = ID(0)

	IDDoubleZ = ID(0x01<<KeyShift | FlagsOther)

	IDOpenParen    = ID(0x10<<KeyShift | FlagsOpen | FlagsTightRight)
	IDCloseParen   = ID(0x11<<KeyShift | FlagsClose | FlagsTightLeft | FlagsImplicitSemicolon)
	IDOpenBracket  = ID(0x12<<KeyShift | FlagsOpen | FlagsTightLeft | FlagsTightRight)
	IDCloseBracket = ID(0x13<<KeyShift | FlagsClose | FlagsTightLeft | FlagsImplicitSemicolon)
	IDOpenCurly    = ID(0x14<<KeyShift | FlagsOpen)
	IDCloseCurly   = ID(0x15<<KeyShift | FlagsClose | FlagsImplicitSemicolon)

	IDDot       = ID(0x18<<KeyShift | FlagsTightLeft | FlagsTightRight)
	IDDotDot    = ID(0x19<<KeyShift | FlagsTightLeft | FlagsTightRight)
	IDComma     = ID(0x1A<<KeyShift | FlagsTightLeft)
	IDExclam    = ID(0x1B<<KeyShift | FlagsTightLeft | FlagsTightRight)
	IDQuestion  = ID(0x1C<<KeyShift | FlagsTightLeft | FlagsTightRight)
	IDColon     = ID(0x1D<<KeyShift | FlagsTightLeft | FlagsTightRight)
	IDSemicolon = ID(0x1E<<KeyShift | FlagsTightLeft)
	IDDollar    = ID(0x1F<<KeyShift | FlagsTightRight)

	IDEq          = ID(0x20<<KeyShift | FlagsAssign)
	IDPlusEq      = ID(0x21<<KeyShift | FlagsAssign)
	IDMinusEq     = ID(0x22<<KeyShift | FlagsAssign)
	IDStarEq      = ID(0x23<<KeyShift | FlagsAssign)
	IDSlashEq     = ID(0x24<<KeyShift | FlagsAssign)
	IDShiftLEq    = ID(0x25<<KeyShift | FlagsAssign)
	IDShiftREq    = ID(0x26<<KeyShift | FlagsAssign)
	IDAmpEq       = ID(0x27<<KeyShift | FlagsAssign)
	IDAmpHatEq    = ID(0x28<<KeyShift | FlagsAssign)
	IDPipeEq      = ID(0x29<<KeyShift | FlagsAssign)
	IDHatEq       = ID(0x2A<<KeyShift | FlagsAssign)
	IDPercentEq   = ID(0x2B<<KeyShift | FlagsAssign)
	IDTildePlusEq = ID(0x2C<<KeyShift | FlagsAssign)

	IDPlus      = ID(0x31<<KeyShift | FlagsBinaryOp | FlagsUnaryOp | FlagsAssociativeOp)
	IDMinus     = ID(0x32<<KeyShift | FlagsBinaryOp | FlagsUnaryOp)
	IDStar      = ID(0x33<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDSlash     = ID(0x34<<KeyShift | FlagsBinaryOp)
	IDShiftL    = ID(0x35<<KeyShift | FlagsBinaryOp)
	IDShiftR    = ID(0x36<<KeyShift | FlagsBinaryOp)
	IDAmp       = ID(0x37<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDAmpHat    = ID(0x38<<KeyShift | FlagsBinaryOp)
	IDPipe      = ID(0x39<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDHat       = ID(0x3A<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDPercent   = ID(0x3B<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDTildePlus = ID(0x3C<<KeyShift | FlagsBinaryOp) // TODO: FlagsAssociativeOp?

	IDNotEq       = ID(0x40<<KeyShift | FlagsBinaryOp)
	IDLessThan    = ID(0x41<<KeyShift | FlagsBinaryOp)
	IDLessEq      = ID(0x42<<KeyShift | FlagsBinaryOp)
	IDEqEq        = ID(0x43<<KeyShift | FlagsBinaryOp)
	IDGreaterEq   = ID(0x44<<KeyShift | FlagsBinaryOp)
	IDGreaterThan = ID(0x45<<KeyShift | FlagsBinaryOp)

	// TODO: sort these by name, when the list has stabilized.
	IDAnd   = ID(0x48<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDOr    = ID(0x49<<KeyShift | FlagsBinaryOp | FlagsAssociativeOp)
	IDNot   = ID(0x4A<<KeyShift | FlagsUnaryOp)
	IDAs    = ID(0x4B<<KeyShift | FlagsBinaryOp)
	IDRef   = ID(0x4C<<KeyShift | FlagsUnaryOp)
	IDDeref = ID(0x4D<<KeyShift | FlagsUnaryOp)

	// TODO: sort these by name, when the list has stabilized.
	IDFunc       = ID(0x50<<KeyShift | FlagsOther)
	IDPtr        = ID(0x51<<KeyShift | FlagsOther)
	IDAssert     = ID(0x52<<KeyShift | FlagsOther)
	IDWhile      = ID(0x53<<KeyShift | FlagsOther)
	IDIf         = ID(0x54<<KeyShift | FlagsOther)
	IDElse       = ID(0x55<<KeyShift | FlagsOther)
	IDReturn     = ID(0x56<<KeyShift | FlagsOther | FlagsImplicitSemicolon)
	IDBreak      = ID(0x57<<KeyShift | FlagsOther | FlagsImplicitSemicolon)
	IDContinue   = ID(0x58<<KeyShift | FlagsOther | FlagsImplicitSemicolon)
	IDStruct     = ID(0x59<<KeyShift | FlagsOther)
	IDUse        = ID(0x5A<<KeyShift | FlagsOther)
	IDVar        = ID(0x5B<<KeyShift | FlagsOther)
	IDNptr       = ID(0x5C<<KeyShift | FlagsOther)
	IDPre        = ID(0x5D<<KeyShift | FlagsOther)
	IDInv        = ID(0x5E<<KeyShift | FlagsOther)
	IDPost       = ID(0x5F<<KeyShift | FlagsOther)
	IDVia        = ID(0x60<<KeyShift | FlagsOther)
	IDPub        = ID(0x61<<KeyShift | FlagsOther)
	IDPri        = ID(0x62<<KeyShift | FlagsOther)
	IDError      = ID(0x63<<KeyShift | FlagsOther)
	IDSuspension = ID(0x64<<KeyShift | FlagsOther)
	IDPackageID  = ID(0x65<<KeyShift | FlagsOther)
	IDConst      = ID(0x66<<KeyShift | FlagsOther)
	IDTry        = ID(0x67<<KeyShift | FlagsOther)
	IDIterate    = ID(0x68<<KeyShift | FlagsOther)

	IDFalse = ID(0x70<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
	IDTrue  = ID(0x71<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
	IDZero  = ID(0x72<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon | FlagsNumLiteral)

	IDUnderscore = ID(0x78<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDThis       = ID(0x79<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDIn         = ID(0x7A<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDOut        = ID(0x7B<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)

	IDI8      = ID(0x80<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDI16     = ID(0x81<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDI32     = ID(0x82<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDI64     = ID(0x83<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDU8      = ID(0x84<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDU16     = ID(0x85<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDU32     = ID(0x86<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDU64     = ID(0x87<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDUsize   = ID(0x88<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
	IDBool    = ID(0x89<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDBuf1    = ID(0x8A<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReader1 = ID(0x8B<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriter1 = ID(0x8C<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDBuf2    = ID(0x8D<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDStatus  = ID(0x8E<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)

	IDMark       = ID(0x90<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU8     = ID(0x91<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU16BE  = ID(0x92<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU16LE  = ID(0x93<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU32BE  = ID(0x94<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU32LE  = ID(0x95<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU64BE  = ID(0x96<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDReadU64LE  = ID(0x97<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDSinceMark  = ID(0x98<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU8    = ID(0x99<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU16BE = ID(0x9A<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU16LE = ID(0x9B<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU32BE = ID(0x9C<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU32LE = ID(0x9D<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU64BE = ID(0x9E<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDWriteU64LE = ID(0x9F<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)

	IDIsError           = ID(0xA0<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDIsOK              = ID(0xA1<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDIsSuspension      = ID(0xA2<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDCopyFromHistory32 = ID(0xA3<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDCopyFromReader32  = ID(0xA4<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDCopyFromSlice     = ID(0xA5<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDCopyFromSlice32   = ID(0xA6<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDSkip32            = ID(0xA7<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDSkip64            = ID(0xA8<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDLength            = ID(0xA9<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDAvailable         = ID(0xAA<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDPrefix            = ID(0xAB<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDSuffix            = ID(0xAC<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDLimit             = ID(0xAD<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDLowBits           = ID(0xAE<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDHighBits          = ID(0xAF<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDUnreadU8          = ID(0xB0<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
	IDIsMarked          = ID(0xB1<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
)
View Source 
const (
	IDXUnaryPlus  = ID(0xD0<<KeyShift | FlagsUnaryOp)
	IDXUnaryMinus = ID(0xD1<<KeyShift | FlagsUnaryOp)
	IDXUnaryNot   = ID(0xD2<<KeyShift | FlagsUnaryOp)
	IDXUnaryRef   = ID(0xD3<<KeyShift | FlagsUnaryOp)
	IDXUnaryDeref = ID(0xD4<<KeyShift | FlagsUnaryOp)

	IDXBinaryPlus        = ID(0xD8<<KeyShift | FlagsBinaryOp)
	IDXBinaryMinus       = ID(0xD9<<KeyShift | FlagsBinaryOp)
	IDXBinaryStar        = ID(0xDA<<KeyShift | FlagsBinaryOp)
	IDXBinarySlash       = ID(0xDB<<KeyShift | FlagsBinaryOp)
	IDXBinaryShiftL      = ID(0xDC<<KeyShift | FlagsBinaryOp)
	IDXBinaryShiftR      = ID(0xDD<<KeyShift | FlagsBinaryOp)
	IDXBinaryAmp         = ID(0xDE<<KeyShift | FlagsBinaryOp)
	IDXBinaryAmpHat      = ID(0xDF<<KeyShift | FlagsBinaryOp)
	IDXBinaryPipe        = ID(0xE0<<KeyShift | FlagsBinaryOp)
	IDXBinaryHat         = ID(0xE1<<KeyShift | FlagsBinaryOp)
	IDXBinaryPercent     = ID(0xE2<<KeyShift | FlagsBinaryOp)
	IDXBinaryNotEq       = ID(0xE3<<KeyShift | FlagsBinaryOp)
	IDXBinaryLessThan    = ID(0xE4<<KeyShift | FlagsBinaryOp)
	IDXBinaryLessEq      = ID(0xE5<<KeyShift | FlagsBinaryOp)
	IDXBinaryEqEq        = ID(0xE6<<KeyShift | FlagsBinaryOp)
	IDXBinaryGreaterEq   = ID(0xE7<<KeyShift | FlagsBinaryOp)
	IDXBinaryGreaterThan = ID(0xE8<<KeyShift | FlagsBinaryOp)
	IDXBinaryAnd         = ID(0xE9<<KeyShift | FlagsBinaryOp)
	IDXBinaryOr          = ID(0xEA<<KeyShift | FlagsBinaryOp)
	IDXBinaryAs          = ID(0xEB<<KeyShift | FlagsBinaryOp)
	IDXBinaryTildePlus   = ID(0xEC<<KeyShift | FlagsBinaryOp)

	IDXAssociativePlus = ID(0xF0<<KeyShift | FlagsAssociativeOp)
	IDXAssociativeStar = ID(0xF1<<KeyShift | FlagsAssociativeOp)
	IDXAssociativeAmp  = ID(0xF2<<KeyShift | FlagsAssociativeOp)
	IDXAssociativePipe = ID(0xF3<<KeyShift | FlagsAssociativeOp)
	IDXAssociativeHat  = ID(0xF4<<KeyShift | FlagsAssociativeOp)
	IDXAssociativeAnd  = ID(0xF5<<KeyShift | FlagsAssociativeOp)
	IDXAssociativeOr   = ID(0xF6<<KeyShift | FlagsAssociativeOp)
)

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.

View Source 
const MaxIntBits = 64

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

Variables

This section is empty.

Functions

func Unescape 

func Unescape(s string) (unescaped string, ok bool)

Types

type Flags 

type Flags uint32

Flags are the low 16 bits of an ID. For example, they signify whether a token is an operator, an identifier, etc.

The flags are not exclusive. For example, the "+" token is both a unary and binary operator. It is also associative: (a + b) + c equals a + (b + c).

A valid token will have non-zero flags. If none of the other flags apply, the FlagsOther bit will be set.

type ID 

type ID uint32

ID combines a Key and Flags.

func (ID) AmbiguousForm 

func (x ID) AmbiguousForm() ID

func (ID) AssociativeForm 

func (x ID) AssociativeForm() ID

func (ID) BinaryForm 

func (x ID) BinaryForm() ID

func (ID) Flags 

func (x ID) Flags() Flags

func (ID) IsAssign 

func (x ID) IsAssign() bool

func (ID) IsAssociativeOp 

func (x ID) IsAssociativeOp() bool

func (ID) IsBinaryOp 

func (x ID) IsBinaryOp() bool

func (ID) IsBuiltIn 

func (x ID) IsBuiltIn() bool

func (ID) IsClose 

func (x ID) IsClose() bool

func (ID) IsIdent 

func (x ID) IsIdent() bool

func (ID) IsImplicitSemicolon 

func (x ID) IsImplicitSemicolon() bool

func (ID) IsLiteral 

func (x ID) IsLiteral() bool

func (ID) IsNumLiteral 

func (x ID) IsNumLiteral() bool

func (ID) IsNumType 

func (x ID) IsNumType() bool

func (ID) IsOpen 

func (x ID) IsOpen() bool

func (ID) IsStrLiteral 

func (x ID) IsStrLiteral() bool

func (ID) IsTightLeft 

func (x ID) IsTightLeft() bool

func (ID) IsTightRight 

func (x ID) IsTightRight() bool

func (ID) IsUnaryOp 

func (x ID) IsUnaryOp() bool

func (ID) IsXAssociativeOp 

func (x ID) IsXAssociativeOp() bool

func (ID) IsXBinaryOp 

func (x ID) IsXBinaryOp() bool

func (ID) IsXUnaryOp 

func (x ID) IsXUnaryOp() bool

func (ID) Key 

func (x ID) Key() Key

func (ID) String 

func (x ID) String(m *Map) string

String returns a string form of x.

func (ID) UnaryForm 

func (x ID) UnaryForm() ID

type Key 

type Key uint32

Key is the high 16 bits of an ID. It is the map key for a Map.

type Map 

type Map struct {
	// contains filtered or unexported fields
}

func (*Map) ByID 

func (m *Map) ByID(x ID) string

func (*Map) ByKey 

func (m *Map) ByKey(k Key) string

func (*Map) ByName 

func (m *Map) ByName(name string) ID

func (*Map) ByToken 

func (m *Map) ByToken(t Token) string

func (*Map) Insert 

func (m *Map) Insert(name string) (ID, error)

type QID 

type QID [2]ID

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".

func (QID) String 

func (x QID) String(m *Map) string

String returns a string form of x.

type Token 

type Token struct {
	ID   ID
	Line uint32
}

Token combines an ID and the line number it was seen.

func Tokenize 

func Tokenize(m *Map, filename string, src []byte) (tokens []Token, comments []string, retErr error)

func (Token) Flags 

func (t Token) Flags() Flags

func (Token) IsAssign 

func (t Token) IsAssign() bool

func (Token) IsAssociativeOp 

func (t Token) IsAssociativeOp() bool

func (Token) IsBinaryOp 

func (t Token) IsBinaryOp() bool

func (Token) IsBuiltIn 

func (t Token) IsBuiltIn() bool

func (Token) IsClose 

func (t Token) IsClose() bool

func (Token) IsIdent 

func (t Token) IsIdent() bool

func (Token) IsImplicitSemicolon 

func (t Token) IsImplicitSemicolon() bool

func (Token) IsLiteral 

func (t Token) IsLiteral() bool

func (Token) IsNumLiteral 

func (t Token) IsNumLiteral() bool

func (Token) IsNumType 

func (t Token) IsNumType() bool

func (Token) IsOpen 

func (t Token) IsOpen() bool

func (Token) IsStrLiteral 

func (t Token) IsStrLiteral() bool

func (Token) IsTightLeft 

func (t Token) IsTightLeft() bool

func (Token) IsTightRight 

func (t Token) IsTightRight() bool

func (Token) IsUnaryOp 

func (t Token) IsUnaryOp() bool

func (Token) IsXAssociativeOp 

func (t Token) IsXAssociativeOp() bool

func (Token) IsXBinaryOp 

func (t Token) IsXBinaryOp() bool

func (Token) IsXUnaryOp 

func (t Token) IsXUnaryOp() bool

func (Token) Key 

func (t Token) Key() Key

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.