4223 lines
94 KiB
Go
4223 lines
94 KiB
Go
package main
|
|
|
|
//go:generate peg delocate.peg
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"sort"
|
|
"strconv"
|
|
)
|
|
|
|
const endSymbol rune = 1114112
|
|
|
|
/* The rule types inferred from the grammar are below. */
|
|
type pegRule uint8
|
|
|
|
const (
|
|
ruleUnknown pegRule = iota
|
|
ruleAsmFile
|
|
ruleStatement
|
|
ruleGlobalDirective
|
|
ruleDirective
|
|
ruleDirectiveName
|
|
ruleLocationDirective
|
|
ruleArgs
|
|
ruleArg
|
|
ruleQuotedArg
|
|
ruleQuotedText
|
|
ruleLabelContainingDirective
|
|
ruleLabelContainingDirectiveName
|
|
ruleSymbolArgs
|
|
ruleSymbolArg
|
|
ruleSymbolType
|
|
ruleDot
|
|
ruleTCMarker
|
|
ruleEscapedChar
|
|
ruleWS
|
|
ruleComment
|
|
ruleLabel
|
|
ruleSymbolName
|
|
ruleLocalSymbol
|
|
ruleLocalLabel
|
|
ruleLocalLabelRef
|
|
ruleInstruction
|
|
ruleInstructionName
|
|
ruleInstructionArg
|
|
ruleAVX512Token
|
|
ruleTOCRefHigh
|
|
ruleTOCRefLow
|
|
ruleIndirectionIndicator
|
|
ruleRegisterOrConstant
|
|
ruleMemoryRef
|
|
ruleSymbolRef
|
|
ruleBaseIndexScale
|
|
ruleOperator
|
|
ruleOffset
|
|
ruleSection
|
|
ruleSegmentRegister
|
|
)
|
|
|
|
var rul3s = [...]string{
|
|
"Unknown",
|
|
"AsmFile",
|
|
"Statement",
|
|
"GlobalDirective",
|
|
"Directive",
|
|
"DirectiveName",
|
|
"LocationDirective",
|
|
"Args",
|
|
"Arg",
|
|
"QuotedArg",
|
|
"QuotedText",
|
|
"LabelContainingDirective",
|
|
"LabelContainingDirectiveName",
|
|
"SymbolArgs",
|
|
"SymbolArg",
|
|
"SymbolType",
|
|
"Dot",
|
|
"TCMarker",
|
|
"EscapedChar",
|
|
"WS",
|
|
"Comment",
|
|
"Label",
|
|
"SymbolName",
|
|
"LocalSymbol",
|
|
"LocalLabel",
|
|
"LocalLabelRef",
|
|
"Instruction",
|
|
"InstructionName",
|
|
"InstructionArg",
|
|
"AVX512Token",
|
|
"TOCRefHigh",
|
|
"TOCRefLow",
|
|
"IndirectionIndicator",
|
|
"RegisterOrConstant",
|
|
"MemoryRef",
|
|
"SymbolRef",
|
|
"BaseIndexScale",
|
|
"Operator",
|
|
"Offset",
|
|
"Section",
|
|
"SegmentRegister",
|
|
}
|
|
|
|
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(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.Printf(" ")
|
|
}
|
|
rule := rul3s[node.pegRule]
|
|
quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
|
|
if !pretty {
|
|
fmt.Printf("%v %v\n", rule, quote)
|
|
} else {
|
|
fmt.Printf("\x1B[34m%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(buffer string) {
|
|
node.print(false, buffer)
|
|
}
|
|
|
|
func (node *node32) PrettyPrint(buffer string) {
|
|
node.print(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(buffer)
|
|
}
|
|
|
|
func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
|
|
t.AST().PrettyPrint(buffer)
|
|
}
|
|
|
|
func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
|
|
if tree := t.tree; int(index) >= len(tree) {
|
|
expanded := make([]token32, 2*len(tree))
|
|
copy(expanded, tree)
|
|
t.tree = expanded
|
|
}
|
|
t.tree[index] = token32{
|
|
pegRule: rule,
|
|
begin: begin,
|
|
end: end,
|
|
}
|
|
}
|
|
|
|
func (t *tokens32) Tokens() []token32 {
|
|
return t.tree
|
|
}
|
|
|
|
type Asm struct {
|
|
Buffer string
|
|
buffer []rune
|
|
rules [41]func() bool
|
|
parse func(rule ...int) error
|
|
reset func()
|
|
Pretty bool
|
|
tokens32
|
|
}
|
|
|
|
func (p *Asm) Parse(rule ...int) error {
|
|
return p.parse(rule...)
|
|
}
|
|
|
|
func (p *Asm) 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 *Asm
|
|
max token32
|
|
}
|
|
|
|
func (e *parseError) Error() string {
|
|
tokens, error := []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)
|
|
error += 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 error
|
|
}
|
|
|
|
func (p *Asm) PrintSyntaxTree() {
|
|
if p.Pretty {
|
|
p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
|
|
} else {
|
|
p.tokens32.PrintSyntaxTree(p.Buffer)
|
|
}
|
|
}
|
|
|
|
func (p *Asm) Init() {
|
|
var (
|
|
max token32
|
|
position, tokenIndex uint32
|
|
buffer []rune
|
|
)
|
|
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 := tokens32{tree: make([]token32, math.MaxInt16)}
|
|
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 AsmFile <- <(Statement* !.)> */
|
|
func() bool {
|
|
position0, tokenIndex0 := position, tokenIndex
|
|
{
|
|
position1 := position
|
|
l2:
|
|
{
|
|
position3, tokenIndex3 := position, tokenIndex
|
|
if !_rules[ruleStatement]() {
|
|
goto l3
|
|
}
|
|
goto l2
|
|
l3:
|
|
position, tokenIndex = position3, tokenIndex3
|
|
}
|
|
{
|
|
position4, tokenIndex4 := position, tokenIndex
|
|
if !matchDot() {
|
|
goto l4
|
|
}
|
|
goto l0
|
|
l4:
|
|
position, tokenIndex = position4, tokenIndex4
|
|
}
|
|
add(ruleAsmFile, position1)
|
|
}
|
|
return true
|
|
l0:
|
|
position, tokenIndex = position0, tokenIndex0
|
|
return false
|
|
},
|
|
/* 1 Statement <- <(WS? (Label / ((GlobalDirective / LocationDirective / LabelContainingDirective / Instruction / Directive / Comment / ) WS? ((Comment? '\n') / ';'))))> */
|
|
func() bool {
|
|
position5, tokenIndex5 := position, tokenIndex
|
|
{
|
|
position6 := position
|
|
{
|
|
position7, tokenIndex7 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l7
|
|
}
|
|
goto l8
|
|
l7:
|
|
position, tokenIndex = position7, tokenIndex7
|
|
}
|
|
l8:
|
|
{
|
|
position9, tokenIndex9 := position, tokenIndex
|
|
if !_rules[ruleLabel]() {
|
|
goto l10
|
|
}
|
|
goto l9
|
|
l10:
|
|
position, tokenIndex = position9, tokenIndex9
|
|
{
|
|
position11, tokenIndex11 := position, tokenIndex
|
|
if !_rules[ruleGlobalDirective]() {
|
|
goto l12
|
|
}
|
|
goto l11
|
|
l12:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if !_rules[ruleLocationDirective]() {
|
|
goto l13
|
|
}
|
|
goto l11
|
|
l13:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if !_rules[ruleLabelContainingDirective]() {
|
|
goto l14
|
|
}
|
|
goto l11
|
|
l14:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if !_rules[ruleInstruction]() {
|
|
goto l15
|
|
}
|
|
goto l11
|
|
l15:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if !_rules[ruleDirective]() {
|
|
goto l16
|
|
}
|
|
goto l11
|
|
l16:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
if !_rules[ruleComment]() {
|
|
goto l17
|
|
}
|
|
goto l11
|
|
l17:
|
|
position, tokenIndex = position11, tokenIndex11
|
|
}
|
|
l11:
|
|
{
|
|
position18, tokenIndex18 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l18
|
|
}
|
|
goto l19
|
|
l18:
|
|
position, tokenIndex = position18, tokenIndex18
|
|
}
|
|
l19:
|
|
{
|
|
position20, tokenIndex20 := position, tokenIndex
|
|
{
|
|
position22, tokenIndex22 := position, tokenIndex
|
|
if !_rules[ruleComment]() {
|
|
goto l22
|
|
}
|
|
goto l23
|
|
l22:
|
|
position, tokenIndex = position22, tokenIndex22
|
|
}
|
|
l23:
|
|
if buffer[position] != rune('\n') {
|
|
goto l21
|
|
}
|
|
position++
|
|
goto l20
|
|
l21:
|
|
position, tokenIndex = position20, tokenIndex20
|
|
if buffer[position] != rune(';') {
|
|
goto l5
|
|
}
|
|
position++
|
|
}
|
|
l20:
|
|
}
|
|
l9:
|
|
add(ruleStatement, position6)
|
|
}
|
|
return true
|
|
l5:
|
|
position, tokenIndex = position5, tokenIndex5
|
|
return false
|
|
},
|
|
/* 2 GlobalDirective <- <((('.' ('g' / 'G') ('l' / 'L') ('o' / 'O') ('b' / 'B') ('a' / 'A') ('l' / 'L')) / ('.' ('g' / 'G') ('l' / 'L') ('o' / 'O') ('b' / 'B') ('l' / 'L'))) WS SymbolName)> */
|
|
func() bool {
|
|
position24, tokenIndex24 := position, tokenIndex
|
|
{
|
|
position25 := position
|
|
{
|
|
position26, tokenIndex26 := position, tokenIndex
|
|
if buffer[position] != rune('.') {
|
|
goto l27
|
|
}
|
|
position++
|
|
{
|
|
position28, tokenIndex28 := position, tokenIndex
|
|
if buffer[position] != rune('g') {
|
|
goto l29
|
|
}
|
|
position++
|
|
goto l28
|
|
l29:
|
|
position, tokenIndex = position28, tokenIndex28
|
|
if buffer[position] != rune('G') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l28:
|
|
{
|
|
position30, tokenIndex30 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l31
|
|
}
|
|
position++
|
|
goto l30
|
|
l31:
|
|
position, tokenIndex = position30, tokenIndex30
|
|
if buffer[position] != rune('L') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l30:
|
|
{
|
|
position32, tokenIndex32 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l33
|
|
}
|
|
position++
|
|
goto l32
|
|
l33:
|
|
position, tokenIndex = position32, tokenIndex32
|
|
if buffer[position] != rune('O') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l32:
|
|
{
|
|
position34, tokenIndex34 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l35
|
|
}
|
|
position++
|
|
goto l34
|
|
l35:
|
|
position, tokenIndex = position34, tokenIndex34
|
|
if buffer[position] != rune('B') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l34:
|
|
{
|
|
position36, tokenIndex36 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l37
|
|
}
|
|
position++
|
|
goto l36
|
|
l37:
|
|
position, tokenIndex = position36, tokenIndex36
|
|
if buffer[position] != rune('A') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l36:
|
|
{
|
|
position38, tokenIndex38 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l39
|
|
}
|
|
position++
|
|
goto l38
|
|
l39:
|
|
position, tokenIndex = position38, tokenIndex38
|
|
if buffer[position] != rune('L') {
|
|
goto l27
|
|
}
|
|
position++
|
|
}
|
|
l38:
|
|
goto l26
|
|
l27:
|
|
position, tokenIndex = position26, tokenIndex26
|
|
if buffer[position] != rune('.') {
|
|
goto l24
|
|
}
|
|
position++
|
|
{
|
|
position40, tokenIndex40 := position, tokenIndex
|
|
if buffer[position] != rune('g') {
|
|
goto l41
|
|
}
|
|
position++
|
|
goto l40
|
|
l41:
|
|
position, tokenIndex = position40, tokenIndex40
|
|
if buffer[position] != rune('G') {
|
|
goto l24
|
|
}
|
|
position++
|
|
}
|
|
l40:
|
|
{
|
|
position42, tokenIndex42 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l43
|
|
}
|
|
position++
|
|
goto l42
|
|
l43:
|
|
position, tokenIndex = position42, tokenIndex42
|
|
if buffer[position] != rune('L') {
|
|
goto l24
|
|
}
|
|
position++
|
|
}
|
|
l42:
|
|
{
|
|
position44, tokenIndex44 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l45
|
|
}
|
|
position++
|
|
goto l44
|
|
l45:
|
|
position, tokenIndex = position44, tokenIndex44
|
|
if buffer[position] != rune('O') {
|
|
goto l24
|
|
}
|
|
position++
|
|
}
|
|
l44:
|
|
{
|
|
position46, tokenIndex46 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l47
|
|
}
|
|
position++
|
|
goto l46
|
|
l47:
|
|
position, tokenIndex = position46, tokenIndex46
|
|
if buffer[position] != rune('B') {
|
|
goto l24
|
|
}
|
|
position++
|
|
}
|
|
l46:
|
|
{
|
|
position48, tokenIndex48 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l49
|
|
}
|
|
position++
|
|
goto l48
|
|
l49:
|
|
position, tokenIndex = position48, tokenIndex48
|
|
if buffer[position] != rune('L') {
|
|
goto l24
|
|
}
|
|
position++
|
|
}
|
|
l48:
|
|
}
|
|
l26:
|
|
if !_rules[ruleWS]() {
|
|
goto l24
|
|
}
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l24
|
|
}
|
|
add(ruleGlobalDirective, position25)
|
|
}
|
|
return true
|
|
l24:
|
|
position, tokenIndex = position24, tokenIndex24
|
|
return false
|
|
},
|
|
/* 3 Directive <- <('.' DirectiveName (WS Args)?)> */
|
|
func() bool {
|
|
position50, tokenIndex50 := position, tokenIndex
|
|
{
|
|
position51 := position
|
|
if buffer[position] != rune('.') {
|
|
goto l50
|
|
}
|
|
position++
|
|
if !_rules[ruleDirectiveName]() {
|
|
goto l50
|
|
}
|
|
{
|
|
position52, tokenIndex52 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l52
|
|
}
|
|
if !_rules[ruleArgs]() {
|
|
goto l52
|
|
}
|
|
goto l53
|
|
l52:
|
|
position, tokenIndex = position52, tokenIndex52
|
|
}
|
|
l53:
|
|
add(ruleDirective, position51)
|
|
}
|
|
return true
|
|
l50:
|
|
position, tokenIndex = position50, tokenIndex50
|
|
return false
|
|
},
|
|
/* 4 DirectiveName <- <([a-z] / [A-Z] / ([0-9] / [0-9]) / '_')+> */
|
|
func() bool {
|
|
position54, tokenIndex54 := position, tokenIndex
|
|
{
|
|
position55 := position
|
|
{
|
|
position58, tokenIndex58 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l59
|
|
}
|
|
position++
|
|
goto l58
|
|
l59:
|
|
position, tokenIndex = position58, tokenIndex58
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l60
|
|
}
|
|
position++
|
|
goto l58
|
|
l60:
|
|
position, tokenIndex = position58, tokenIndex58
|
|
{
|
|
position62, tokenIndex62 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l63
|
|
}
|
|
position++
|
|
goto l62
|
|
l63:
|
|
position, tokenIndex = position62, tokenIndex62
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l61
|
|
}
|
|
position++
|
|
}
|
|
l62:
|
|
goto l58
|
|
l61:
|
|
position, tokenIndex = position58, tokenIndex58
|
|
if buffer[position] != rune('_') {
|
|
goto l54
|
|
}
|
|
position++
|
|
}
|
|
l58:
|
|
l56:
|
|
{
|
|
position57, tokenIndex57 := position, tokenIndex
|
|
{
|
|
position64, tokenIndex64 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l65
|
|
}
|
|
position++
|
|
goto l64
|
|
l65:
|
|
position, tokenIndex = position64, tokenIndex64
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l66
|
|
}
|
|
position++
|
|
goto l64
|
|
l66:
|
|
position, tokenIndex = position64, tokenIndex64
|
|
{
|
|
position68, tokenIndex68 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l69
|
|
}
|
|
position++
|
|
goto l68
|
|
l69:
|
|
position, tokenIndex = position68, tokenIndex68
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l67
|
|
}
|
|
position++
|
|
}
|
|
l68:
|
|
goto l64
|
|
l67:
|
|
position, tokenIndex = position64, tokenIndex64
|
|
if buffer[position] != rune('_') {
|
|
goto l57
|
|
}
|
|
position++
|
|
}
|
|
l64:
|
|
goto l56
|
|
l57:
|
|
position, tokenIndex = position57, tokenIndex57
|
|
}
|
|
add(ruleDirectiveName, position55)
|
|
}
|
|
return true
|
|
l54:
|
|
position, tokenIndex = position54, tokenIndex54
|
|
return false
|
|
},
|
|
/* 5 LocationDirective <- <((('.' ('f' / 'F') ('i' / 'I') ('l' / 'L') ('e' / 'E')) / ('.' ('l' / 'L') ('o' / 'O') ('c' / 'C'))) WS (!('#' / '\n') .)+)> */
|
|
func() bool {
|
|
position70, tokenIndex70 := position, tokenIndex
|
|
{
|
|
position71 := position
|
|
{
|
|
position72, tokenIndex72 := position, tokenIndex
|
|
if buffer[position] != rune('.') {
|
|
goto l73
|
|
}
|
|
position++
|
|
{
|
|
position74, tokenIndex74 := position, tokenIndex
|
|
if buffer[position] != rune('f') {
|
|
goto l75
|
|
}
|
|
position++
|
|
goto l74
|
|
l75:
|
|
position, tokenIndex = position74, tokenIndex74
|
|
if buffer[position] != rune('F') {
|
|
goto l73
|
|
}
|
|
position++
|
|
}
|
|
l74:
|
|
{
|
|
position76, tokenIndex76 := position, tokenIndex
|
|
if buffer[position] != rune('i') {
|
|
goto l77
|
|
}
|
|
position++
|
|
goto l76
|
|
l77:
|
|
position, tokenIndex = position76, tokenIndex76
|
|
if buffer[position] != rune('I') {
|
|
goto l73
|
|
}
|
|
position++
|
|
}
|
|
l76:
|
|
{
|
|
position78, tokenIndex78 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l79
|
|
}
|
|
position++
|
|
goto l78
|
|
l79:
|
|
position, tokenIndex = position78, tokenIndex78
|
|
if buffer[position] != rune('L') {
|
|
goto l73
|
|
}
|
|
position++
|
|
}
|
|
l78:
|
|
{
|
|
position80, tokenIndex80 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l81
|
|
}
|
|
position++
|
|
goto l80
|
|
l81:
|
|
position, tokenIndex = position80, tokenIndex80
|
|
if buffer[position] != rune('E') {
|
|
goto l73
|
|
}
|
|
position++
|
|
}
|
|
l80:
|
|
goto l72
|
|
l73:
|
|
position, tokenIndex = position72, tokenIndex72
|
|
if buffer[position] != rune('.') {
|
|
goto l70
|
|
}
|
|
position++
|
|
{
|
|
position82, tokenIndex82 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l83
|
|
}
|
|
position++
|
|
goto l82
|
|
l83:
|
|
position, tokenIndex = position82, tokenIndex82
|
|
if buffer[position] != rune('L') {
|
|
goto l70
|
|
}
|
|
position++
|
|
}
|
|
l82:
|
|
{
|
|
position84, tokenIndex84 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l85
|
|
}
|
|
position++
|
|
goto l84
|
|
l85:
|
|
position, tokenIndex = position84, tokenIndex84
|
|
if buffer[position] != rune('O') {
|
|
goto l70
|
|
}
|
|
position++
|
|
}
|
|
l84:
|
|
{
|
|
position86, tokenIndex86 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l87
|
|
}
|
|
position++
|
|
goto l86
|
|
l87:
|
|
position, tokenIndex = position86, tokenIndex86
|
|
if buffer[position] != rune('C') {
|
|
goto l70
|
|
}
|
|
position++
|
|
}
|
|
l86:
|
|
}
|
|
l72:
|
|
if !_rules[ruleWS]() {
|
|
goto l70
|
|
}
|
|
{
|
|
position90, tokenIndex90 := position, tokenIndex
|
|
{
|
|
position91, tokenIndex91 := position, tokenIndex
|
|
if buffer[position] != rune('#') {
|
|
goto l92
|
|
}
|
|
position++
|
|
goto l91
|
|
l92:
|
|
position, tokenIndex = position91, tokenIndex91
|
|
if buffer[position] != rune('\n') {
|
|
goto l90
|
|
}
|
|
position++
|
|
}
|
|
l91:
|
|
goto l70
|
|
l90:
|
|
position, tokenIndex = position90, tokenIndex90
|
|
}
|
|
if !matchDot() {
|
|
goto l70
|
|
}
|
|
l88:
|
|
{
|
|
position89, tokenIndex89 := position, tokenIndex
|
|
{
|
|
position93, tokenIndex93 := position, tokenIndex
|
|
{
|
|
position94, tokenIndex94 := position, tokenIndex
|
|
if buffer[position] != rune('#') {
|
|
goto l95
|
|
}
|
|
position++
|
|
goto l94
|
|
l95:
|
|
position, tokenIndex = position94, tokenIndex94
|
|
if buffer[position] != rune('\n') {
|
|
goto l93
|
|
}
|
|
position++
|
|
}
|
|
l94:
|
|
goto l89
|
|
l93:
|
|
position, tokenIndex = position93, tokenIndex93
|
|
}
|
|
if !matchDot() {
|
|
goto l89
|
|
}
|
|
goto l88
|
|
l89:
|
|
position, tokenIndex = position89, tokenIndex89
|
|
}
|
|
add(ruleLocationDirective, position71)
|
|
}
|
|
return true
|
|
l70:
|
|
position, tokenIndex = position70, tokenIndex70
|
|
return false
|
|
},
|
|
/* 6 Args <- <(Arg (WS? ',' WS? Arg)*)> */
|
|
func() bool {
|
|
position96, tokenIndex96 := position, tokenIndex
|
|
{
|
|
position97 := position
|
|
if !_rules[ruleArg]() {
|
|
goto l96
|
|
}
|
|
l98:
|
|
{
|
|
position99, tokenIndex99 := position, tokenIndex
|
|
{
|
|
position100, tokenIndex100 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l100
|
|
}
|
|
goto l101
|
|
l100:
|
|
position, tokenIndex = position100, tokenIndex100
|
|
}
|
|
l101:
|
|
if buffer[position] != rune(',') {
|
|
goto l99
|
|
}
|
|
position++
|
|
{
|
|
position102, tokenIndex102 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l102
|
|
}
|
|
goto l103
|
|
l102:
|
|
position, tokenIndex = position102, tokenIndex102
|
|
}
|
|
l103:
|
|
if !_rules[ruleArg]() {
|
|
goto l99
|
|
}
|
|
goto l98
|
|
l99:
|
|
position, tokenIndex = position99, tokenIndex99
|
|
}
|
|
add(ruleArgs, position97)
|
|
}
|
|
return true
|
|
l96:
|
|
position, tokenIndex = position96, tokenIndex96
|
|
return false
|
|
},
|
|
/* 7 Arg <- <(QuotedArg / ([0-9] / [0-9] / ([a-z] / [A-Z]) / '%' / '+' / '-' / '*' / '_' / '@' / '.')*)> */
|
|
func() bool {
|
|
{
|
|
position105 := position
|
|
{
|
|
position106, tokenIndex106 := position, tokenIndex
|
|
if !_rules[ruleQuotedArg]() {
|
|
goto l107
|
|
}
|
|
goto l106
|
|
l107:
|
|
position, tokenIndex = position106, tokenIndex106
|
|
l108:
|
|
{
|
|
position109, tokenIndex109 := position, tokenIndex
|
|
{
|
|
position110, tokenIndex110 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l111
|
|
}
|
|
position++
|
|
goto l110
|
|
l111:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l112
|
|
}
|
|
position++
|
|
goto l110
|
|
l112:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
{
|
|
position114, tokenIndex114 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l115
|
|
}
|
|
position++
|
|
goto l114
|
|
l115:
|
|
position, tokenIndex = position114, tokenIndex114
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l113
|
|
}
|
|
position++
|
|
}
|
|
l114:
|
|
goto l110
|
|
l113:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('%') {
|
|
goto l116
|
|
}
|
|
position++
|
|
goto l110
|
|
l116:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('+') {
|
|
goto l117
|
|
}
|
|
position++
|
|
goto l110
|
|
l117:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('-') {
|
|
goto l118
|
|
}
|
|
position++
|
|
goto l110
|
|
l118:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('*') {
|
|
goto l119
|
|
}
|
|
position++
|
|
goto l110
|
|
l119:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('_') {
|
|
goto l120
|
|
}
|
|
position++
|
|
goto l110
|
|
l120:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('@') {
|
|
goto l121
|
|
}
|
|
position++
|
|
goto l110
|
|
l121:
|
|
position, tokenIndex = position110, tokenIndex110
|
|
if buffer[position] != rune('.') {
|
|
goto l109
|
|
}
|
|
position++
|
|
}
|
|
l110:
|
|
goto l108
|
|
l109:
|
|
position, tokenIndex = position109, tokenIndex109
|
|
}
|
|
}
|
|
l106:
|
|
add(ruleArg, position105)
|
|
}
|
|
return true
|
|
},
|
|
/* 8 QuotedArg <- <('"' QuotedText '"')> */
|
|
func() bool {
|
|
position122, tokenIndex122 := position, tokenIndex
|
|
{
|
|
position123 := position
|
|
if buffer[position] != rune('"') {
|
|
goto l122
|
|
}
|
|
position++
|
|
if !_rules[ruleQuotedText]() {
|
|
goto l122
|
|
}
|
|
if buffer[position] != rune('"') {
|
|
goto l122
|
|
}
|
|
position++
|
|
add(ruleQuotedArg, position123)
|
|
}
|
|
return true
|
|
l122:
|
|
position, tokenIndex = position122, tokenIndex122
|
|
return false
|
|
},
|
|
/* 9 QuotedText <- <(EscapedChar / (!'"' .))*> */
|
|
func() bool {
|
|
{
|
|
position125 := position
|
|
l126:
|
|
{
|
|
position127, tokenIndex127 := position, tokenIndex
|
|
{
|
|
position128, tokenIndex128 := position, tokenIndex
|
|
if !_rules[ruleEscapedChar]() {
|
|
goto l129
|
|
}
|
|
goto l128
|
|
l129:
|
|
position, tokenIndex = position128, tokenIndex128
|
|
{
|
|
position130, tokenIndex130 := position, tokenIndex
|
|
if buffer[position] != rune('"') {
|
|
goto l130
|
|
}
|
|
position++
|
|
goto l127
|
|
l130:
|
|
position, tokenIndex = position130, tokenIndex130
|
|
}
|
|
if !matchDot() {
|
|
goto l127
|
|
}
|
|
}
|
|
l128:
|
|
goto l126
|
|
l127:
|
|
position, tokenIndex = position127, tokenIndex127
|
|
}
|
|
add(ruleQuotedText, position125)
|
|
}
|
|
return true
|
|
},
|
|
/* 10 LabelContainingDirective <- <(LabelContainingDirectiveName WS SymbolArgs)> */
|
|
func() bool {
|
|
position131, tokenIndex131 := position, tokenIndex
|
|
{
|
|
position132 := position
|
|
if !_rules[ruleLabelContainingDirectiveName]() {
|
|
goto l131
|
|
}
|
|
if !_rules[ruleWS]() {
|
|
goto l131
|
|
}
|
|
if !_rules[ruleSymbolArgs]() {
|
|
goto l131
|
|
}
|
|
add(ruleLabelContainingDirective, position132)
|
|
}
|
|
return true
|
|
l131:
|
|
position, tokenIndex = position131, tokenIndex131
|
|
return false
|
|
},
|
|
/* 11 LabelContainingDirectiveName <- <(('.' ('l' / 'L') ('o' / 'O') ('n' / 'N') ('g' / 'G')) / ('.' ('s' / 'S') ('e' / 'E') ('t' / 'T')) / ('.' '8' ('b' / 'B') ('y' / 'Y') ('t' / 'T') ('e' / 'E')) / ('.' '4' ('b' / 'B') ('y' / 'Y') ('t' / 'T') ('e' / 'E')) / ('.' ('q' / 'Q') ('u' / 'U') ('a' / 'A') ('d' / 'D')) / ('.' ('t' / 'T') ('c' / 'C')) / ('.' ('l' / 'L') ('o' / 'O') ('c' / 'C') ('a' / 'A') ('l' / 'L') ('e' / 'E') ('n' / 'N') ('t' / 'T') ('r' / 'R') ('y' / 'Y')) / ('.' ('s' / 'S') ('i' / 'I') ('z' / 'Z') ('e' / 'E')) / ('.' ('t' / 'T') ('y' / 'Y') ('p' / 'P') ('e' / 'E')) / ('.' ('u' / 'U') ('l' / 'L') ('e' / 'E') ('b' / 'B') '1' '2' '8') / ('.' ('s' / 'S') ('l' / 'L') ('e' / 'E') ('b' / 'B') '1' '2' '8'))> */
|
|
func() bool {
|
|
position133, tokenIndex133 := position, tokenIndex
|
|
{
|
|
position134 := position
|
|
{
|
|
position135, tokenIndex135 := position, tokenIndex
|
|
if buffer[position] != rune('.') {
|
|
goto l136
|
|
}
|
|
position++
|
|
{
|
|
position137, tokenIndex137 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l138
|
|
}
|
|
position++
|
|
goto l137
|
|
l138:
|
|
position, tokenIndex = position137, tokenIndex137
|
|
if buffer[position] != rune('L') {
|
|
goto l136
|
|
}
|
|
position++
|
|
}
|
|
l137:
|
|
{
|
|
position139, tokenIndex139 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l140
|
|
}
|
|
position++
|
|
goto l139
|
|
l140:
|
|
position, tokenIndex = position139, tokenIndex139
|
|
if buffer[position] != rune('O') {
|
|
goto l136
|
|
}
|
|
position++
|
|
}
|
|
l139:
|
|
{
|
|
position141, tokenIndex141 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l142
|
|
}
|
|
position++
|
|
goto l141
|
|
l142:
|
|
position, tokenIndex = position141, tokenIndex141
|
|
if buffer[position] != rune('N') {
|
|
goto l136
|
|
}
|
|
position++
|
|
}
|
|
l141:
|
|
{
|
|
position143, tokenIndex143 := position, tokenIndex
|
|
if buffer[position] != rune('g') {
|
|
goto l144
|
|
}
|
|
position++
|
|
goto l143
|
|
l144:
|
|
position, tokenIndex = position143, tokenIndex143
|
|
if buffer[position] != rune('G') {
|
|
goto l136
|
|
}
|
|
position++
|
|
}
|
|
l143:
|
|
goto l135
|
|
l136:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l145
|
|
}
|
|
position++
|
|
{
|
|
position146, tokenIndex146 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l147
|
|
}
|
|
position++
|
|
goto l146
|
|
l147:
|
|
position, tokenIndex = position146, tokenIndex146
|
|
if buffer[position] != rune('S') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l146:
|
|
{
|
|
position148, tokenIndex148 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l149
|
|
}
|
|
position++
|
|
goto l148
|
|
l149:
|
|
position, tokenIndex = position148, tokenIndex148
|
|
if buffer[position] != rune('E') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l148:
|
|
{
|
|
position150, tokenIndex150 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l151
|
|
}
|
|
position++
|
|
goto l150
|
|
l151:
|
|
position, tokenIndex = position150, tokenIndex150
|
|
if buffer[position] != rune('T') {
|
|
goto l145
|
|
}
|
|
position++
|
|
}
|
|
l150:
|
|
goto l135
|
|
l145:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l152
|
|
}
|
|
position++
|
|
if buffer[position] != rune('8') {
|
|
goto l152
|
|
}
|
|
position++
|
|
{
|
|
position153, tokenIndex153 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l154
|
|
}
|
|
position++
|
|
goto l153
|
|
l154:
|
|
position, tokenIndex = position153, tokenIndex153
|
|
if buffer[position] != rune('B') {
|
|
goto l152
|
|
}
|
|
position++
|
|
}
|
|
l153:
|
|
{
|
|
position155, tokenIndex155 := position, tokenIndex
|
|
if buffer[position] != rune('y') {
|
|
goto l156
|
|
}
|
|
position++
|
|
goto l155
|
|
l156:
|
|
position, tokenIndex = position155, tokenIndex155
|
|
if buffer[position] != rune('Y') {
|
|
goto l152
|
|
}
|
|
position++
|
|
}
|
|
l155:
|
|
{
|
|
position157, tokenIndex157 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l158
|
|
}
|
|
position++
|
|
goto l157
|
|
l158:
|
|
position, tokenIndex = position157, tokenIndex157
|
|
if buffer[position] != rune('T') {
|
|
goto l152
|
|
}
|
|
position++
|
|
}
|
|
l157:
|
|
{
|
|
position159, tokenIndex159 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l160
|
|
}
|
|
position++
|
|
goto l159
|
|
l160:
|
|
position, tokenIndex = position159, tokenIndex159
|
|
if buffer[position] != rune('E') {
|
|
goto l152
|
|
}
|
|
position++
|
|
}
|
|
l159:
|
|
goto l135
|
|
l152:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l161
|
|
}
|
|
position++
|
|
if buffer[position] != rune('4') {
|
|
goto l161
|
|
}
|
|
position++
|
|
{
|
|
position162, tokenIndex162 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l163
|
|
}
|
|
position++
|
|
goto l162
|
|
l163:
|
|
position, tokenIndex = position162, tokenIndex162
|
|
if buffer[position] != rune('B') {
|
|
goto l161
|
|
}
|
|
position++
|
|
}
|
|
l162:
|
|
{
|
|
position164, tokenIndex164 := position, tokenIndex
|
|
if buffer[position] != rune('y') {
|
|
goto l165
|
|
}
|
|
position++
|
|
goto l164
|
|
l165:
|
|
position, tokenIndex = position164, tokenIndex164
|
|
if buffer[position] != rune('Y') {
|
|
goto l161
|
|
}
|
|
position++
|
|
}
|
|
l164:
|
|
{
|
|
position166, tokenIndex166 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l167
|
|
}
|
|
position++
|
|
goto l166
|
|
l167:
|
|
position, tokenIndex = position166, tokenIndex166
|
|
if buffer[position] != rune('T') {
|
|
goto l161
|
|
}
|
|
position++
|
|
}
|
|
l166:
|
|
{
|
|
position168, tokenIndex168 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l169
|
|
}
|
|
position++
|
|
goto l168
|
|
l169:
|
|
position, tokenIndex = position168, tokenIndex168
|
|
if buffer[position] != rune('E') {
|
|
goto l161
|
|
}
|
|
position++
|
|
}
|
|
l168:
|
|
goto l135
|
|
l161:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l170
|
|
}
|
|
position++
|
|
{
|
|
position171, tokenIndex171 := position, tokenIndex
|
|
if buffer[position] != rune('q') {
|
|
goto l172
|
|
}
|
|
position++
|
|
goto l171
|
|
l172:
|
|
position, tokenIndex = position171, tokenIndex171
|
|
if buffer[position] != rune('Q') {
|
|
goto l170
|
|
}
|
|
position++
|
|
}
|
|
l171:
|
|
{
|
|
position173, tokenIndex173 := position, tokenIndex
|
|
if buffer[position] != rune('u') {
|
|
goto l174
|
|
}
|
|
position++
|
|
goto l173
|
|
l174:
|
|
position, tokenIndex = position173, tokenIndex173
|
|
if buffer[position] != rune('U') {
|
|
goto l170
|
|
}
|
|
position++
|
|
}
|
|
l173:
|
|
{
|
|
position175, tokenIndex175 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l176
|
|
}
|
|
position++
|
|
goto l175
|
|
l176:
|
|
position, tokenIndex = position175, tokenIndex175
|
|
if buffer[position] != rune('A') {
|
|
goto l170
|
|
}
|
|
position++
|
|
}
|
|
l175:
|
|
{
|
|
position177, tokenIndex177 := position, tokenIndex
|
|
if buffer[position] != rune('d') {
|
|
goto l178
|
|
}
|
|
position++
|
|
goto l177
|
|
l178:
|
|
position, tokenIndex = position177, tokenIndex177
|
|
if buffer[position] != rune('D') {
|
|
goto l170
|
|
}
|
|
position++
|
|
}
|
|
l177:
|
|
goto l135
|
|
l170:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l179
|
|
}
|
|
position++
|
|
{
|
|
position180, tokenIndex180 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l181
|
|
}
|
|
position++
|
|
goto l180
|
|
l181:
|
|
position, tokenIndex = position180, tokenIndex180
|
|
if buffer[position] != rune('T') {
|
|
goto l179
|
|
}
|
|
position++
|
|
}
|
|
l180:
|
|
{
|
|
position182, tokenIndex182 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l183
|
|
}
|
|
position++
|
|
goto l182
|
|
l183:
|
|
position, tokenIndex = position182, tokenIndex182
|
|
if buffer[position] != rune('C') {
|
|
goto l179
|
|
}
|
|
position++
|
|
}
|
|
l182:
|
|
goto l135
|
|
l179:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l184
|
|
}
|
|
position++
|
|
{
|
|
position185, tokenIndex185 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l186
|
|
}
|
|
position++
|
|
goto l185
|
|
l186:
|
|
position, tokenIndex = position185, tokenIndex185
|
|
if buffer[position] != rune('L') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l185:
|
|
{
|
|
position187, tokenIndex187 := position, tokenIndex
|
|
if buffer[position] != rune('o') {
|
|
goto l188
|
|
}
|
|
position++
|
|
goto l187
|
|
l188:
|
|
position, tokenIndex = position187, tokenIndex187
|
|
if buffer[position] != rune('O') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l187:
|
|
{
|
|
position189, tokenIndex189 := position, tokenIndex
|
|
if buffer[position] != rune('c') {
|
|
goto l190
|
|
}
|
|
position++
|
|
goto l189
|
|
l190:
|
|
position, tokenIndex = position189, tokenIndex189
|
|
if buffer[position] != rune('C') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l189:
|
|
{
|
|
position191, tokenIndex191 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l192
|
|
}
|
|
position++
|
|
goto l191
|
|
l192:
|
|
position, tokenIndex = position191, tokenIndex191
|
|
if buffer[position] != rune('A') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l191:
|
|
{
|
|
position193, tokenIndex193 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l194
|
|
}
|
|
position++
|
|
goto l193
|
|
l194:
|
|
position, tokenIndex = position193, tokenIndex193
|
|
if buffer[position] != rune('L') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l193:
|
|
{
|
|
position195, tokenIndex195 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l196
|
|
}
|
|
position++
|
|
goto l195
|
|
l196:
|
|
position, tokenIndex = position195, tokenIndex195
|
|
if buffer[position] != rune('E') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l195:
|
|
{
|
|
position197, tokenIndex197 := position, tokenIndex
|
|
if buffer[position] != rune('n') {
|
|
goto l198
|
|
}
|
|
position++
|
|
goto l197
|
|
l198:
|
|
position, tokenIndex = position197, tokenIndex197
|
|
if buffer[position] != rune('N') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l197:
|
|
{
|
|
position199, tokenIndex199 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l200
|
|
}
|
|
position++
|
|
goto l199
|
|
l200:
|
|
position, tokenIndex = position199, tokenIndex199
|
|
if buffer[position] != rune('T') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l199:
|
|
{
|
|
position201, tokenIndex201 := position, tokenIndex
|
|
if buffer[position] != rune('r') {
|
|
goto l202
|
|
}
|
|
position++
|
|
goto l201
|
|
l202:
|
|
position, tokenIndex = position201, tokenIndex201
|
|
if buffer[position] != rune('R') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l201:
|
|
{
|
|
position203, tokenIndex203 := position, tokenIndex
|
|
if buffer[position] != rune('y') {
|
|
goto l204
|
|
}
|
|
position++
|
|
goto l203
|
|
l204:
|
|
position, tokenIndex = position203, tokenIndex203
|
|
if buffer[position] != rune('Y') {
|
|
goto l184
|
|
}
|
|
position++
|
|
}
|
|
l203:
|
|
goto l135
|
|
l184:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l205
|
|
}
|
|
position++
|
|
{
|
|
position206, tokenIndex206 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l207
|
|
}
|
|
position++
|
|
goto l206
|
|
l207:
|
|
position, tokenIndex = position206, tokenIndex206
|
|
if buffer[position] != rune('S') {
|
|
goto l205
|
|
}
|
|
position++
|
|
}
|
|
l206:
|
|
{
|
|
position208, tokenIndex208 := position, tokenIndex
|
|
if buffer[position] != rune('i') {
|
|
goto l209
|
|
}
|
|
position++
|
|
goto l208
|
|
l209:
|
|
position, tokenIndex = position208, tokenIndex208
|
|
if buffer[position] != rune('I') {
|
|
goto l205
|
|
}
|
|
position++
|
|
}
|
|
l208:
|
|
{
|
|
position210, tokenIndex210 := position, tokenIndex
|
|
if buffer[position] != rune('z') {
|
|
goto l211
|
|
}
|
|
position++
|
|
goto l210
|
|
l211:
|
|
position, tokenIndex = position210, tokenIndex210
|
|
if buffer[position] != rune('Z') {
|
|
goto l205
|
|
}
|
|
position++
|
|
}
|
|
l210:
|
|
{
|
|
position212, tokenIndex212 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l213
|
|
}
|
|
position++
|
|
goto l212
|
|
l213:
|
|
position, tokenIndex = position212, tokenIndex212
|
|
if buffer[position] != rune('E') {
|
|
goto l205
|
|
}
|
|
position++
|
|
}
|
|
l212:
|
|
goto l135
|
|
l205:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l214
|
|
}
|
|
position++
|
|
{
|
|
position215, tokenIndex215 := position, tokenIndex
|
|
if buffer[position] != rune('t') {
|
|
goto l216
|
|
}
|
|
position++
|
|
goto l215
|
|
l216:
|
|
position, tokenIndex = position215, tokenIndex215
|
|
if buffer[position] != rune('T') {
|
|
goto l214
|
|
}
|
|
position++
|
|
}
|
|
l215:
|
|
{
|
|
position217, tokenIndex217 := position, tokenIndex
|
|
if buffer[position] != rune('y') {
|
|
goto l218
|
|
}
|
|
position++
|
|
goto l217
|
|
l218:
|
|
position, tokenIndex = position217, tokenIndex217
|
|
if buffer[position] != rune('Y') {
|
|
goto l214
|
|
}
|
|
position++
|
|
}
|
|
l217:
|
|
{
|
|
position219, tokenIndex219 := position, tokenIndex
|
|
if buffer[position] != rune('p') {
|
|
goto l220
|
|
}
|
|
position++
|
|
goto l219
|
|
l220:
|
|
position, tokenIndex = position219, tokenIndex219
|
|
if buffer[position] != rune('P') {
|
|
goto l214
|
|
}
|
|
position++
|
|
}
|
|
l219:
|
|
{
|
|
position221, tokenIndex221 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l222
|
|
}
|
|
position++
|
|
goto l221
|
|
l222:
|
|
position, tokenIndex = position221, tokenIndex221
|
|
if buffer[position] != rune('E') {
|
|
goto l214
|
|
}
|
|
position++
|
|
}
|
|
l221:
|
|
goto l135
|
|
l214:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l223
|
|
}
|
|
position++
|
|
{
|
|
position224, tokenIndex224 := position, tokenIndex
|
|
if buffer[position] != rune('u') {
|
|
goto l225
|
|
}
|
|
position++
|
|
goto l224
|
|
l225:
|
|
position, tokenIndex = position224, tokenIndex224
|
|
if buffer[position] != rune('U') {
|
|
goto l223
|
|
}
|
|
position++
|
|
}
|
|
l224:
|
|
{
|
|
position226, tokenIndex226 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l227
|
|
}
|
|
position++
|
|
goto l226
|
|
l227:
|
|
position, tokenIndex = position226, tokenIndex226
|
|
if buffer[position] != rune('L') {
|
|
goto l223
|
|
}
|
|
position++
|
|
}
|
|
l226:
|
|
{
|
|
position228, tokenIndex228 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l229
|
|
}
|
|
position++
|
|
goto l228
|
|
l229:
|
|
position, tokenIndex = position228, tokenIndex228
|
|
if buffer[position] != rune('E') {
|
|
goto l223
|
|
}
|
|
position++
|
|
}
|
|
l228:
|
|
{
|
|
position230, tokenIndex230 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l231
|
|
}
|
|
position++
|
|
goto l230
|
|
l231:
|
|
position, tokenIndex = position230, tokenIndex230
|
|
if buffer[position] != rune('B') {
|
|
goto l223
|
|
}
|
|
position++
|
|
}
|
|
l230:
|
|
if buffer[position] != rune('1') {
|
|
goto l223
|
|
}
|
|
position++
|
|
if buffer[position] != rune('2') {
|
|
goto l223
|
|
}
|
|
position++
|
|
if buffer[position] != rune('8') {
|
|
goto l223
|
|
}
|
|
position++
|
|
goto l135
|
|
l223:
|
|
position, tokenIndex = position135, tokenIndex135
|
|
if buffer[position] != rune('.') {
|
|
goto l133
|
|
}
|
|
position++
|
|
{
|
|
position232, tokenIndex232 := position, tokenIndex
|
|
if buffer[position] != rune('s') {
|
|
goto l233
|
|
}
|
|
position++
|
|
goto l232
|
|
l233:
|
|
position, tokenIndex = position232, tokenIndex232
|
|
if buffer[position] != rune('S') {
|
|
goto l133
|
|
}
|
|
position++
|
|
}
|
|
l232:
|
|
{
|
|
position234, tokenIndex234 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l235
|
|
}
|
|
position++
|
|
goto l234
|
|
l235:
|
|
position, tokenIndex = position234, tokenIndex234
|
|
if buffer[position] != rune('L') {
|
|
goto l133
|
|
}
|
|
position++
|
|
}
|
|
l234:
|
|
{
|
|
position236, tokenIndex236 := position, tokenIndex
|
|
if buffer[position] != rune('e') {
|
|
goto l237
|
|
}
|
|
position++
|
|
goto l236
|
|
l237:
|
|
position, tokenIndex = position236, tokenIndex236
|
|
if buffer[position] != rune('E') {
|
|
goto l133
|
|
}
|
|
position++
|
|
}
|
|
l236:
|
|
{
|
|
position238, tokenIndex238 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l239
|
|
}
|
|
position++
|
|
goto l238
|
|
l239:
|
|
position, tokenIndex = position238, tokenIndex238
|
|
if buffer[position] != rune('B') {
|
|
goto l133
|
|
}
|
|
position++
|
|
}
|
|
l238:
|
|
if buffer[position] != rune('1') {
|
|
goto l133
|
|
}
|
|
position++
|
|
if buffer[position] != rune('2') {
|
|
goto l133
|
|
}
|
|
position++
|
|
if buffer[position] != rune('8') {
|
|
goto l133
|
|
}
|
|
position++
|
|
}
|
|
l135:
|
|
add(ruleLabelContainingDirectiveName, position134)
|
|
}
|
|
return true
|
|
l133:
|
|
position, tokenIndex = position133, tokenIndex133
|
|
return false
|
|
},
|
|
/* 12 SymbolArgs <- <(SymbolArg (WS? ',' WS? SymbolArg)*)> */
|
|
func() bool {
|
|
position240, tokenIndex240 := position, tokenIndex
|
|
{
|
|
position241 := position
|
|
if !_rules[ruleSymbolArg]() {
|
|
goto l240
|
|
}
|
|
l242:
|
|
{
|
|
position243, tokenIndex243 := position, tokenIndex
|
|
{
|
|
position244, tokenIndex244 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l244
|
|
}
|
|
goto l245
|
|
l244:
|
|
position, tokenIndex = position244, tokenIndex244
|
|
}
|
|
l245:
|
|
if buffer[position] != rune(',') {
|
|
goto l243
|
|
}
|
|
position++
|
|
{
|
|
position246, tokenIndex246 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l246
|
|
}
|
|
goto l247
|
|
l246:
|
|
position, tokenIndex = position246, tokenIndex246
|
|
}
|
|
l247:
|
|
if !_rules[ruleSymbolArg]() {
|
|
goto l243
|
|
}
|
|
goto l242
|
|
l243:
|
|
position, tokenIndex = position243, tokenIndex243
|
|
}
|
|
add(ruleSymbolArgs, position241)
|
|
}
|
|
return true
|
|
l240:
|
|
position, tokenIndex = position240, tokenIndex240
|
|
return false
|
|
},
|
|
/* 13 SymbolArg <- <(Offset / SymbolType / ((Offset / LocalSymbol / SymbolName / Dot) WS? Operator WS? (Offset / LocalSymbol / SymbolName)) / (LocalSymbol TCMarker?) / (SymbolName Offset) / (SymbolName TCMarker?))> */
|
|
func() bool {
|
|
position248, tokenIndex248 := position, tokenIndex
|
|
{
|
|
position249 := position
|
|
{
|
|
position250, tokenIndex250 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l251
|
|
}
|
|
goto l250
|
|
l251:
|
|
position, tokenIndex = position250, tokenIndex250
|
|
if !_rules[ruleSymbolType]() {
|
|
goto l252
|
|
}
|
|
goto l250
|
|
l252:
|
|
position, tokenIndex = position250, tokenIndex250
|
|
{
|
|
position254, tokenIndex254 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l255
|
|
}
|
|
goto l254
|
|
l255:
|
|
position, tokenIndex = position254, tokenIndex254
|
|
if !_rules[ruleLocalSymbol]() {
|
|
goto l256
|
|
}
|
|
goto l254
|
|
l256:
|
|
position, tokenIndex = position254, tokenIndex254
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l257
|
|
}
|
|
goto l254
|
|
l257:
|
|
position, tokenIndex = position254, tokenIndex254
|
|
if !_rules[ruleDot]() {
|
|
goto l253
|
|
}
|
|
}
|
|
l254:
|
|
{
|
|
position258, tokenIndex258 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l258
|
|
}
|
|
goto l259
|
|
l258:
|
|
position, tokenIndex = position258, tokenIndex258
|
|
}
|
|
l259:
|
|
if !_rules[ruleOperator]() {
|
|
goto l253
|
|
}
|
|
{
|
|
position260, tokenIndex260 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l260
|
|
}
|
|
goto l261
|
|
l260:
|
|
position, tokenIndex = position260, tokenIndex260
|
|
}
|
|
l261:
|
|
{
|
|
position262, tokenIndex262 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l263
|
|
}
|
|
goto l262
|
|
l263:
|
|
position, tokenIndex = position262, tokenIndex262
|
|
if !_rules[ruleLocalSymbol]() {
|
|
goto l264
|
|
}
|
|
goto l262
|
|
l264:
|
|
position, tokenIndex = position262, tokenIndex262
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l253
|
|
}
|
|
}
|
|
l262:
|
|
goto l250
|
|
l253:
|
|
position, tokenIndex = position250, tokenIndex250
|
|
if !_rules[ruleLocalSymbol]() {
|
|
goto l265
|
|
}
|
|
{
|
|
position266, tokenIndex266 := position, tokenIndex
|
|
if !_rules[ruleTCMarker]() {
|
|
goto l266
|
|
}
|
|
goto l267
|
|
l266:
|
|
position, tokenIndex = position266, tokenIndex266
|
|
}
|
|
l267:
|
|
goto l250
|
|
l265:
|
|
position, tokenIndex = position250, tokenIndex250
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l268
|
|
}
|
|
if !_rules[ruleOffset]() {
|
|
goto l268
|
|
}
|
|
goto l250
|
|
l268:
|
|
position, tokenIndex = position250, tokenIndex250
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l248
|
|
}
|
|
{
|
|
position269, tokenIndex269 := position, tokenIndex
|
|
if !_rules[ruleTCMarker]() {
|
|
goto l269
|
|
}
|
|
goto l270
|
|
l269:
|
|
position, tokenIndex = position269, tokenIndex269
|
|
}
|
|
l270:
|
|
}
|
|
l250:
|
|
add(ruleSymbolArg, position249)
|
|
}
|
|
return true
|
|
l248:
|
|
position, tokenIndex = position248, tokenIndex248
|
|
return false
|
|
},
|
|
/* 14 SymbolType <- <(('@' 'f' 'u' 'n' 'c' 't' 'i' 'o' 'n') / ('@' 'o' 'b' 'j' 'e' 'c' 't'))> */
|
|
func() bool {
|
|
position271, tokenIndex271 := position, tokenIndex
|
|
{
|
|
position272 := position
|
|
{
|
|
position273, tokenIndex273 := position, tokenIndex
|
|
if buffer[position] != rune('@') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('f') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('u') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('n') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('c') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('i') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l274
|
|
}
|
|
position++
|
|
if buffer[position] != rune('n') {
|
|
goto l274
|
|
}
|
|
position++
|
|
goto l273
|
|
l274:
|
|
position, tokenIndex = position273, tokenIndex273
|
|
if buffer[position] != rune('@') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('o') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('b') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('j') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('e') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('c') {
|
|
goto l271
|
|
}
|
|
position++
|
|
if buffer[position] != rune('t') {
|
|
goto l271
|
|
}
|
|
position++
|
|
}
|
|
l273:
|
|
add(ruleSymbolType, position272)
|
|
}
|
|
return true
|
|
l271:
|
|
position, tokenIndex = position271, tokenIndex271
|
|
return false
|
|
},
|
|
/* 15 Dot <- <'.'> */
|
|
func() bool {
|
|
position275, tokenIndex275 := position, tokenIndex
|
|
{
|
|
position276 := position
|
|
if buffer[position] != rune('.') {
|
|
goto l275
|
|
}
|
|
position++
|
|
add(ruleDot, position276)
|
|
}
|
|
return true
|
|
l275:
|
|
position, tokenIndex = position275, tokenIndex275
|
|
return false
|
|
},
|
|
/* 16 TCMarker <- <('[' 'T' 'C' ']')> */
|
|
func() bool {
|
|
position277, tokenIndex277 := position, tokenIndex
|
|
{
|
|
position278 := position
|
|
if buffer[position] != rune('[') {
|
|
goto l277
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l277
|
|
}
|
|
position++
|
|
if buffer[position] != rune('C') {
|
|
goto l277
|
|
}
|
|
position++
|
|
if buffer[position] != rune(']') {
|
|
goto l277
|
|
}
|
|
position++
|
|
add(ruleTCMarker, position278)
|
|
}
|
|
return true
|
|
l277:
|
|
position, tokenIndex = position277, tokenIndex277
|
|
return false
|
|
},
|
|
/* 17 EscapedChar <- <('\\' .)> */
|
|
func() bool {
|
|
position279, tokenIndex279 := position, tokenIndex
|
|
{
|
|
position280 := position
|
|
if buffer[position] != rune('\\') {
|
|
goto l279
|
|
}
|
|
position++
|
|
if !matchDot() {
|
|
goto l279
|
|
}
|
|
add(ruleEscapedChar, position280)
|
|
}
|
|
return true
|
|
l279:
|
|
position, tokenIndex = position279, tokenIndex279
|
|
return false
|
|
},
|
|
/* 18 WS <- <(' ' / '\t')+> */
|
|
func() bool {
|
|
position281, tokenIndex281 := position, tokenIndex
|
|
{
|
|
position282 := position
|
|
{
|
|
position285, tokenIndex285 := position, tokenIndex
|
|
if buffer[position] != rune(' ') {
|
|
goto l286
|
|
}
|
|
position++
|
|
goto l285
|
|
l286:
|
|
position, tokenIndex = position285, tokenIndex285
|
|
if buffer[position] != rune('\t') {
|
|
goto l281
|
|
}
|
|
position++
|
|
}
|
|
l285:
|
|
l283:
|
|
{
|
|
position284, tokenIndex284 := position, tokenIndex
|
|
{
|
|
position287, tokenIndex287 := position, tokenIndex
|
|
if buffer[position] != rune(' ') {
|
|
goto l288
|
|
}
|
|
position++
|
|
goto l287
|
|
l288:
|
|
position, tokenIndex = position287, tokenIndex287
|
|
if buffer[position] != rune('\t') {
|
|
goto l284
|
|
}
|
|
position++
|
|
}
|
|
l287:
|
|
goto l283
|
|
l284:
|
|
position, tokenIndex = position284, tokenIndex284
|
|
}
|
|
add(ruleWS, position282)
|
|
}
|
|
return true
|
|
l281:
|
|
position, tokenIndex = position281, tokenIndex281
|
|
return false
|
|
},
|
|
/* 19 Comment <- <('#' (!'\n' .)*)> */
|
|
func() bool {
|
|
position289, tokenIndex289 := position, tokenIndex
|
|
{
|
|
position290 := position
|
|
if buffer[position] != rune('#') {
|
|
goto l289
|
|
}
|
|
position++
|
|
l291:
|
|
{
|
|
position292, tokenIndex292 := position, tokenIndex
|
|
{
|
|
position293, tokenIndex293 := position, tokenIndex
|
|
if buffer[position] != rune('\n') {
|
|
goto l293
|
|
}
|
|
position++
|
|
goto l292
|
|
l293:
|
|
position, tokenIndex = position293, tokenIndex293
|
|
}
|
|
if !matchDot() {
|
|
goto l292
|
|
}
|
|
goto l291
|
|
l292:
|
|
position, tokenIndex = position292, tokenIndex292
|
|
}
|
|
add(ruleComment, position290)
|
|
}
|
|
return true
|
|
l289:
|
|
position, tokenIndex = position289, tokenIndex289
|
|
return false
|
|
},
|
|
/* 20 Label <- <((LocalSymbol / LocalLabel / SymbolName) ':')> */
|
|
func() bool {
|
|
position294, tokenIndex294 := position, tokenIndex
|
|
{
|
|
position295 := position
|
|
{
|
|
position296, tokenIndex296 := position, tokenIndex
|
|
if !_rules[ruleLocalSymbol]() {
|
|
goto l297
|
|
}
|
|
goto l296
|
|
l297:
|
|
position, tokenIndex = position296, tokenIndex296
|
|
if !_rules[ruleLocalLabel]() {
|
|
goto l298
|
|
}
|
|
goto l296
|
|
l298:
|
|
position, tokenIndex = position296, tokenIndex296
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l294
|
|
}
|
|
}
|
|
l296:
|
|
if buffer[position] != rune(':') {
|
|
goto l294
|
|
}
|
|
position++
|
|
add(ruleLabel, position295)
|
|
}
|
|
return true
|
|
l294:
|
|
position, tokenIndex = position294, tokenIndex294
|
|
return false
|
|
},
|
|
/* 21 SymbolName <- <(([a-z] / [A-Z] / '.' / '_') ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')*)> */
|
|
func() bool {
|
|
position299, tokenIndex299 := position, tokenIndex
|
|
{
|
|
position300 := position
|
|
{
|
|
position301, tokenIndex301 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l302
|
|
}
|
|
position++
|
|
goto l301
|
|
l302:
|
|
position, tokenIndex = position301, tokenIndex301
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l303
|
|
}
|
|
position++
|
|
goto l301
|
|
l303:
|
|
position, tokenIndex = position301, tokenIndex301
|
|
if buffer[position] != rune('.') {
|
|
goto l304
|
|
}
|
|
position++
|
|
goto l301
|
|
l304:
|
|
position, tokenIndex = position301, tokenIndex301
|
|
if buffer[position] != rune('_') {
|
|
goto l299
|
|
}
|
|
position++
|
|
}
|
|
l301:
|
|
l305:
|
|
{
|
|
position306, tokenIndex306 := position, tokenIndex
|
|
{
|
|
position307, tokenIndex307 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l308
|
|
}
|
|
position++
|
|
goto l307
|
|
l308:
|
|
position, tokenIndex = position307, tokenIndex307
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l309
|
|
}
|
|
position++
|
|
goto l307
|
|
l309:
|
|
position, tokenIndex = position307, tokenIndex307
|
|
if buffer[position] != rune('.') {
|
|
goto l310
|
|
}
|
|
position++
|
|
goto l307
|
|
l310:
|
|
position, tokenIndex = position307, tokenIndex307
|
|
{
|
|
position312, tokenIndex312 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l313
|
|
}
|
|
position++
|
|
goto l312
|
|
l313:
|
|
position, tokenIndex = position312, tokenIndex312
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l311
|
|
}
|
|
position++
|
|
}
|
|
l312:
|
|
goto l307
|
|
l311:
|
|
position, tokenIndex = position307, tokenIndex307
|
|
if buffer[position] != rune('$') {
|
|
goto l314
|
|
}
|
|
position++
|
|
goto l307
|
|
l314:
|
|
position, tokenIndex = position307, tokenIndex307
|
|
if buffer[position] != rune('_') {
|
|
goto l306
|
|
}
|
|
position++
|
|
}
|
|
l307:
|
|
goto l305
|
|
l306:
|
|
position, tokenIndex = position306, tokenIndex306
|
|
}
|
|
add(ruleSymbolName, position300)
|
|
}
|
|
return true
|
|
l299:
|
|
position, tokenIndex = position299, tokenIndex299
|
|
return false
|
|
},
|
|
/* 22 LocalSymbol <- <('.' 'L' ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')+)> */
|
|
func() bool {
|
|
position315, tokenIndex315 := position, tokenIndex
|
|
{
|
|
position316 := position
|
|
if buffer[position] != rune('.') {
|
|
goto l315
|
|
}
|
|
position++
|
|
if buffer[position] != rune('L') {
|
|
goto l315
|
|
}
|
|
position++
|
|
{
|
|
position319, tokenIndex319 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l320
|
|
}
|
|
position++
|
|
goto l319
|
|
l320:
|
|
position, tokenIndex = position319, tokenIndex319
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l321
|
|
}
|
|
position++
|
|
goto l319
|
|
l321:
|
|
position, tokenIndex = position319, tokenIndex319
|
|
if buffer[position] != rune('.') {
|
|
goto l322
|
|
}
|
|
position++
|
|
goto l319
|
|
l322:
|
|
position, tokenIndex = position319, tokenIndex319
|
|
{
|
|
position324, tokenIndex324 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l325
|
|
}
|
|
position++
|
|
goto l324
|
|
l325:
|
|
position, tokenIndex = position324, tokenIndex324
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l323
|
|
}
|
|
position++
|
|
}
|
|
l324:
|
|
goto l319
|
|
l323:
|
|
position, tokenIndex = position319, tokenIndex319
|
|
if buffer[position] != rune('$') {
|
|
goto l326
|
|
}
|
|
position++
|
|
goto l319
|
|
l326:
|
|
position, tokenIndex = position319, tokenIndex319
|
|
if buffer[position] != rune('_') {
|
|
goto l315
|
|
}
|
|
position++
|
|
}
|
|
l319:
|
|
l317:
|
|
{
|
|
position318, tokenIndex318 := position, tokenIndex
|
|
{
|
|
position327, tokenIndex327 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l328
|
|
}
|
|
position++
|
|
goto l327
|
|
l328:
|
|
position, tokenIndex = position327, tokenIndex327
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l329
|
|
}
|
|
position++
|
|
goto l327
|
|
l329:
|
|
position, tokenIndex = position327, tokenIndex327
|
|
if buffer[position] != rune('.') {
|
|
goto l330
|
|
}
|
|
position++
|
|
goto l327
|
|
l330:
|
|
position, tokenIndex = position327, tokenIndex327
|
|
{
|
|
position332, tokenIndex332 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l333
|
|
}
|
|
position++
|
|
goto l332
|
|
l333:
|
|
position, tokenIndex = position332, tokenIndex332
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l331
|
|
}
|
|
position++
|
|
}
|
|
l332:
|
|
goto l327
|
|
l331:
|
|
position, tokenIndex = position327, tokenIndex327
|
|
if buffer[position] != rune('$') {
|
|
goto l334
|
|
}
|
|
position++
|
|
goto l327
|
|
l334:
|
|
position, tokenIndex = position327, tokenIndex327
|
|
if buffer[position] != rune('_') {
|
|
goto l318
|
|
}
|
|
position++
|
|
}
|
|
l327:
|
|
goto l317
|
|
l318:
|
|
position, tokenIndex = position318, tokenIndex318
|
|
}
|
|
add(ruleLocalSymbol, position316)
|
|
}
|
|
return true
|
|
l315:
|
|
position, tokenIndex = position315, tokenIndex315
|
|
return false
|
|
},
|
|
/* 23 LocalLabel <- <([0-9] ([0-9] / '$')*)> */
|
|
func() bool {
|
|
position335, tokenIndex335 := position, tokenIndex
|
|
{
|
|
position336 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l335
|
|
}
|
|
position++
|
|
l337:
|
|
{
|
|
position338, tokenIndex338 := position, tokenIndex
|
|
{
|
|
position339, tokenIndex339 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l340
|
|
}
|
|
position++
|
|
goto l339
|
|
l340:
|
|
position, tokenIndex = position339, tokenIndex339
|
|
if buffer[position] != rune('$') {
|
|
goto l338
|
|
}
|
|
position++
|
|
}
|
|
l339:
|
|
goto l337
|
|
l338:
|
|
position, tokenIndex = position338, tokenIndex338
|
|
}
|
|
add(ruleLocalLabel, position336)
|
|
}
|
|
return true
|
|
l335:
|
|
position, tokenIndex = position335, tokenIndex335
|
|
return false
|
|
},
|
|
/* 24 LocalLabelRef <- <([0-9] ([0-9] / '$')* ('b' / 'f'))> */
|
|
func() bool {
|
|
position341, tokenIndex341 := position, tokenIndex
|
|
{
|
|
position342 := position
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l341
|
|
}
|
|
position++
|
|
l343:
|
|
{
|
|
position344, tokenIndex344 := position, tokenIndex
|
|
{
|
|
position345, tokenIndex345 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l346
|
|
}
|
|
position++
|
|
goto l345
|
|
l346:
|
|
position, tokenIndex = position345, tokenIndex345
|
|
if buffer[position] != rune('$') {
|
|
goto l344
|
|
}
|
|
position++
|
|
}
|
|
l345:
|
|
goto l343
|
|
l344:
|
|
position, tokenIndex = position344, tokenIndex344
|
|
}
|
|
{
|
|
position347, tokenIndex347 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l348
|
|
}
|
|
position++
|
|
goto l347
|
|
l348:
|
|
position, tokenIndex = position347, tokenIndex347
|
|
if buffer[position] != rune('f') {
|
|
goto l341
|
|
}
|
|
position++
|
|
}
|
|
l347:
|
|
add(ruleLocalLabelRef, position342)
|
|
}
|
|
return true
|
|
l341:
|
|
position, tokenIndex = position341, tokenIndex341
|
|
return false
|
|
},
|
|
/* 25 Instruction <- <(InstructionName (WS InstructionArg (WS? ',' WS? InstructionArg)*)?)> */
|
|
func() bool {
|
|
position349, tokenIndex349 := position, tokenIndex
|
|
{
|
|
position350 := position
|
|
if !_rules[ruleInstructionName]() {
|
|
goto l349
|
|
}
|
|
{
|
|
position351, tokenIndex351 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l351
|
|
}
|
|
if !_rules[ruleInstructionArg]() {
|
|
goto l351
|
|
}
|
|
l353:
|
|
{
|
|
position354, tokenIndex354 := position, tokenIndex
|
|
{
|
|
position355, tokenIndex355 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l355
|
|
}
|
|
goto l356
|
|
l355:
|
|
position, tokenIndex = position355, tokenIndex355
|
|
}
|
|
l356:
|
|
if buffer[position] != rune(',') {
|
|
goto l354
|
|
}
|
|
position++
|
|
{
|
|
position357, tokenIndex357 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l357
|
|
}
|
|
goto l358
|
|
l357:
|
|
position, tokenIndex = position357, tokenIndex357
|
|
}
|
|
l358:
|
|
if !_rules[ruleInstructionArg]() {
|
|
goto l354
|
|
}
|
|
goto l353
|
|
l354:
|
|
position, tokenIndex = position354, tokenIndex354
|
|
}
|
|
goto l352
|
|
l351:
|
|
position, tokenIndex = position351, tokenIndex351
|
|
}
|
|
l352:
|
|
add(ruleInstruction, position350)
|
|
}
|
|
return true
|
|
l349:
|
|
position, tokenIndex = position349, tokenIndex349
|
|
return false
|
|
},
|
|
/* 26 InstructionName <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))* ('.' / '+' / '-')?)> */
|
|
func() bool {
|
|
position359, tokenIndex359 := position, tokenIndex
|
|
{
|
|
position360 := position
|
|
{
|
|
position361, tokenIndex361 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l362
|
|
}
|
|
position++
|
|
goto l361
|
|
l362:
|
|
position, tokenIndex = position361, tokenIndex361
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l359
|
|
}
|
|
position++
|
|
}
|
|
l361:
|
|
l363:
|
|
{
|
|
position364, tokenIndex364 := position, tokenIndex
|
|
{
|
|
position365, tokenIndex365 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l366
|
|
}
|
|
position++
|
|
goto l365
|
|
l366:
|
|
position, tokenIndex = position365, tokenIndex365
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l367
|
|
}
|
|
position++
|
|
goto l365
|
|
l367:
|
|
position, tokenIndex = position365, tokenIndex365
|
|
{
|
|
position368, tokenIndex368 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l369
|
|
}
|
|
position++
|
|
goto l368
|
|
l369:
|
|
position, tokenIndex = position368, tokenIndex368
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l364
|
|
}
|
|
position++
|
|
}
|
|
l368:
|
|
}
|
|
l365:
|
|
goto l363
|
|
l364:
|
|
position, tokenIndex = position364, tokenIndex364
|
|
}
|
|
{
|
|
position370, tokenIndex370 := position, tokenIndex
|
|
{
|
|
position372, tokenIndex372 := position, tokenIndex
|
|
if buffer[position] != rune('.') {
|
|
goto l373
|
|
}
|
|
position++
|
|
goto l372
|
|
l373:
|
|
position, tokenIndex = position372, tokenIndex372
|
|
if buffer[position] != rune('+') {
|
|
goto l374
|
|
}
|
|
position++
|
|
goto l372
|
|
l374:
|
|
position, tokenIndex = position372, tokenIndex372
|
|
if buffer[position] != rune('-') {
|
|
goto l370
|
|
}
|
|
position++
|
|
}
|
|
l372:
|
|
goto l371
|
|
l370:
|
|
position, tokenIndex = position370, tokenIndex370
|
|
}
|
|
l371:
|
|
add(ruleInstructionName, position360)
|
|
}
|
|
return true
|
|
l359:
|
|
position, tokenIndex = position359, tokenIndex359
|
|
return false
|
|
},
|
|
/* 27 InstructionArg <- <(IndirectionIndicator? (RegisterOrConstant / LocalLabelRef / TOCRefHigh / TOCRefLow / MemoryRef) AVX512Token*)> */
|
|
func() bool {
|
|
position375, tokenIndex375 := position, tokenIndex
|
|
{
|
|
position376 := position
|
|
{
|
|
position377, tokenIndex377 := position, tokenIndex
|
|
if !_rules[ruleIndirectionIndicator]() {
|
|
goto l377
|
|
}
|
|
goto l378
|
|
l377:
|
|
position, tokenIndex = position377, tokenIndex377
|
|
}
|
|
l378:
|
|
{
|
|
position379, tokenIndex379 := position, tokenIndex
|
|
if !_rules[ruleRegisterOrConstant]() {
|
|
goto l380
|
|
}
|
|
goto l379
|
|
l380:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if !_rules[ruleLocalLabelRef]() {
|
|
goto l381
|
|
}
|
|
goto l379
|
|
l381:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if !_rules[ruleTOCRefHigh]() {
|
|
goto l382
|
|
}
|
|
goto l379
|
|
l382:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if !_rules[ruleTOCRefLow]() {
|
|
goto l383
|
|
}
|
|
goto l379
|
|
l383:
|
|
position, tokenIndex = position379, tokenIndex379
|
|
if !_rules[ruleMemoryRef]() {
|
|
goto l375
|
|
}
|
|
}
|
|
l379:
|
|
l384:
|
|
{
|
|
position385, tokenIndex385 := position, tokenIndex
|
|
if !_rules[ruleAVX512Token]() {
|
|
goto l385
|
|
}
|
|
goto l384
|
|
l385:
|
|
position, tokenIndex = position385, tokenIndex385
|
|
}
|
|
add(ruleInstructionArg, position376)
|
|
}
|
|
return true
|
|
l375:
|
|
position, tokenIndex = position375, tokenIndex375
|
|
return false
|
|
},
|
|
/* 28 AVX512Token <- <(WS? '{' '%'? ([0-9] / [a-z])* '}')> */
|
|
func() bool {
|
|
position386, tokenIndex386 := position, tokenIndex
|
|
{
|
|
position387 := position
|
|
{
|
|
position388, tokenIndex388 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l388
|
|
}
|
|
goto l389
|
|
l388:
|
|
position, tokenIndex = position388, tokenIndex388
|
|
}
|
|
l389:
|
|
if buffer[position] != rune('{') {
|
|
goto l386
|
|
}
|
|
position++
|
|
{
|
|
position390, tokenIndex390 := position, tokenIndex
|
|
if buffer[position] != rune('%') {
|
|
goto l390
|
|
}
|
|
position++
|
|
goto l391
|
|
l390:
|
|
position, tokenIndex = position390, tokenIndex390
|
|
}
|
|
l391:
|
|
l392:
|
|
{
|
|
position393, tokenIndex393 := position, tokenIndex
|
|
{
|
|
position394, tokenIndex394 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l395
|
|
}
|
|
position++
|
|
goto l394
|
|
l395:
|
|
position, tokenIndex = position394, tokenIndex394
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l393
|
|
}
|
|
position++
|
|
}
|
|
l394:
|
|
goto l392
|
|
l393:
|
|
position, tokenIndex = position393, tokenIndex393
|
|
}
|
|
if buffer[position] != rune('}') {
|
|
goto l386
|
|
}
|
|
position++
|
|
add(ruleAVX512Token, position387)
|
|
}
|
|
return true
|
|
l386:
|
|
position, tokenIndex = position386, tokenIndex386
|
|
return false
|
|
},
|
|
/* 29 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */
|
|
func() bool {
|
|
position396, tokenIndex396 := position, tokenIndex
|
|
{
|
|
position397 := position
|
|
if buffer[position] != rune('.') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('O') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('C') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('.') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l396
|
|
}
|
|
position++
|
|
{
|
|
position398, tokenIndex398 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l399
|
|
}
|
|
position++
|
|
if buffer[position] != rune('b') {
|
|
goto l399
|
|
}
|
|
position++
|
|
goto l398
|
|
l399:
|
|
position, tokenIndex = position398, tokenIndex398
|
|
if buffer[position] != rune('.') {
|
|
goto l396
|
|
}
|
|
position++
|
|
if buffer[position] != rune('L') {
|
|
goto l396
|
|
}
|
|
position++
|
|
{
|
|
position402, tokenIndex402 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l403
|
|
}
|
|
position++
|
|
goto l402
|
|
l403:
|
|
position, tokenIndex = position402, tokenIndex402
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l404
|
|
}
|
|
position++
|
|
goto l402
|
|
l404:
|
|
position, tokenIndex = position402, tokenIndex402
|
|
if buffer[position] != rune('_') {
|
|
goto l405
|
|
}
|
|
position++
|
|
goto l402
|
|
l405:
|
|
position, tokenIndex = position402, tokenIndex402
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l396
|
|
}
|
|
position++
|
|
}
|
|
l402:
|
|
l400:
|
|
{
|
|
position401, tokenIndex401 := position, tokenIndex
|
|
{
|
|
position406, tokenIndex406 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l407
|
|
}
|
|
position++
|
|
goto l406
|
|
l407:
|
|
position, tokenIndex = position406, tokenIndex406
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l408
|
|
}
|
|
position++
|
|
goto l406
|
|
l408:
|
|
position, tokenIndex = position406, tokenIndex406
|
|
if buffer[position] != rune('_') {
|
|
goto l409
|
|
}
|
|
position++
|
|
goto l406
|
|
l409:
|
|
position, tokenIndex = position406, tokenIndex406
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l401
|
|
}
|
|
position++
|
|
}
|
|
l406:
|
|
goto l400
|
|
l401:
|
|
position, tokenIndex = position401, tokenIndex401
|
|
}
|
|
}
|
|
l398:
|
|
if buffer[position] != rune('@') {
|
|
goto l396
|
|
}
|
|
position++
|
|
{
|
|
position410, tokenIndex410 := position, tokenIndex
|
|
if buffer[position] != rune('h') {
|
|
goto l411
|
|
}
|
|
position++
|
|
goto l410
|
|
l411:
|
|
position, tokenIndex = position410, tokenIndex410
|
|
if buffer[position] != rune('H') {
|
|
goto l396
|
|
}
|
|
position++
|
|
}
|
|
l410:
|
|
{
|
|
position412, tokenIndex412 := position, tokenIndex
|
|
if buffer[position] != rune('a') {
|
|
goto l413
|
|
}
|
|
position++
|
|
goto l412
|
|
l413:
|
|
position, tokenIndex = position412, tokenIndex412
|
|
if buffer[position] != rune('A') {
|
|
goto l396
|
|
}
|
|
position++
|
|
}
|
|
l412:
|
|
add(ruleTOCRefHigh, position397)
|
|
}
|
|
return true
|
|
l396:
|
|
position, tokenIndex = position396, tokenIndex396
|
|
return false
|
|
},
|
|
/* 30 TOCRefLow <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('l' / 'L')))> */
|
|
func() bool {
|
|
position414, tokenIndex414 := position, tokenIndex
|
|
{
|
|
position415 := position
|
|
if buffer[position] != rune('.') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('T') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('O') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('C') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('.') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('-') {
|
|
goto l414
|
|
}
|
|
position++
|
|
{
|
|
position416, tokenIndex416 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l417
|
|
}
|
|
position++
|
|
if buffer[position] != rune('b') {
|
|
goto l417
|
|
}
|
|
position++
|
|
goto l416
|
|
l417:
|
|
position, tokenIndex = position416, tokenIndex416
|
|
if buffer[position] != rune('.') {
|
|
goto l414
|
|
}
|
|
position++
|
|
if buffer[position] != rune('L') {
|
|
goto l414
|
|
}
|
|
position++
|
|
{
|
|
position420, tokenIndex420 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l421
|
|
}
|
|
position++
|
|
goto l420
|
|
l421:
|
|
position, tokenIndex = position420, tokenIndex420
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l422
|
|
}
|
|
position++
|
|
goto l420
|
|
l422:
|
|
position, tokenIndex = position420, tokenIndex420
|
|
if buffer[position] != rune('_') {
|
|
goto l423
|
|
}
|
|
position++
|
|
goto l420
|
|
l423:
|
|
position, tokenIndex = position420, tokenIndex420
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l414
|
|
}
|
|
position++
|
|
}
|
|
l420:
|
|
l418:
|
|
{
|
|
position419, tokenIndex419 := position, tokenIndex
|
|
{
|
|
position424, tokenIndex424 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l425
|
|
}
|
|
position++
|
|
goto l424
|
|
l425:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l426
|
|
}
|
|
position++
|
|
goto l424
|
|
l426:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if buffer[position] != rune('_') {
|
|
goto l427
|
|
}
|
|
position++
|
|
goto l424
|
|
l427:
|
|
position, tokenIndex = position424, tokenIndex424
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l419
|
|
}
|
|
position++
|
|
}
|
|
l424:
|
|
goto l418
|
|
l419:
|
|
position, tokenIndex = position419, tokenIndex419
|
|
}
|
|
}
|
|
l416:
|
|
if buffer[position] != rune('@') {
|
|
goto l414
|
|
}
|
|
position++
|
|
{
|
|
position428, tokenIndex428 := position, tokenIndex
|
|
if buffer[position] != rune('l') {
|
|
goto l429
|
|
}
|
|
position++
|
|
goto l428
|
|
l429:
|
|
position, tokenIndex = position428, tokenIndex428
|
|
if buffer[position] != rune('L') {
|
|
goto l414
|
|
}
|
|
position++
|
|
}
|
|
l428:
|
|
add(ruleTOCRefLow, position415)
|
|
}
|
|
return true
|
|
l414:
|
|
position, tokenIndex = position414, tokenIndex414
|
|
return false
|
|
},
|
|
/* 31 IndirectionIndicator <- <'*'> */
|
|
func() bool {
|
|
position430, tokenIndex430 := position, tokenIndex
|
|
{
|
|
position431 := position
|
|
if buffer[position] != rune('*') {
|
|
goto l430
|
|
}
|
|
position++
|
|
add(ruleIndirectionIndicator, position431)
|
|
}
|
|
return true
|
|
l430:
|
|
position, tokenIndex = position430, tokenIndex430
|
|
return false
|
|
},
|
|
/* 32 RegisterOrConstant <- <((('%' ([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))*) / ('$'? ((Offset Offset) / Offset))) !('f' / 'b' / ':' / '(' / '+' / '-'))> */
|
|
func() bool {
|
|
position432, tokenIndex432 := position, tokenIndex
|
|
{
|
|
position433 := position
|
|
{
|
|
position434, tokenIndex434 := position, tokenIndex
|
|
if buffer[position] != rune('%') {
|
|
goto l435
|
|
}
|
|
position++
|
|
{
|
|
position436, tokenIndex436 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l437
|
|
}
|
|
position++
|
|
goto l436
|
|
l437:
|
|
position, tokenIndex = position436, tokenIndex436
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l435
|
|
}
|
|
position++
|
|
}
|
|
l436:
|
|
l438:
|
|
{
|
|
position439, tokenIndex439 := position, tokenIndex
|
|
{
|
|
position440, tokenIndex440 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l441
|
|
}
|
|
position++
|
|
goto l440
|
|
l441:
|
|
position, tokenIndex = position440, tokenIndex440
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l442
|
|
}
|
|
position++
|
|
goto l440
|
|
l442:
|
|
position, tokenIndex = position440, tokenIndex440
|
|
{
|
|
position443, tokenIndex443 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l444
|
|
}
|
|
position++
|
|
goto l443
|
|
l444:
|
|
position, tokenIndex = position443, tokenIndex443
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l439
|
|
}
|
|
position++
|
|
}
|
|
l443:
|
|
}
|
|
l440:
|
|
goto l438
|
|
l439:
|
|
position, tokenIndex = position439, tokenIndex439
|
|
}
|
|
goto l434
|
|
l435:
|
|
position, tokenIndex = position434, tokenIndex434
|
|
{
|
|
position445, tokenIndex445 := position, tokenIndex
|
|
if buffer[position] != rune('$') {
|
|
goto l445
|
|
}
|
|
position++
|
|
goto l446
|
|
l445:
|
|
position, tokenIndex = position445, tokenIndex445
|
|
}
|
|
l446:
|
|
{
|
|
position447, tokenIndex447 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l448
|
|
}
|
|
if !_rules[ruleOffset]() {
|
|
goto l448
|
|
}
|
|
goto l447
|
|
l448:
|
|
position, tokenIndex = position447, tokenIndex447
|
|
if !_rules[ruleOffset]() {
|
|
goto l432
|
|
}
|
|
}
|
|
l447:
|
|
}
|
|
l434:
|
|
{
|
|
position449, tokenIndex449 := position, tokenIndex
|
|
{
|
|
position450, tokenIndex450 := position, tokenIndex
|
|
if buffer[position] != rune('f') {
|
|
goto l451
|
|
}
|
|
position++
|
|
goto l450
|
|
l451:
|
|
position, tokenIndex = position450, tokenIndex450
|
|
if buffer[position] != rune('b') {
|
|
goto l452
|
|
}
|
|
position++
|
|
goto l450
|
|
l452:
|
|
position, tokenIndex = position450, tokenIndex450
|
|
if buffer[position] != rune(':') {
|
|
goto l453
|
|
}
|
|
position++
|
|
goto l450
|
|
l453:
|
|
position, tokenIndex = position450, tokenIndex450
|
|
if buffer[position] != rune('(') {
|
|
goto l454
|
|
}
|
|
position++
|
|
goto l450
|
|
l454:
|
|
position, tokenIndex = position450, tokenIndex450
|
|
if buffer[position] != rune('+') {
|
|
goto l455
|
|
}
|
|
position++
|
|
goto l450
|
|
l455:
|
|
position, tokenIndex = position450, tokenIndex450
|
|
if buffer[position] != rune('-') {
|
|
goto l449
|
|
}
|
|
position++
|
|
}
|
|
l450:
|
|
goto l432
|
|
l449:
|
|
position, tokenIndex = position449, tokenIndex449
|
|
}
|
|
add(ruleRegisterOrConstant, position433)
|
|
}
|
|
return true
|
|
l432:
|
|
position, tokenIndex = position432, tokenIndex432
|
|
return false
|
|
},
|
|
/* 33 MemoryRef <- <((SymbolRef BaseIndexScale) / SymbolRef / (Offset* BaseIndexScale) / (SegmentRegister Offset BaseIndexScale) / (SegmentRegister BaseIndexScale) / (SegmentRegister Offset) / BaseIndexScale)> */
|
|
func() bool {
|
|
position456, tokenIndex456 := position, tokenIndex
|
|
{
|
|
position457 := position
|
|
{
|
|
position458, tokenIndex458 := position, tokenIndex
|
|
if !_rules[ruleSymbolRef]() {
|
|
goto l459
|
|
}
|
|
if !_rules[ruleBaseIndexScale]() {
|
|
goto l459
|
|
}
|
|
goto l458
|
|
l459:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
if !_rules[ruleSymbolRef]() {
|
|
goto l460
|
|
}
|
|
goto l458
|
|
l460:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
l462:
|
|
{
|
|
position463, tokenIndex463 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l463
|
|
}
|
|
goto l462
|
|
l463:
|
|
position, tokenIndex = position463, tokenIndex463
|
|
}
|
|
if !_rules[ruleBaseIndexScale]() {
|
|
goto l461
|
|
}
|
|
goto l458
|
|
l461:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
if !_rules[ruleSegmentRegister]() {
|
|
goto l464
|
|
}
|
|
if !_rules[ruleOffset]() {
|
|
goto l464
|
|
}
|
|
if !_rules[ruleBaseIndexScale]() {
|
|
goto l464
|
|
}
|
|
goto l458
|
|
l464:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
if !_rules[ruleSegmentRegister]() {
|
|
goto l465
|
|
}
|
|
if !_rules[ruleBaseIndexScale]() {
|
|
goto l465
|
|
}
|
|
goto l458
|
|
l465:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
if !_rules[ruleSegmentRegister]() {
|
|
goto l466
|
|
}
|
|
if !_rules[ruleOffset]() {
|
|
goto l466
|
|
}
|
|
goto l458
|
|
l466:
|
|
position, tokenIndex = position458, tokenIndex458
|
|
if !_rules[ruleBaseIndexScale]() {
|
|
goto l456
|
|
}
|
|
}
|
|
l458:
|
|
add(ruleMemoryRef, position457)
|
|
}
|
|
return true
|
|
l456:
|
|
position, tokenIndex = position456, tokenIndex456
|
|
return false
|
|
},
|
|
/* 34 SymbolRef <- <((Offset* '+')? (LocalSymbol / SymbolName) Offset* ('@' Section Offset*)?)> */
|
|
func() bool {
|
|
position467, tokenIndex467 := position, tokenIndex
|
|
{
|
|
position468 := position
|
|
{
|
|
position469, tokenIndex469 := position, tokenIndex
|
|
l471:
|
|
{
|
|
position472, tokenIndex472 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l472
|
|
}
|
|
goto l471
|
|
l472:
|
|
position, tokenIndex = position472, tokenIndex472
|
|
}
|
|
if buffer[position] != rune('+') {
|
|
goto l469
|
|
}
|
|
position++
|
|
goto l470
|
|
l469:
|
|
position, tokenIndex = position469, tokenIndex469
|
|
}
|
|
l470:
|
|
{
|
|
position473, tokenIndex473 := position, tokenIndex
|
|
if !_rules[ruleLocalSymbol]() {
|
|
goto l474
|
|
}
|
|
goto l473
|
|
l474:
|
|
position, tokenIndex = position473, tokenIndex473
|
|
if !_rules[ruleSymbolName]() {
|
|
goto l467
|
|
}
|
|
}
|
|
l473:
|
|
l475:
|
|
{
|
|
position476, tokenIndex476 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l476
|
|
}
|
|
goto l475
|
|
l476:
|
|
position, tokenIndex = position476, tokenIndex476
|
|
}
|
|
{
|
|
position477, tokenIndex477 := position, tokenIndex
|
|
if buffer[position] != rune('@') {
|
|
goto l477
|
|
}
|
|
position++
|
|
if !_rules[ruleSection]() {
|
|
goto l477
|
|
}
|
|
l479:
|
|
{
|
|
position480, tokenIndex480 := position, tokenIndex
|
|
if !_rules[ruleOffset]() {
|
|
goto l480
|
|
}
|
|
goto l479
|
|
l480:
|
|
position, tokenIndex = position480, tokenIndex480
|
|
}
|
|
goto l478
|
|
l477:
|
|
position, tokenIndex = position477, tokenIndex477
|
|
}
|
|
l478:
|
|
add(ruleSymbolRef, position468)
|
|
}
|
|
return true
|
|
l467:
|
|
position, tokenIndex = position467, tokenIndex467
|
|
return false
|
|
},
|
|
/* 35 BaseIndexScale <- <('(' RegisterOrConstant? WS? (',' WS? RegisterOrConstant WS? (',' [0-9]+)?)? ')')> */
|
|
func() bool {
|
|
position481, tokenIndex481 := position, tokenIndex
|
|
{
|
|
position482 := position
|
|
if buffer[position] != rune('(') {
|
|
goto l481
|
|
}
|
|
position++
|
|
{
|
|
position483, tokenIndex483 := position, tokenIndex
|
|
if !_rules[ruleRegisterOrConstant]() {
|
|
goto l483
|
|
}
|
|
goto l484
|
|
l483:
|
|
position, tokenIndex = position483, tokenIndex483
|
|
}
|
|
l484:
|
|
{
|
|
position485, tokenIndex485 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l485
|
|
}
|
|
goto l486
|
|
l485:
|
|
position, tokenIndex = position485, tokenIndex485
|
|
}
|
|
l486:
|
|
{
|
|
position487, tokenIndex487 := position, tokenIndex
|
|
if buffer[position] != rune(',') {
|
|
goto l487
|
|
}
|
|
position++
|
|
{
|
|
position489, tokenIndex489 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l489
|
|
}
|
|
goto l490
|
|
l489:
|
|
position, tokenIndex = position489, tokenIndex489
|
|
}
|
|
l490:
|
|
if !_rules[ruleRegisterOrConstant]() {
|
|
goto l487
|
|
}
|
|
{
|
|
position491, tokenIndex491 := position, tokenIndex
|
|
if !_rules[ruleWS]() {
|
|
goto l491
|
|
}
|
|
goto l492
|
|
l491:
|
|
position, tokenIndex = position491, tokenIndex491
|
|
}
|
|
l492:
|
|
{
|
|
position493, tokenIndex493 := position, tokenIndex
|
|
if buffer[position] != rune(',') {
|
|
goto l493
|
|
}
|
|
position++
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l493
|
|
}
|
|
position++
|
|
l495:
|
|
{
|
|
position496, tokenIndex496 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l496
|
|
}
|
|
position++
|
|
goto l495
|
|
l496:
|
|
position, tokenIndex = position496, tokenIndex496
|
|
}
|
|
goto l494
|
|
l493:
|
|
position, tokenIndex = position493, tokenIndex493
|
|
}
|
|
l494:
|
|
goto l488
|
|
l487:
|
|
position, tokenIndex = position487, tokenIndex487
|
|
}
|
|
l488:
|
|
if buffer[position] != rune(')') {
|
|
goto l481
|
|
}
|
|
position++
|
|
add(ruleBaseIndexScale, position482)
|
|
}
|
|
return true
|
|
l481:
|
|
position, tokenIndex = position481, tokenIndex481
|
|
return false
|
|
},
|
|
/* 36 Operator <- <('+' / '-')> */
|
|
func() bool {
|
|
position497, tokenIndex497 := position, tokenIndex
|
|
{
|
|
position498 := position
|
|
{
|
|
position499, tokenIndex499 := position, tokenIndex
|
|
if buffer[position] != rune('+') {
|
|
goto l500
|
|
}
|
|
position++
|
|
goto l499
|
|
l500:
|
|
position, tokenIndex = position499, tokenIndex499
|
|
if buffer[position] != rune('-') {
|
|
goto l497
|
|
}
|
|
position++
|
|
}
|
|
l499:
|
|
add(ruleOperator, position498)
|
|
}
|
|
return true
|
|
l497:
|
|
position, tokenIndex = position497, tokenIndex497
|
|
return false
|
|
},
|
|
/* 37 Offset <- <('+'? '-'? (('0' ('b' / 'B') ('0' / '1')+) / ('0' ('x' / 'X') ([0-9] / [0-9] / ([a-f] / [A-F]))+) / [0-9]+))> */
|
|
func() bool {
|
|
position501, tokenIndex501 := position, tokenIndex
|
|
{
|
|
position502 := position
|
|
{
|
|
position503, tokenIndex503 := position, tokenIndex
|
|
if buffer[position] != rune('+') {
|
|
goto l503
|
|
}
|
|
position++
|
|
goto l504
|
|
l503:
|
|
position, tokenIndex = position503, tokenIndex503
|
|
}
|
|
l504:
|
|
{
|
|
position505, tokenIndex505 := position, tokenIndex
|
|
if buffer[position] != rune('-') {
|
|
goto l505
|
|
}
|
|
position++
|
|
goto l506
|
|
l505:
|
|
position, tokenIndex = position505, tokenIndex505
|
|
}
|
|
l506:
|
|
{
|
|
position507, tokenIndex507 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l508
|
|
}
|
|
position++
|
|
{
|
|
position509, tokenIndex509 := position, tokenIndex
|
|
if buffer[position] != rune('b') {
|
|
goto l510
|
|
}
|
|
position++
|
|
goto l509
|
|
l510:
|
|
position, tokenIndex = position509, tokenIndex509
|
|
if buffer[position] != rune('B') {
|
|
goto l508
|
|
}
|
|
position++
|
|
}
|
|
l509:
|
|
{
|
|
position513, tokenIndex513 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l514
|
|
}
|
|
position++
|
|
goto l513
|
|
l514:
|
|
position, tokenIndex = position513, tokenIndex513
|
|
if buffer[position] != rune('1') {
|
|
goto l508
|
|
}
|
|
position++
|
|
}
|
|
l513:
|
|
l511:
|
|
{
|
|
position512, tokenIndex512 := position, tokenIndex
|
|
{
|
|
position515, tokenIndex515 := position, tokenIndex
|
|
if buffer[position] != rune('0') {
|
|
goto l516
|
|
}
|
|
position++
|
|
goto l515
|
|
l516:
|
|
position, tokenIndex = position515, tokenIndex515
|
|
if buffer[position] != rune('1') {
|
|
goto l512
|
|
}
|
|
position++
|
|
}
|
|
l515:
|
|
goto l511
|
|
l512:
|
|
position, tokenIndex = position512, tokenIndex512
|
|
}
|
|
goto l507
|
|
l508:
|
|
position, tokenIndex = position507, tokenIndex507
|
|
if buffer[position] != rune('0') {
|
|
goto l517
|
|
}
|
|
position++
|
|
{
|
|
position518, tokenIndex518 := position, tokenIndex
|
|
if buffer[position] != rune('x') {
|
|
goto l519
|
|
}
|
|
position++
|
|
goto l518
|
|
l519:
|
|
position, tokenIndex = position518, tokenIndex518
|
|
if buffer[position] != rune('X') {
|
|
goto l517
|
|
}
|
|
position++
|
|
}
|
|
l518:
|
|
{
|
|
position522, tokenIndex522 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l523
|
|
}
|
|
position++
|
|
goto l522
|
|
l523:
|
|
position, tokenIndex = position522, tokenIndex522
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l524
|
|
}
|
|
position++
|
|
goto l522
|
|
l524:
|
|
position, tokenIndex = position522, tokenIndex522
|
|
{
|
|
position525, tokenIndex525 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('f') {
|
|
goto l526
|
|
}
|
|
position++
|
|
goto l525
|
|
l526:
|
|
position, tokenIndex = position525, tokenIndex525
|
|
if c := buffer[position]; c < rune('A') || c > rune('F') {
|
|
goto l517
|
|
}
|
|
position++
|
|
}
|
|
l525:
|
|
}
|
|
l522:
|
|
l520:
|
|
{
|
|
position521, tokenIndex521 := position, tokenIndex
|
|
{
|
|
position527, tokenIndex527 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l528
|
|
}
|
|
position++
|
|
goto l527
|
|
l528:
|
|
position, tokenIndex = position527, tokenIndex527
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l529
|
|
}
|
|
position++
|
|
goto l527
|
|
l529:
|
|
position, tokenIndex = position527, tokenIndex527
|
|
{
|
|
position530, tokenIndex530 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('f') {
|
|
goto l531
|
|
}
|
|
position++
|
|
goto l530
|
|
l531:
|
|
position, tokenIndex = position530, tokenIndex530
|
|
if c := buffer[position]; c < rune('A') || c > rune('F') {
|
|
goto l521
|
|
}
|
|
position++
|
|
}
|
|
l530:
|
|
}
|
|
l527:
|
|
goto l520
|
|
l521:
|
|
position, tokenIndex = position521, tokenIndex521
|
|
}
|
|
goto l507
|
|
l517:
|
|
position, tokenIndex = position507, tokenIndex507
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l501
|
|
}
|
|
position++
|
|
l532:
|
|
{
|
|
position533, tokenIndex533 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('0') || c > rune('9') {
|
|
goto l533
|
|
}
|
|
position++
|
|
goto l532
|
|
l533:
|
|
position, tokenIndex = position533, tokenIndex533
|
|
}
|
|
}
|
|
l507:
|
|
add(ruleOffset, position502)
|
|
}
|
|
return true
|
|
l501:
|
|
position, tokenIndex = position501, tokenIndex501
|
|
return false
|
|
},
|
|
/* 38 Section <- <([a-z] / [A-Z] / '@')+> */
|
|
func() bool {
|
|
position534, tokenIndex534 := position, tokenIndex
|
|
{
|
|
position535 := position
|
|
{
|
|
position538, tokenIndex538 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l539
|
|
}
|
|
position++
|
|
goto l538
|
|
l539:
|
|
position, tokenIndex = position538, tokenIndex538
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l540
|
|
}
|
|
position++
|
|
goto l538
|
|
l540:
|
|
position, tokenIndex = position538, tokenIndex538
|
|
if buffer[position] != rune('@') {
|
|
goto l534
|
|
}
|
|
position++
|
|
}
|
|
l538:
|
|
l536:
|
|
{
|
|
position537, tokenIndex537 := position, tokenIndex
|
|
{
|
|
position541, tokenIndex541 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('a') || c > rune('z') {
|
|
goto l542
|
|
}
|
|
position++
|
|
goto l541
|
|
l542:
|
|
position, tokenIndex = position541, tokenIndex541
|
|
if c := buffer[position]; c < rune('A') || c > rune('Z') {
|
|
goto l543
|
|
}
|
|
position++
|
|
goto l541
|
|
l543:
|
|
position, tokenIndex = position541, tokenIndex541
|
|
if buffer[position] != rune('@') {
|
|
goto l537
|
|
}
|
|
position++
|
|
}
|
|
l541:
|
|
goto l536
|
|
l537:
|
|
position, tokenIndex = position537, tokenIndex537
|
|
}
|
|
add(ruleSection, position535)
|
|
}
|
|
return true
|
|
l534:
|
|
position, tokenIndex = position534, tokenIndex534
|
|
return false
|
|
},
|
|
/* 39 SegmentRegister <- <('%' ([c-g] / 's') ('s' ':'))> */
|
|
func() bool {
|
|
position544, tokenIndex544 := position, tokenIndex
|
|
{
|
|
position545 := position
|
|
if buffer[position] != rune('%') {
|
|
goto l544
|
|
}
|
|
position++
|
|
{
|
|
position546, tokenIndex546 := position, tokenIndex
|
|
if c := buffer[position]; c < rune('c') || c > rune('g') {
|
|
goto l547
|
|
}
|
|
position++
|
|
goto l546
|
|
l547:
|
|
position, tokenIndex = position546, tokenIndex546
|
|
if buffer[position] != rune('s') {
|
|
goto l544
|
|
}
|
|
position++
|
|
}
|
|
l546:
|
|
if buffer[position] != rune('s') {
|
|
goto l544
|
|
}
|
|
position++
|
|
if buffer[position] != rune(':') {
|
|
goto l544
|
|
}
|
|
position++
|
|
add(ruleSegmentRegister, position545)
|
|
}
|
|
return true
|
|
l544:
|
|
position, tokenIndex = position544, tokenIndex544
|
|
return false
|
|
},
|
|
}
|
|
p.rules = _rules
|
|
}
|