lexer

package

v0.0.0-...-e5cb6a0 Latest Latest Go to latest Published: Jun 4, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/GoLangsam/sexpr

Links

Open Source Insights

Documentation ¶

Index ¶

Constants
Variables
type ActionRow
- func (a ActionRow) String() string
type ActionTable
type Lexer
- func NewLexer(src []byte) *Lexer
- func NewLexerFile(fpath string) (*Lexer, error)
- func (l *Lexer) Reset()
- func (l *Lexer) Scan() (tok *token.Token)
type TransitionTable

Constants ¶

View Source

const (
	NoState    = -1
	NumStates  = 93
	NumSymbols = 59
)

Variables ¶

View Source

var ActTab = ActionTable{
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 4,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 2,
		Ignore: "",
	},
	ActionRow{
		Accept: 3,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 5,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 9,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 7,
		Ignore: "",
	},
	ActionRow{
		Accept: 7,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 7,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 7,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
}

View Source

var TransTab = TransitionTable{

	func(r rune) int {
		switch {
		case r == 9:
			return 1
		case r == 10:
			return 1
		case r == 13:
			return 1
		case r == 32:
			return 1
		case r == 33:
			return 2
		case r == 34:
			return 3
		case r == 35:
			return 2
		case r == 36:
			return 2
		case r == 40:
			return 4
		case r == 41:
			return 5
		case r == 44:
			return 6
		case r == 45:
			return 7
		case r == 46:
			return 8
		case r == 48:
			return 9
		case 49 <= r && r <= 57:
			return 10
		case r == 63:
			return 2
		case r == 64:
			return 2
		case 65 <= r && r <= 90:
			return 11
		case 97 <= r && r <= 122:
			return 12
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 9:
			return 1
		case r == 10:
			return 1
		case r == 13:
			return 1
		case r == 32:
			return 1
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		}
		return NoState
	},

	func(r rune) int {
		switch {
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 46:
			return 23
		case r == 48:
			return 24
		case 49 <= r && r <= 57:
			return 25
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 26
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 27
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 28
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 29
		case 48 <= r && r <= 55:
			return 30
		case 56 <= r && r <= 57:
			return 31
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 32
		case 70 <= r && r <= 87:
			return 16
		case r == 88:
			return 33
		case 89 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 34
		case 102 <= r && r <= 119:
			return 18
		case r == 120:
			return 35
		case 121 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 29
		case 48 <= r && r <= 57:
			return 36
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 32
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 34
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 32:
			return 14
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 15
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 37
		case r == 39:
			return 37
		case 48 <= r && r <= 55:
			return 38
		case r == 85:
			return 39
		case r == 92:
			return 37
		case r == 97:
			return 37
		case r == 98:
			return 37
		case r == 102:
			return 37
		case r == 110:
			return 37
		case r == 114:
			return 37
		case r == 116:
			return 37
		case r == 117:
			return 40
		case r == 118:
			return 37
		case r == 120:
			return 41
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 42
		case r == 69:
			return 43
		case r == 101:
			return 43
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 46:
			return 44
		case 48 <= r && r <= 55:
			return 45
		case 56 <= r && r <= 57:
			return 46
		case r == 69:
			return 47
		case r == 88:
			return 48
		case r == 101:
			return 47
		case r == 120:
			return 48
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 46:
			return 44
		case 48 <= r && r <= 57:
			return 25
		case r == 69:
			return 47
		case r == 101:
			return 47
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 26
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 49
		case r == 45:
			return 50
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 51
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 49
		case r == 45:
			return 50
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 51
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 52
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 53
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 54
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 29
		case 48 <= r && r <= 55:
			return 30
		case 56 <= r && r <= 57:
			return 31
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 32
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 34
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 29
		case 48 <= r && r <= 57:
			return 31
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 32
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 34
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 55
		case r == 45:
			return 56
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 57
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 58
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 70:
			return 59
		case 71 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 102:
			return 60
		case 103 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 55
		case r == 45:
			return 56
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 57
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 58
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 70:
			return 59
		case 71 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 102:
			return 60
		case 103 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 29
		case 48 <= r && r <= 57:
			return 36
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 32
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 34
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 55:
			return 61
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 62
		case 65 <= r && r <= 70:
			return 62
		case 97 <= r && r <= 102:
			return 62
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 63
		case 65 <= r && r <= 70:
			return 63
		case 97 <= r && r <= 102:
			return 63
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 64
		case 65 <= r && r <= 70:
			return 64
		case 97 <= r && r <= 102:
			return 64
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 42
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 43:
			return 49
		case r == 45:
			return 49
		case 48 <= r && r <= 57:
			return 65
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 66
		case r == 69:
			return 67
		case r == 101:
			return 67
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 46:
			return 44
		case 48 <= r && r <= 55:
			return 45
		case 56 <= r && r <= 57:
			return 46
		case r == 69:
			return 47
		case r == 101:
			return 47
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 46:
			return 44
		case 48 <= r && r <= 57:
			return 46
		case r == 69:
			return 47
		case r == 101:
			return 47
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 43:
			return 55
		case r == 45:
			return 55
		case 48 <= r && r <= 57:
			return 68
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 69
		case 65 <= r && r <= 70:
			return 69
		case 97 <= r && r <= 102:
			return 69
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 65
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 51
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 51
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 52
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 68:
			return 16
		case r == 69:
			return 70
		case 70 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 100:
			return 18
		case r == 101:
			return 71
		case 102 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 72
		case r == 45:
			return 73
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 74
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 72
		case r == 45:
			return 73
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 74
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 68
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 57
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 57
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 58
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 70:
			return 59
		case 71 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 102:
			return 60
		case 103 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 58
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 70:
			return 59
		case 71 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 102:
			return 60
		case 103 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 58
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 70:
			return 59
		case 71 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 102:
			return 60
		case 103 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 55:
			return 75
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 76
		case 65 <= r && r <= 70:
			return 76
		case 97 <= r && r <= 102:
			return 76
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 77
		case 65 <= r && r <= 70:
			return 77
		case 97 <= r && r <= 102:
			return 77
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 78
		case 65 <= r && r <= 70:
			return 78
		case 97 <= r && r <= 102:
			return 78
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 65
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 66
		case r == 69:
			return 79
		case r == 101:
			return 79
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 43:
			return 72
		case r == 45:
			return 72
		case 48 <= r && r <= 57:
			return 80
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 68
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 69
		case 65 <= r && r <= 70:
			return 69
		case 97 <= r && r <= 102:
			return 69
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 81
		case r == 45:
			return 82
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 83
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 43:
			return 81
		case r == 45:
			return 82
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 83
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 80
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 74
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 74
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 84
		case 65 <= r && r <= 70:
			return 84
		case 97 <= r && r <= 102:
			return 84
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 85
		case 65 <= r && r <= 70:
			return 85
		case 97 <= r && r <= 102:
			return 85
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		case r == 43:
			return 81
		case r == 45:
			return 81
		case 48 <= r && r <= 57:
			return 86
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 80
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 86
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 83
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 33:
			return 13
		case r == 35:
			return 13
		case r == 36:
			return 13
		case r == 45:
			return 14
		case r == 46:
			return 13
		case 48 <= r && r <= 57:
			return 83
		case r == 63:
			return 13
		case r == 64:
			return 13
		case 65 <= r && r <= 90:
			return 16
		case r == 92:
			return 17
		case 97 <= r && r <= 122:
			return 18
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 87
		case 65 <= r && r <= 70:
			return 87
		case 97 <= r && r <= 102:
			return 87
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 88
		case 65 <= r && r <= 70:
			return 88
		case 97 <= r && r <= 102:
			return 88
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 86
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 89
		case 65 <= r && r <= 70:
			return 89
		case 97 <= r && r <= 102:
			return 89
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 90
		case 65 <= r && r <= 70:
			return 90
		case 97 <= r && r <= 102:
			return 90
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 91
		case 65 <= r && r <= 70:
			return 91
		case 97 <= r && r <= 102:
			return 91
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case 48 <= r && r <= 57:
			return 92
		case 65 <= r && r <= 70:
			return 92
		case 97 <= r && r <= 102:
			return 92
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 34:
			return 19
		case r == 92:
			return 20
		default:
			return 21
		}
	},
}

Functions ¶

This section is empty.

Types ¶

type ActionRow ¶

type ActionRow struct {
	Accept token.Type
	Ignore string
}

func (ActionRow) String ¶

func (a ActionRow) String() string

type ActionTable ¶

type ActionTable [NumStates]ActionRow

type Lexer ¶

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

func NewLexer ¶

func NewLexer(src []byte) *Lexer

func NewLexerFile ¶

func NewLexerFile(fpath string) (*Lexer, error)

func (*Lexer) Reset ¶

func (l *Lexer) Reset()

func (*Lexer) Scan ¶

func (l *Lexer) Scan() (tok *token.Token)

type TransitionTable ¶

type TransitionTable [NumStates]func(rune) int

Let s be the current state Let r be the current input rune transitionTable[s](r) returns the next state.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL