regexp.peg.go

package contraption

// Code generated by peg regexp.peg DO NOT EDIT.

import (
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
	"strings"
)

const endSymbol rune = 1114112

/* The rule types inferred from the grammar are below. */
type pegRule uint8

const (
	ruleUnknown pegRule = iota
	ruleBody
	ruleAlter
	ruleCat
	rulePoint
	ruleConcrete
	ruleAny
	ruleSeveral
	ruleMaybe
	ruleLazyAny
	ruleLazySeveral
	ruleLazyMaybe
	ruleType
	ruleValue
	ruleRect
	ruleIn
	ruleOut
	ruleAnywhere
	ruleTime
	ruleBegin
	ruleEnd
	ruleToken
	ruleNumber
	ruleChar
	ruleSP
)

var rul3s = [...]string{
	"Unknown",
	"Body",
	"Alter",
	"Cat",
	"Point",
	"Concrete",
	"Any",
	"Several",
	"Maybe",
	"LazyAny",
	"LazySeveral",
	"LazyMaybe",
	"Type",
	"Value",
	"Rect",
	"In",
	"Out",
	"Anywhere",
	"Time",
	"Begin",
	"End",
	"Token",
	"Number",
	"Char",
	"SP",
}

type token32 struct {
	pegRule
	begin, end uint32
}

func (t *token32) String() string {
	return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
}

type node32 struct {
	token32
	up, next *node32
}

func (node *node32) print(w io.Writer, pretty bool, buffer string) {
	var print func(node *node32, depth int)
	print = func(node *node32, depth int) {
		for node != nil {
			for c := 0; c < depth; c++ {
				fmt.Fprintf(w, " ")
			}
			rule := rul3s[node.pegRule]
			quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
			if !pretty {
				fmt.Fprintf(w, "%v %v\n", rule, quote)
			} else {
				fmt.Fprintf(w, "\x1B[36m%v\x1B[m %v\n", rule, quote)
			}
			if node.up != nil {
				print(node.up, depth+1)
			}
			node = node.next
		}
	}
	print(node, 0)
}

func (node *node32) Print(w io.Writer, buffer string) {
	node.print(w, false, buffer)
}

func (node *node32) PrettyPrint(w io.Writer, buffer string) {
	node.print(w, true, buffer)
}

type tokens32 struct {
	tree []token32
}

func (t *tokens32) Trim(length uint32) {
	t.tree = t.tree[:length]
}

func (t *tokens32) Print() {
	for _, token := range t.tree {
		fmt.Println(token.String())
	}
}

func (t *tokens32) AST() *node32 {
	type element struct {
		node *node32
		down *element
	}
	tokens := t.Tokens()
	var stack *element
	for _, token := range tokens {
		if token.begin == token.end {
			continue
		}
		node := &node32{token32: token}
		for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
			stack.node.next = node.up
			node.up = stack.node
			stack = stack.down
		}
		stack = &element{node: node, down: stack}
	}
	if stack != nil {
		return stack.node
	}
	return nil
}

func (t *tokens32) PrintSyntaxTree(buffer string) {
	t.AST().Print(os.Stdout, buffer)
}

func (t *tokens32) WriteSyntaxTree(w io.Writer, buffer string) {
	t.AST().Print(w, buffer)
}

func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
	t.AST().PrettyPrint(os.Stdout, buffer)
}

func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
	tree, i := t.tree, int(index)
	if i >= len(tree) {
		t.tree = append(tree, token32{pegRule: rule, begin: begin, end: end})
		return
	}
	tree[i] = token32{pegRule: rule, begin: begin, end: end}
}

func (t *tokens32) Tokens() []token32 {
	return t.tree
}

type rpeg struct {
	typs  map[string]any
	Type  string
	Value string
	Begin bool
	End   bool
	In    bool

	Buffer string
	buffer []rune
	rules  [25]func() bool
	parse  func(rule ...int) error
	reset  func()
	Pretty bool
	tokens32
}

func (p *rpeg) Parse(rule ...int) error {
	return p.parse(rule...)
}

func (p *rpeg) Reset() {
	p.reset()
}

type textPosition struct {
	line, symbol int
}

type textPositionMap map[int]textPosition

func translatePositions(buffer []rune, positions []int) textPositionMap {
	length, translations, j, line, symbol := len(positions), make(textPositionMap, len(positions)), 0, 1, 0
	sort.Ints(positions)

search:
	for i, c := range buffer {
		if c == '\n' {
			line, symbol = line+1, 0
		} else {
			symbol++
		}
		if i == positions[j] {
			translations[positions[j]] = textPosition{line, symbol}
			for j++; j < length; j++ {
				if i != positions[j] {
					continue search
				}
			}
			break search
		}
	}

	return translations
}

type parseError struct {
	p   *rpeg
	max token32
}

func (e *parseError) Error() string {
	tokens, err := []token32{e.max}, "\n"
	positions, p := make([]int, 2*len(tokens)), 0
	for _, token := range tokens {
		positions[p], p = int(token.begin), p+1
		positions[p], p = int(token.end), p+1
	}
	translations := translatePositions(e.p.buffer, positions)
	format := "parse error near %v (line %v symbol %v - line %v symbol %v):\n%v\n"
	if e.p.Pretty {
		format = "parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n"
	}
	for _, token := range tokens {
		begin, end := int(token.begin), int(token.end)
		err += fmt.Sprintf(format,
			rul3s[token.pegRule],
			translations[begin].line, translations[begin].symbol,
			translations[end].line, translations[end].symbol,
			strconv.Quote(string(e.p.buffer[begin:end])))
	}

	return err
}

func (p *rpeg) PrintSyntaxTree() {
	if p.Pretty {
		p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
	} else {
		p.tokens32.PrintSyntaxTree(p.Buffer)
	}
}

func (p *rpeg) WriteSyntaxTree(w io.Writer) {
	p.tokens32.WriteSyntaxTree(w, p.Buffer)
}

func (p *rpeg) SprintSyntaxTree() string {
	var bldr strings.Builder
	p.WriteSyntaxTree(&bldr)
	return bldr.String()
}

func Pretty(pretty bool) func(*rpeg) error {
	return func(p *rpeg) error {
		p.Pretty = pretty
		return nil
	}
}

func Size(size int) func(*rpeg) error {
	return func(p *rpeg) error {
		p.tokens32 = tokens32{tree: make([]token32, 0, size)}
		return nil
	}
}
func (p *rpeg) Init(options ...func(*rpeg) error) error {
	var (
		max                  token32
		position, tokenIndex uint32
		buffer               []rune
	)
	for _, option := range options {
		err := option(p)
		if err != nil {
			return err
		}
	}
	p.reset = func() {
		max = token32{}
		position, tokenIndex = 0, 0

		p.buffer = []rune(p.Buffer)
		if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != endSymbol {
			p.buffer = append(p.buffer, endSymbol)
		}
		buffer = p.buffer
	}
	p.reset()

	_rules := p.rules
	tree := p.tokens32
	p.parse = func(rule ...int) error {
		r := 1
		if len(rule) > 0 {
			r = rule[0]
		}
		matches := p.rules[r]()
		p.tokens32 = tree
		if matches {
			p.Trim(tokenIndex)
			return nil
		}
		return &parseError{p, max}
	}

	add := func(rule pegRule, begin uint32) {
		tree.Add(rule, begin, position, tokenIndex)
		tokenIndex++
		if begin != position && position > max.end {
			max = token32{rule, begin, position}
		}
	}

	matchDot := func() bool {
		if buffer[position] != endSymbol {
			position++
			return true
		}
		return false
	}

	/*matchChar := func(c byte) bool {
		if buffer[position] == c {
			position++
			return true
		}
		return false
	}*/

	/*matchRange := func(lower byte, upper byte) bool {
		if c := buffer[position]; c >= lower && c <= upper {
			position++
			return true
		}
		return false
	}*/

	_rules = [...]func() bool{
		nil,
		/* 0 Body <- <(Alter / Cat)> */
		func() bool {
			position0, tokenIndex0 := position, tokenIndex
			{
				position1 := position
				{
					position2, tokenIndex2 := position, tokenIndex
					if !_rules[ruleAlter]() {
						goto l3
					}
					goto l2
				l3:
					position, tokenIndex = position2, tokenIndex2
					if !_rules[ruleCat]() {
						goto l0
					}
				}
			l2:
				add(ruleBody, position1)
			}
			return true
		l0:
			position, tokenIndex = position0, tokenIndex0
			return false
		},
		/* 1 Alter <- <((Cat (' ' / '\t' / '\n')* '|' (' ' / '\t' / '\n')* Cat) / (Cat (' ' / '\t' / '\n')* '|' (' ' / '\t' / '\n')* Alter))> */
		func() bool {
			position4, tokenIndex4 := position, tokenIndex
			{
				position5 := position
				{
					position6, tokenIndex6 := position, tokenIndex
					if !_rules[ruleCat]() {
						goto l7
					}
				l8:
					{
						position9, tokenIndex9 := position, tokenIndex
						{
							position10, tokenIndex10 := position, tokenIndex
							if buffer[position] != rune(' ') {
								goto l11
							}
							position++
							goto l10
						l11:
							position, tokenIndex = position10, tokenIndex10
							if buffer[position] != rune('\t') {
								goto l12
							}
							position++
							goto l10
						l12:
							position, tokenIndex = position10, tokenIndex10
							if buffer[position] != rune('\n') {
								goto l9
							}
							position++
						}
					l10:
						goto l8
					l9:
						position, tokenIndex = position9, tokenIndex9
					}
					if buffer[position] != rune('|') {
						goto l7
					}
					position++
				l13:
					{
						position14, tokenIndex14 := position, tokenIndex
						{
							position15, tokenIndex15 := position, tokenIndex
							if buffer[position] != rune(' ') {
								goto l16
							}
							position++
							goto l15
						l16:
							position, tokenIndex = position15, tokenIndex15
							if buffer[position] != rune('\t') {
								goto l17
							}
							position++
							goto l15
						l17:
							position, tokenIndex = position15, tokenIndex15
							if buffer[position] != rune('\n') {
								goto l14
							}
							position++
						}
					l15:
						goto l13
					l14:
						position, tokenIndex = position14, tokenIndex14
					}
					if !_rules[ruleCat]() {
						goto l7
					}
					goto l6
				l7:
					position, tokenIndex = position6, tokenIndex6
					if !_rules[ruleCat]() {
						goto l4
					}
				l18:
					{
						position19, tokenIndex19 := position, tokenIndex
						{
							position20, tokenIndex20 := position, tokenIndex
							if buffer[position] != rune(' ') {
								goto l21
							}
							position++
							goto l20
						l21:
							position, tokenIndex = position20, tokenIndex20
							if buffer[position] != rune('\t') {
								goto l22
							}
							position++
							goto l20
						l22:
							position, tokenIndex = position20, tokenIndex20
							if buffer[position] != rune('\n') {
								goto l19
							}
							position++
						}
					l20:
						goto l18
					l19:
						position, tokenIndex = position19, tokenIndex19
					}
					if buffer[position] != rune('|') {
						goto l4
					}
					position++
				l23:
					{
						position24, tokenIndex24 := position, tokenIndex
						{
							position25, tokenIndex25 := position, tokenIndex
							if buffer[position] != rune(' ') {
								goto l26
							}
							position++
							goto l25
						l26:
							position, tokenIndex = position25, tokenIndex25
							if buffer[position] != rune('\t') {
								goto l27
							}
							position++
							goto l25
						l27:
							position, tokenIndex = position25, tokenIndex25
							if buffer[position] != rune('\n') {
								goto l24
							}
							position++
						}
					l25:
						goto l23
					l24:
						position, tokenIndex = position24, tokenIndex24
					}
					if !_rules[ruleAlter]() {
						goto l4
					}
				}
			l6:
				add(ruleAlter, position5)
			}
			return true
		l4:
			position, tokenIndex = position4, tokenIndex4
			return false
		},
		/* 2 Cat <- <(Point ((' ' / '\t' / '\n')* Cat)?)> */
		func() bool {
			position28, tokenIndex28 := position, tokenIndex
			{
				position29 := position
				if !_rules[rulePoint]() {
					goto l28
				}
				{
					position30, tokenIndex30 := position, tokenIndex
				l32:
					{
						position33, tokenIndex33 := position, tokenIndex
						{
							position34, tokenIndex34 := position, tokenIndex
							if buffer[position] != rune(' ') {
								goto l35
							}
							position++
							goto l34
						l35:
							position, tokenIndex = position34, tokenIndex34
							if buffer[position] != rune('\t') {
								goto l36
							}
							position++
							goto l34
						l36:
							position, tokenIndex = position34, tokenIndex34
							if buffer[position] != rune('\n') {
								goto l33
							}
							position++
						}
					l34:
						goto l32
					l33:
						position, tokenIndex = position33, tokenIndex33
					}
					if !_rules[ruleCat]() {
						goto l30
					}
					goto l31
				l30:
					position, tokenIndex = position30, tokenIndex30
				}
			l31:
				add(ruleCat, position29)
			}
			return true
		l28:
			position, tokenIndex = position28, tokenIndex28
			return false
		},
		/* 3 Point <- <(Concrete (Any / Several / Maybe / LazyAny / LazySeveral / LazyMaybe)?)> */
		func() bool {
			position37, tokenIndex37 := position, tokenIndex
			{
				position38 := position
				if !_rules[ruleConcrete]() {
					goto l37
				}
				{
					position39, tokenIndex39 := position, tokenIndex
					{
						position41, tokenIndex41 := position, tokenIndex
						if !_rules[ruleAny]() {
							goto l42
						}
						goto l41
					l42:
						position, tokenIndex = position41, tokenIndex41
						if !_rules[ruleSeveral]() {
							goto l43
						}
						goto l41
					l43:
						position, tokenIndex = position41, tokenIndex41
						if !_rules[ruleMaybe]() {
							goto l44
						}
						goto l41
					l44:
						position, tokenIndex = position41, tokenIndex41
						if !_rules[ruleLazyAny]() {
							goto l45
						}
						goto l41
					l45:
						position, tokenIndex = position41, tokenIndex41
						if !_rules[ruleLazySeveral]() {
							goto l46
						}
						goto l41
					l46:
						position, tokenIndex = position41, tokenIndex41
						if !_rules[ruleLazyMaybe]() {
							goto l39
						}
					}
				l41:
					goto l40
				l39:
					position, tokenIndex = position39, tokenIndex39
				}
			l40:
				add(rulePoint, position38)
			}
			return true
		l37:
			position, tokenIndex = position37, tokenIndex37
			return false
		},
		/* 4 Concrete <- <(Type ('(' SP Value SP ')')? ((Rect Time?) / (Time? Rect?)))> */
		func() bool {
			position47, tokenIndex47 := position, tokenIndex
			{
				position48 := position
				if !_rules[ruleType]() {
					goto l47
				}
				{
					position49, tokenIndex49 := position, tokenIndex
					if buffer[position] != rune('(') {
						goto l49
					}
					position++
					if !_rules[ruleSP]() {
						goto l49
					}
					if !_rules[ruleValue]() {
						goto l49
					}
					if !_rules[ruleSP]() {
						goto l49
					}
					if buffer[position] != rune(')') {
						goto l49
					}
					position++
					goto l50
				l49:
					position, tokenIndex = position49, tokenIndex49
				}
			l50:
				{
					position51, tokenIndex51 := position, tokenIndex
					if !_rules[ruleRect]() {
						goto l52
					}
					{
						position53, tokenIndex53 := position, tokenIndex
						if !_rules[ruleTime]() {
							goto l53
						}
						goto l54
					l53:
						position, tokenIndex = position53, tokenIndex53
					}
				l54:
					goto l51
				l52:
					position, tokenIndex = position51, tokenIndex51
					{
						position55, tokenIndex55 := position, tokenIndex
						if !_rules[ruleTime]() {
							goto l55
						}
						goto l56
					l55:
						position, tokenIndex = position55, tokenIndex55
					}
				l56:
					{
						position57, tokenIndex57 := position, tokenIndex
						if !_rules[ruleRect]() {
							goto l57
						}
						goto l58
					l57:
						position, tokenIndex = position57, tokenIndex57
					}
				l58:
				}
			l51:
				add(ruleConcrete, position48)
			}
			return true
		l47:
			position, tokenIndex = position47, tokenIndex47
			return false
		},
		/* 5 Any <- <'*'> */
		func() bool {
			position59, tokenIndex59 := position, tokenIndex
			{
				position60 := position
				if buffer[position] != rune('*') {
					goto l59
				}
				position++
				add(ruleAny, position60)
			}
			return true
		l59:
			position, tokenIndex = position59, tokenIndex59
			return false
		},
		/* 6 Several <- <'+'> */
		func() bool {
			position61, tokenIndex61 := position, tokenIndex
			{
				position62 := position
				if buffer[position] != rune('+') {
					goto l61
				}
				position++
				add(ruleSeveral, position62)
			}
			return true
		l61:
			position, tokenIndex = position61, tokenIndex61
			return false
		},
		/* 7 Maybe <- <'?'> */
		func() bool {
			position63, tokenIndex63 := position, tokenIndex
			{
				position64 := position
				if buffer[position] != rune('?') {
					goto l63
				}
				position++
				add(ruleMaybe, position64)
			}
			return true
		l63:
			position, tokenIndex = position63, tokenIndex63
			return false
		},
		/* 8 LazyAny <- <('*' '?')> */
		func() bool {
			position65, tokenIndex65 := position, tokenIndex
			{
				position66 := position
				if buffer[position] != rune('*') {
					goto l65
				}
				position++
				if buffer[position] != rune('?') {
					goto l65
				}
				position++
				add(ruleLazyAny, position66)
			}
			return true
		l65:
			position, tokenIndex = position65, tokenIndex65
			return false
		},
		/* 9 LazySeveral <- <('+' '?')> */
		func() bool {
			position67, tokenIndex67 := position, tokenIndex
			{
				position68 := position
				if buffer[position] != rune('+') {
					goto l67
				}
				position++
				if buffer[position] != rune('?') {
					goto l67
				}
				position++
				add(ruleLazySeveral, position68)
			}
			return true
		l67:
			position, tokenIndex = position67, tokenIndex67
			return false
		},
		/* 10 LazyMaybe <- <('?' '?')> */
		func() bool {
			position69, tokenIndex69 := position, tokenIndex
			{
				position70 := position
				if buffer[position] != rune('?') {
					goto l69
				}
				position++
				if buffer[position] != rune('?') {
					goto l69
				}
				position++
				add(ruleLazyMaybe, position70)
			}
			return true
		l69:
			position, tokenIndex = position69, tokenIndex69
			return false
		},
		/* 11 Type <- <Token> */
		func() bool {
			position71, tokenIndex71 := position, tokenIndex
			{
				position72 := position
				if !_rules[ruleToken]() {
					goto l71
				}
				add(ruleType, position72)
			}
			return true
		l71:
			position, tokenIndex = position71, tokenIndex71
			return false
		},
		/* 12 Value <- <(Number / Char / Token)> */
		func() bool {
			position73, tokenIndex73 := position, tokenIndex
			{
				position74 := position
				{
					position75, tokenIndex75 := position, tokenIndex
					if !_rules[ruleNumber]() {
						goto l76
					}
					goto l75
				l76:
					position, tokenIndex = position75, tokenIndex75
					if !_rules[ruleChar]() {
						goto l77
					}
					goto l75
				l77:
					position, tokenIndex = position75, tokenIndex75
					if !_rules[ruleToken]() {
						goto l73
					}
				}
			l75:
				add(ruleValue, position74)
			}
			return true
		l73:
			position, tokenIndex = position73, tokenIndex73
			return false
		},
		/* 13 Rect <- <(In / Out / Anywhere)> */
		func() bool {
			position78, tokenIndex78 := position, tokenIndex
			{
				position79 := position
				{
					position80, tokenIndex80 := position, tokenIndex
					if !_rules[ruleIn]() {
						goto l81
					}
					goto l80
				l81:
					position, tokenIndex = position80, tokenIndex80
					if !_rules[ruleOut]() {
						goto l82
					}
					goto l80
				l82:
					position, tokenIndex = position80, tokenIndex80
					if !_rules[ruleAnywhere]() {
						goto l78
					}
				}
			l80:
				add(ruleRect, position79)
			}
			return true
		l78:
			position, tokenIndex = position78, tokenIndex78
			return false
		},
		/* 14 In <- <(':' 'i' 'n')> */
		func() bool {
			position83, tokenIndex83 := position, tokenIndex
			{
				position84 := position
				if buffer[position] != rune(':') {
					goto l83
				}
				position++
				if buffer[position] != rune('i') {
					goto l83
				}
				position++
				if buffer[position] != rune('n') {
					goto l83
				}
				position++
				add(ruleIn, position84)
			}
			return true
		l83:
			position, tokenIndex = position83, tokenIndex83
			return false
		},
		/* 15 Out <- <(':' 'o' 'u' 't')> */
		func() bool {
			position85, tokenIndex85 := position, tokenIndex
			{
				position86 := position
				if buffer[position] != rune(':') {
					goto l85
				}
				position++
				if buffer[position] != rune('o') {
					goto l85
				}
				position++
				if buffer[position] != rune('u') {
					goto l85
				}
				position++
				if buffer[position] != rune('t') {
					goto l85
				}
				position++
				add(ruleOut, position86)
			}
			return true
		l85:
			position, tokenIndex = position85, tokenIndex85
			return false
		},
		/* 16 Anywhere <- <(':' 'a' 'n' 'y')> */
		func() bool {
			position87, tokenIndex87 := position, tokenIndex
			{
				position88 := position
				if buffer[position] != rune(':') {
					goto l87
				}
				position++
				if buffer[position] != rune('a') {
					goto l87
				}
				position++
				if buffer[position] != rune('n') {
					goto l87
				}
				position++
				if buffer[position] != rune('y') {
					goto l87
				}
				position++
				add(ruleAnywhere, position88)
			}
			return true
		l87:
			position, tokenIndex = position87, tokenIndex87
			return false
		},
		/* 17 Time <- <(Begin / End)> */
		func() bool {
			position89, tokenIndex89 := position, tokenIndex
			{
				position90 := position
				{
					position91, tokenIndex91 := position, tokenIndex
					if !_rules[ruleBegin]() {
						goto l92
					}
					goto l91
				l92:
					position, tokenIndex = position91, tokenIndex91
					if !_rules[ruleEnd]() {
						goto l89
					}
				}
			l91:
				add(ruleTime, position90)
			}
			return true
		l89:
			position, tokenIndex = position89, tokenIndex89
			return false
		},
		/* 18 Begin <- <(':' 'b' 'e' 'g' 'i' 'n')> */
		func() bool {
			position93, tokenIndex93 := position, tokenIndex
			{
				position94 := position
				if buffer[position] != rune(':') {
					goto l93
				}
				position++
				if buffer[position] != rune('b') {
					goto l93
				}
				position++
				if buffer[position] != rune('e') {
					goto l93
				}
				position++
				if buffer[position] != rune('g') {
					goto l93
				}
				position++
				if buffer[position] != rune('i') {
					goto l93
				}
				position++
				if buffer[position] != rune('n') {
					goto l93
				}
				position++
				add(ruleBegin, position94)
			}
			return true
		l93:
			position, tokenIndex = position93, tokenIndex93
			return false
		},
		/* 19 End <- <(':' 'e' 'n' 'd')> */
		func() bool {
			position95, tokenIndex95 := position, tokenIndex
			{
				position96 := position
				if buffer[position] != rune(':') {
					goto l95
				}
				position++
				if buffer[position] != rune('e') {
					goto l95
				}
				position++
				if buffer[position] != rune('n') {
					goto l95
				}
				position++
				if buffer[position] != rune('d') {
					goto l95
				}
				position++
				add(ruleEnd, position96)
			}
			return true
		l95:
			position, tokenIndex = position95, tokenIndex95
			return false
		},
		/* 20 Token <- <(('!'? ('_' / [a-z] / [A-Z]) ('_' / [a-z] / [A-Z] / [0-9] / '/' / '.' / '-')*) / '←' / '→' / '↑' / '↓' / '.')> */
		func() bool {
			position97, tokenIndex97 := position, tokenIndex
			{
				position98 := position
				{
					position99, tokenIndex99 := position, tokenIndex
					{
						position101, tokenIndex101 := position, tokenIndex
						if buffer[position] != rune('!') {
							goto l101
						}
						position++
						goto l102
					l101:
						position, tokenIndex = position101, tokenIndex101
					}
				l102:
					{
						position103, tokenIndex103 := position, tokenIndex
						if buffer[position] != rune('_') {
							goto l104
						}
						position++
						goto l103
					l104:
						position, tokenIndex = position103, tokenIndex103
						if c := buffer[position]; c < rune('a') || c > rune('z') {
							goto l105
						}
						position++
						goto l103
					l105:
						position, tokenIndex = position103, tokenIndex103
						if c := buffer[position]; c < rune('A') || c > rune('Z') {
							goto l100
						}
						position++
					}
				l103:
				l106:
					{
						position107, tokenIndex107 := position, tokenIndex
						{
							position108, tokenIndex108 := position, tokenIndex
							if buffer[position] != rune('_') {
								goto l109
							}
							position++
							goto l108
						l109:
							position, tokenIndex = position108, tokenIndex108
							if c := buffer[position]; c < rune('a') || c > rune('z') {
								goto l110
							}
							position++
							goto l108
						l110:
							position, tokenIndex = position108, tokenIndex108
							if c := buffer[position]; c < rune('A') || c > rune('Z') {
								goto l111
							}
							position++
							goto l108
						l111:
							position, tokenIndex = position108, tokenIndex108
							if c := buffer[position]; c < rune('0') || c > rune('9') {
								goto l112
							}
							position++
							goto l108
						l112:
							position, tokenIndex = position108, tokenIndex108
							if buffer[position] != rune('/') {
								goto l113
							}
							position++
							goto l108
						l113:
							position, tokenIndex = position108, tokenIndex108
							if buffer[position] != rune('.') {
								goto l114
							}
							position++
							goto l108
						l114:
							position, tokenIndex = position108, tokenIndex108
							if buffer[position] != rune('-') {
								goto l107
							}
							position++
						}
					l108:
						goto l106
					l107:
						position, tokenIndex = position107, tokenIndex107
					}
					goto l99
				l100:
					position, tokenIndex = position99, tokenIndex99
					if buffer[position] != rune('←') {
						goto l115
					}
					position++
					goto l99
				l115:
					position, tokenIndex = position99, tokenIndex99
					if buffer[position] != rune('→') {
						goto l116
					}
					position++
					goto l99
				l116:
					position, tokenIndex = position99, tokenIndex99
					if buffer[position] != rune('↑') {
						goto l117
					}
					position++
					goto l99
				l117:
					position, tokenIndex = position99, tokenIndex99
					if buffer[position] != rune('↓') {
						goto l118
					}
					position++
					goto l99
				l118:
					position, tokenIndex = position99, tokenIndex99
					if buffer[position] != rune('.') {
						goto l97
					}
					position++
				}
			l99:
				add(ruleToken, position98)
			}
			return true
		l97:
			position, tokenIndex = position97, tokenIndex97
			return false
		},
		/* 21 Number <- <(('-' / '+')? [0-9] ('o' / 'O' / 'x' / 'X')? [0-9]*)> */
		func() bool {
			position119, tokenIndex119 := position, tokenIndex
			{
				position120 := position
				{
					position121, tokenIndex121 := position, tokenIndex
					{
						position123, tokenIndex123 := position, tokenIndex
						if buffer[position] != rune('-') {
							goto l124
						}
						position++
						goto l123
					l124:
						position, tokenIndex = position123, tokenIndex123
						if buffer[position] != rune('+') {
							goto l121
						}
						position++
					}
				l123:
					goto l122
				l121:
					position, tokenIndex = position121, tokenIndex121
				}
			l122:
				if c := buffer[position]; c < rune('0') || c > rune('9') {
					goto l119
				}
				position++
				{
					position125, tokenIndex125 := position, tokenIndex
					{
						position127, tokenIndex127 := position, tokenIndex
						if buffer[position] != rune('o') {
							goto l128
						}
						position++
						goto l127
					l128:
						position, tokenIndex = position127, tokenIndex127
						if buffer[position] != rune('O') {
							goto l129
						}
						position++
						goto l127
					l129:
						position, tokenIndex = position127, tokenIndex127
						if buffer[position] != rune('x') {
							goto l130
						}
						position++
						goto l127
					l130:
						position, tokenIndex = position127, tokenIndex127
						if buffer[position] != rune('X') {
							goto l125
						}
						position++
					}
				l127:
					goto l126
				l125:
					position, tokenIndex = position125, tokenIndex125
				}
			l126:
			l131:
				{
					position132, tokenIndex132 := position, tokenIndex
					if c := buffer[position]; c < rune('0') || c > rune('9') {
						goto l132
					}
					position++
					goto l131
				l132:
					position, tokenIndex = position132, tokenIndex132
				}
				add(ruleNumber, position120)
			}
			return true
		l119:
			position, tokenIndex = position119, tokenIndex119
			return false
		},
		/* 22 Char <- <('\'' . '\'')> */
		func() bool {
			position133, tokenIndex133 := position, tokenIndex
			{
				position134 := position
				if buffer[position] != rune('\'') {
					goto l133
				}
				position++
				if !matchDot() {
					goto l133
				}
				if buffer[position] != rune('\'') {
					goto l133
				}
				position++
				add(ruleChar, position134)
			}
			return true
		l133:
			position, tokenIndex = position133, tokenIndex133
			return false
		},
		/* 23 SP <- <(' ' / '\t' / '\n')*> */
		func() bool {
			{
				position136 := position
			l137:
				{
					position138, tokenIndex138 := position, tokenIndex
					{
						position139, tokenIndex139 := position, tokenIndex
						if buffer[position] != rune(' ') {
							goto l140
						}
						position++
						goto l139
					l140:
						position, tokenIndex = position139, tokenIndex139
						if buffer[position] != rune('\t') {
							goto l141
						}
						position++
						goto l139
					l141:
						position, tokenIndex = position139, tokenIndex139
						if buffer[position] != rune('\n') {
							goto l138
						}
						position++
					}
				l139:
					goto l137
				l138:
					position, tokenIndex = position138, tokenIndex138
				}
				add(ruleSP, position136)
			}
			return true
		},
	}
	p.rules = _rules
	return nil
}