lexer

package

v0.6.0 Latest Latest Go to latest Published: Jun 6, 2018 License: BSD-3-Clause 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/gtfierro/hod

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  = 62
	NumSymbols = 71
)

Variables ¶

View Source

var ActTab = ActionTable{
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: -1,
		Ignore: "!whitespace",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 20,
		Ignore: "",
	},
	ActionRow{
		Accept: 21,
		Ignore: "",
	},
	ActionRow{
		Accept: 4,
		Ignore: "",
	},
	ActionRow{
		Accept: 23,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 8,
		Ignore: "",
	},
	ActionRow{
		Accept: 18,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 2,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 22,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 19,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 6,
		Ignore: "",
	},
	ActionRow{
		Accept: 17,
		Ignore: "",
	},
	ActionRow{
		Accept: 7,
		Ignore: "",
	},
	ActionRow{
		Accept: 15,
		Ignore: "",
	},
	ActionRow{
		Accept: 0,
		Ignore: "",
	},
	ActionRow{
		Accept: 16,
		Ignore: "",
	},
	ActionRow{
		Accept: 11,
		Ignore: "",
	},
	ActionRow{
		Accept: 11,
		Ignore: "",
	},
	ActionRow{
		Accept: 11,
		Ignore: "",
	},
	ActionRow{
		Accept: 11,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 14,
		Ignore: "",
	},
	ActionRow{
		Accept: 14,
		Ignore: "",
	},
	ActionRow{
		Accept: 14,
		Ignore: "",
	},
	ActionRow{
		Accept: 14,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 12,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 9,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 10,
		Ignore: "",
	},
	ActionRow{
		Accept: 25,
		Ignore: "",
	},
	ActionRow{
		Accept: 13,
		Ignore: "",
	},
	ActionRow{
		Accept: 5,
		Ignore: "",
	},
	ActionRow{
		Accept: 3,
		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 == 34:
			return 2
		case r == 40:
			return 3
		case r == 41:
			return 4
		case r == 42:
			return 5
		case r == 43:
			return 6
		case r == 45:
			return 7
		case r == 46:
			return 8
		case r == 47:
			return 9
		case 48 <= r && r <= 57:
			return 10
		case r == 59:
			return 11
		case r == 60:
			return 12
		case r == 63:
			return 13
		case 65 <= r && r <= 66:
			return 14
		case r == 67:
			return 15
		case 68 <= r && r <= 69:
			return 14
		case r == 70:
			return 16
		case 71 <= r && r <= 72:
			return 14
		case r == 73:
			return 17
		case 74 <= r && r <= 82:
			return 14
		case r == 83:
			return 18
		case r == 84:
			return 14
		case r == 85:
			return 19
		case r == 86:
			return 14
		case r == 87:
			return 20
		case 88 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case r == 97:
			return 21
		case 98 <= r && r <= 122:
			return 22
		case r == 123:
			return 23
		case r == 124:
			return 24
		case r == 125:
			return 25
		}
		return NoState
	},

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

	func(r rune) int {
		switch {
		case r == 34:
			return 26
		default:
			return 2
		}
	},

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

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

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

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

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

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

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

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

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

	func(r rune) int {
		switch {
		case r == 62:
			return 28
		default:
			return 12
		}
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 29
		case 48 <= r && r <= 57:
			return 30
		case 65 <= r && r <= 90:
			return 31
		case r == 95:
			return 29
		case 97 <= r && r <= 122:
			return 32
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 78:
			return 14
		case r == 79:
			return 33
		case 80 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 81:
			return 14
		case r == 82:
			return 34
		case 83 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 77:
			return 14
		case r == 78:
			return 35
		case 79 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 68:
			return 14
		case r == 69:
			return 36
		case 70 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 77:
			return 14
		case r == 78:
			return 37
		case 79 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 71:
			return 14
		case r == 72:
			return 38
		case 73 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

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

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

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

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

	func(r rune) int {
		switch {
		case r == 45:
			return 39
		case 48 <= r && r <= 57:
			return 40
		case 65 <= r && r <= 90:
			return 41
		case r == 95:
			return 39
		case 97 <= r && r <= 122:
			return 42
		}
		return NoState
	},

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

	func(r rune) int {
		switch {
		case r == 45:
			return 29
		case 48 <= r && r <= 57:
			return 30
		case 65 <= r && r <= 90:
			return 31
		case r == 95:
			return 29
		case 97 <= r && r <= 122:
			return 32
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 29
		case 48 <= r && r <= 57:
			return 30
		case 65 <= r && r <= 90:
			return 31
		case r == 95:
			return 29
		case 97 <= r && r <= 122:
			return 32
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 29
		case 48 <= r && r <= 57:
			return 30
		case 65 <= r && r <= 90:
			return 31
		case r == 95:
			return 29
		case 97 <= r && r <= 122:
			return 32
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 29
		case 48 <= r && r <= 57:
			return 30
		case 65 <= r && r <= 90:
			return 31
		case r == 95:
			return 29
		case 97 <= r && r <= 122:
			return 32
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 84:
			return 14
		case r == 85:
			return 43
		case 86 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 78:
			return 14
		case r == 79:
			return 44
		case 80 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 82:
			return 14
		case r == 83:
			return 45
		case 84 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 75:
			return 14
		case r == 76:
			return 46
		case 77 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 72:
			return 14
		case r == 73:
			return 47
		case 74 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 68:
			return 14
		case r == 69:
			return 48
		case 70 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 39
		case 48 <= r && r <= 57:
			return 40
		case 65 <= r && r <= 90:
			return 41
		case r == 95:
			return 39
		case 97 <= r && r <= 122:
			return 42
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 39
		case 48 <= r && r <= 57:
			return 40
		case 65 <= r && r <= 90:
			return 41
		case r == 95:
			return 39
		case 97 <= r && r <= 122:
			return 42
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 39
		case 48 <= r && r <= 57:
			return 40
		case 65 <= r && r <= 90:
			return 41
		case r == 95:
			return 39
		case 97 <= r && r <= 122:
			return 42
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 39
		case 48 <= r && r <= 57:
			return 40
		case 65 <= r && r <= 90:
			return 41
		case r == 95:
			return 39
		case 97 <= r && r <= 122:
			return 42
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 77:
			return 14
		case r == 78:
			return 49
		case 79 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 76:
			return 14
		case r == 77:
			return 50
		case 78 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 68:
			return 14
		case r == 69:
			return 51
		case 70 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 68:
			return 14
		case r == 69:
			return 52
		case 70 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 78:
			return 14
		case r == 79:
			return 53
		case 80 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 81:
			return 14
		case r == 82:
			return 54
		case 83 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 83:
			return 14
		case r == 84:
			return 55
		case 85 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 81:
			return 14
		case r == 82:
			return 56
		case 83 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 66:
			return 14
		case r == 67:
			return 57
		case 68 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 77:
			return 14
		case r == 78:
			return 58
		case 79 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 68:
			return 14
		case r == 69:
			return 59
		case 70 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 83:
			return 14
		case r == 84:
			return 60
		case 85 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 83:
			return 14
		case r == 84:
			return 61
		case 85 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},

	func(r rune) int {
		switch {
		case r == 45:
			return 7
		case 48 <= r && r <= 57:
			return 10
		case r == 58:
			return 27
		case 65 <= r && r <= 90:
			return 14
		case r == 95:
			return 7
		case 97 <= r && r <= 122:
			return 22
		}
		return NoState
	},
}

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