diff options
Diffstat (limited to 'src/util/fipstools/delocate/delocate.peg.go')
| -rw-r--r-- | src/util/fipstools/delocate/delocate.peg.go | 4017 |
1 files changed, 4017 insertions, 0 deletions
diff --git a/src/util/fipstools/delocate/delocate.peg.go b/src/util/fipstools/delocate/delocate.peg.go new file mode 100644 index 00000000..f0ad78f6 --- /dev/null +++ b/src/util/fipstools/delocate/delocate.peg.go @@ -0,0 +1,4017 @@ +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 + 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", + "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 [40]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')))> */ + 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 l133 + } + position++ + { + position214, tokenIndex214 := position, tokenIndex + if buffer[position] != rune('t') { + goto l215 + } + position++ + goto l214 + l215: + position, tokenIndex = position214, tokenIndex214 + if buffer[position] != rune('T') { + goto l133 + } + position++ + } + l214: + { + position216, tokenIndex216 := position, tokenIndex + if buffer[position] != rune('y') { + goto l217 + } + position++ + goto l216 + l217: + position, tokenIndex = position216, tokenIndex216 + if buffer[position] != rune('Y') { + goto l133 + } + position++ + } + l216: + { + position218, tokenIndex218 := position, tokenIndex + if buffer[position] != rune('p') { + goto l219 + } + position++ + goto l218 + l219: + position, tokenIndex = position218, tokenIndex218 + if buffer[position] != rune('P') { + goto l133 + } + position++ + } + l218: + { + position220, tokenIndex220 := position, tokenIndex + if buffer[position] != rune('e') { + goto l221 + } + position++ + goto l220 + l221: + position, tokenIndex = position220, tokenIndex220 + if buffer[position] != rune('E') { + goto l133 + } + position++ + } + l220: + } + l135: + add(ruleLabelContainingDirectiveName, position134) + } + return true + l133: + position, tokenIndex = position133, tokenIndex133 + return false + }, + /* 12 SymbolArgs <- <(SymbolArg (WS? ',' WS? SymbolArg)*)> */ + func() bool { + position222, tokenIndex222 := position, tokenIndex + { + position223 := position + if !_rules[ruleSymbolArg]() { + goto l222 + } + l224: + { + position225, tokenIndex225 := position, tokenIndex + { + position226, tokenIndex226 := position, tokenIndex + if !_rules[ruleWS]() { + goto l226 + } + goto l227 + l226: + position, tokenIndex = position226, tokenIndex226 + } + l227: + if buffer[position] != rune(',') { + goto l225 + } + position++ + { + position228, tokenIndex228 := position, tokenIndex + if !_rules[ruleWS]() { + goto l228 + } + goto l229 + l228: + position, tokenIndex = position228, tokenIndex228 + } + l229: + if !_rules[ruleSymbolArg]() { + goto l225 + } + goto l224 + l225: + position, tokenIndex = position225, tokenIndex225 + } + add(ruleSymbolArgs, position223) + } + return true + l222: + position, tokenIndex = position222, tokenIndex222 + return false + }, + /* 13 SymbolArg <- <(Offset / SymbolType / ((Offset / LocalSymbol / SymbolName / Dot) WS? Operator WS? (Offset / LocalSymbol / SymbolName)) / (LocalSymbol TCMarker?) / (SymbolName Offset) / (SymbolName TCMarker?))> */ + func() bool { + position230, tokenIndex230 := position, tokenIndex + { + position231 := position + { + position232, tokenIndex232 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l233 + } + goto l232 + l233: + position, tokenIndex = position232, tokenIndex232 + if !_rules[ruleSymbolType]() { + goto l234 + } + goto l232 + l234: + position, tokenIndex = position232, tokenIndex232 + { + position236, tokenIndex236 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l237 + } + goto l236 + l237: + position, tokenIndex = position236, tokenIndex236 + if !_rules[ruleLocalSymbol]() { + goto l238 + } + goto l236 + l238: + position, tokenIndex = position236, tokenIndex236 + if !_rules[ruleSymbolName]() { + goto l239 + } + goto l236 + l239: + position, tokenIndex = position236, tokenIndex236 + if !_rules[ruleDot]() { + goto l235 + } + } + l236: + { + position240, tokenIndex240 := position, tokenIndex + if !_rules[ruleWS]() { + goto l240 + } + goto l241 + l240: + position, tokenIndex = position240, tokenIndex240 + } + l241: + if !_rules[ruleOperator]() { + goto l235 + } + { + position242, tokenIndex242 := position, tokenIndex + if !_rules[ruleWS]() { + goto l242 + } + goto l243 + l242: + position, tokenIndex = position242, tokenIndex242 + } + l243: + { + position244, tokenIndex244 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l245 + } + goto l244 + l245: + position, tokenIndex = position244, tokenIndex244 + if !_rules[ruleLocalSymbol]() { + goto l246 + } + goto l244 + l246: + position, tokenIndex = position244, tokenIndex244 + if !_rules[ruleSymbolName]() { + goto l235 + } + } + l244: + goto l232 + l235: + position, tokenIndex = position232, tokenIndex232 + if !_rules[ruleLocalSymbol]() { + goto l247 + } + { + position248, tokenIndex248 := position, tokenIndex + if !_rules[ruleTCMarker]() { + goto l248 + } + goto l249 + l248: + position, tokenIndex = position248, tokenIndex248 + } + l249: + goto l232 + l247: + position, tokenIndex = position232, tokenIndex232 + if !_rules[ruleSymbolName]() { + goto l250 + } + if !_rules[ruleOffset]() { + goto l250 + } + goto l232 + l250: + position, tokenIndex = position232, tokenIndex232 + if !_rules[ruleSymbolName]() { + goto l230 + } + { + position251, tokenIndex251 := position, tokenIndex + if !_rules[ruleTCMarker]() { + goto l251 + } + goto l252 + l251: + position, tokenIndex = position251, tokenIndex251 + } + l252: + } + l232: + add(ruleSymbolArg, position231) + } + return true + l230: + position, tokenIndex = position230, tokenIndex230 + return false + }, + /* 14 SymbolType <- <(('@' 'f' 'u' 'n' 'c' 't' 'i' 'o' 'n') / ('@' 'o' 'b' 'j' 'e' 'c' 't'))> */ + func() bool { + position253, tokenIndex253 := position, tokenIndex + { + position254 := position + { + position255, tokenIndex255 := position, tokenIndex + if buffer[position] != rune('@') { + goto l256 + } + position++ + if buffer[position] != rune('f') { + goto l256 + } + position++ + if buffer[position] != rune('u') { + goto l256 + } + position++ + if buffer[position] != rune('n') { + goto l256 + } + position++ + if buffer[position] != rune('c') { + goto l256 + } + position++ + if buffer[position] != rune('t') { + goto l256 + } + position++ + if buffer[position] != rune('i') { + goto l256 + } + position++ + if buffer[position] != rune('o') { + goto l256 + } + position++ + if buffer[position] != rune('n') { + goto l256 + } + position++ + goto l255 + l256: + position, tokenIndex = position255, tokenIndex255 + if buffer[position] != rune('@') { + goto l253 + } + position++ + if buffer[position] != rune('o') { + goto l253 + } + position++ + if buffer[position] != rune('b') { + goto l253 + } + position++ + if buffer[position] != rune('j') { + goto l253 + } + position++ + if buffer[position] != rune('e') { + goto l253 + } + position++ + if buffer[position] != rune('c') { + goto l253 + } + position++ + if buffer[position] != rune('t') { + goto l253 + } + position++ + } + l255: + add(ruleSymbolType, position254) + } + return true + l253: + position, tokenIndex = position253, tokenIndex253 + return false + }, + /* 15 Dot <- <'.'> */ + func() bool { + position257, tokenIndex257 := position, tokenIndex + { + position258 := position + if buffer[position] != rune('.') { + goto l257 + } + position++ + add(ruleDot, position258) + } + return true + l257: + position, tokenIndex = position257, tokenIndex257 + return false + }, + /* 16 TCMarker <- <('[' 'T' 'C' ']')> */ + func() bool { + position259, tokenIndex259 := position, tokenIndex + { + position260 := position + if buffer[position] != rune('[') { + goto l259 + } + position++ + if buffer[position] != rune('T') { + goto l259 + } + position++ + if buffer[position] != rune('C') { + goto l259 + } + position++ + if buffer[position] != rune(']') { + goto l259 + } + position++ + add(ruleTCMarker, position260) + } + return true + l259: + position, tokenIndex = position259, tokenIndex259 + return false + }, + /* 17 EscapedChar <- <('\\' .)> */ + func() bool { + position261, tokenIndex261 := position, tokenIndex + { + position262 := position + if buffer[position] != rune('\\') { + goto l261 + } + position++ + if !matchDot() { + goto l261 + } + add(ruleEscapedChar, position262) + } + return true + l261: + position, tokenIndex = position261, tokenIndex261 + return false + }, + /* 18 WS <- <(' ' / '\t')+> */ + func() bool { + position263, tokenIndex263 := position, tokenIndex + { + position264 := position + { + position267, tokenIndex267 := position, tokenIndex + if buffer[position] != rune(' ') { + goto l268 + } + position++ + goto l267 + l268: + position, tokenIndex = position267, tokenIndex267 + if buffer[position] != rune('\t') { + goto l263 + } + position++ + } + l267: + l265: + { + position266, tokenIndex266 := position, tokenIndex + { + position269, tokenIndex269 := position, tokenIndex + if buffer[position] != rune(' ') { + goto l270 + } + position++ + goto l269 + l270: + position, tokenIndex = position269, tokenIndex269 + if buffer[position] != rune('\t') { + goto l266 + } + position++ + } + l269: + goto l265 + l266: + position, tokenIndex = position266, tokenIndex266 + } + add(ruleWS, position264) + } + return true + l263: + position, tokenIndex = position263, tokenIndex263 + return false + }, + /* 19 Comment <- <('#' (!'\n' .)*)> */ + func() bool { + position271, tokenIndex271 := position, tokenIndex + { + position272 := position + if buffer[position] != rune('#') { + goto l271 + } + position++ + l273: + { + position274, tokenIndex274 := position, tokenIndex + { + position275, tokenIndex275 := position, tokenIndex + if buffer[position] != rune('\n') { + goto l275 + } + position++ + goto l274 + l275: + position, tokenIndex = position275, tokenIndex275 + } + if !matchDot() { + goto l274 + } + goto l273 + l274: + position, tokenIndex = position274, tokenIndex274 + } + add(ruleComment, position272) + } + return true + l271: + position, tokenIndex = position271, tokenIndex271 + return false + }, + /* 20 Label <- <((LocalSymbol / LocalLabel / SymbolName) ':')> */ + func() bool { + position276, tokenIndex276 := position, tokenIndex + { + position277 := position + { + position278, tokenIndex278 := position, tokenIndex + if !_rules[ruleLocalSymbol]() { + goto l279 + } + goto l278 + l279: + position, tokenIndex = position278, tokenIndex278 + if !_rules[ruleLocalLabel]() { + goto l280 + } + goto l278 + l280: + position, tokenIndex = position278, tokenIndex278 + if !_rules[ruleSymbolName]() { + goto l276 + } + } + l278: + if buffer[position] != rune(':') { + goto l276 + } + position++ + add(ruleLabel, position277) + } + return true + l276: + position, tokenIndex = position276, tokenIndex276 + return false + }, + /* 21 SymbolName <- <(([a-z] / [A-Z] / '.' / '_') ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')*)> */ + func() bool { + position281, tokenIndex281 := position, tokenIndex + { + position282 := position + { + position283, tokenIndex283 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l284 + } + position++ + goto l283 + l284: + position, tokenIndex = position283, tokenIndex283 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l285 + } + position++ + goto l283 + l285: + position, tokenIndex = position283, tokenIndex283 + if buffer[position] != rune('.') { + goto l286 + } + position++ + goto l283 + l286: + position, tokenIndex = position283, tokenIndex283 + if buffer[position] != rune('_') { + goto l281 + } + position++ + } + l283: + l287: + { + position288, tokenIndex288 := position, tokenIndex + { + position289, tokenIndex289 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l290 + } + position++ + goto l289 + l290: + position, tokenIndex = position289, tokenIndex289 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l291 + } + position++ + goto l289 + l291: + position, tokenIndex = position289, tokenIndex289 + if buffer[position] != rune('.') { + goto l292 + } + position++ + goto l289 + l292: + position, tokenIndex = position289, tokenIndex289 + { + position294, tokenIndex294 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l295 + } + position++ + goto l294 + l295: + position, tokenIndex = position294, tokenIndex294 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l293 + } + position++ + } + l294: + goto l289 + l293: + position, tokenIndex = position289, tokenIndex289 + if buffer[position] != rune('$') { + goto l296 + } + position++ + goto l289 + l296: + position, tokenIndex = position289, tokenIndex289 + if buffer[position] != rune('_') { + goto l288 + } + position++ + } + l289: + goto l287 + l288: + position, tokenIndex = position288, tokenIndex288 + } + add(ruleSymbolName, position282) + } + return true + l281: + position, tokenIndex = position281, tokenIndex281 + return false + }, + /* 22 LocalSymbol <- <('.' 'L' ([a-z] / [A-Z] / '.' / ([0-9] / [0-9]) / '$' / '_')+)> */ + func() bool { + position297, tokenIndex297 := position, tokenIndex + { + position298 := position + if buffer[position] != rune('.') { + goto l297 + } + position++ + if buffer[position] != rune('L') { + goto l297 + } + 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 + { + position306, tokenIndex306 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l307 + } + position++ + goto l306 + l307: + position, tokenIndex = position306, tokenIndex306 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l305 + } + position++ + } + l306: + goto l301 + l305: + position, tokenIndex = position301, tokenIndex301 + if buffer[position] != rune('$') { + goto l308 + } + position++ + goto l301 + l308: + position, tokenIndex = position301, tokenIndex301 + if buffer[position] != rune('_') { + goto l297 + } + position++ + } + l301: + l299: + { + position300, tokenIndex300 := position, tokenIndex + { + position309, tokenIndex309 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l310 + } + position++ + goto l309 + l310: + position, tokenIndex = position309, tokenIndex309 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l311 + } + position++ + goto l309 + l311: + position, tokenIndex = position309, tokenIndex309 + if buffer[position] != rune('.') { + goto l312 + } + position++ + goto l309 + l312: + position, tokenIndex = position309, tokenIndex309 + { + position314, tokenIndex314 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l315 + } + position++ + goto l314 + l315: + position, tokenIndex = position314, tokenIndex314 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l313 + } + position++ + } + l314: + goto l309 + l313: + position, tokenIndex = position309, tokenIndex309 + if buffer[position] != rune('$') { + goto l316 + } + position++ + goto l309 + l316: + position, tokenIndex = position309, tokenIndex309 + if buffer[position] != rune('_') { + goto l300 + } + position++ + } + l309: + goto l299 + l300: + position, tokenIndex = position300, tokenIndex300 + } + add(ruleLocalSymbol, position298) + } + return true + l297: + position, tokenIndex = position297, tokenIndex297 + return false + }, + /* 23 LocalLabel <- <([0-9] ([0-9] / '$')*)> */ + func() bool { + position317, tokenIndex317 := position, tokenIndex + { + position318 := position + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l317 + } + position++ + l319: + { + position320, tokenIndex320 := position, tokenIndex + { + position321, tokenIndex321 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l322 + } + position++ + goto l321 + l322: + position, tokenIndex = position321, tokenIndex321 + if buffer[position] != rune('$') { + goto l320 + } + position++ + } + l321: + goto l319 + l320: + position, tokenIndex = position320, tokenIndex320 + } + add(ruleLocalLabel, position318) + } + return true + l317: + position, tokenIndex = position317, tokenIndex317 + return false + }, + /* 24 LocalLabelRef <- <([0-9] ([0-9] / '$')* ('b' / 'f'))> */ + func() bool { + position323, tokenIndex323 := position, tokenIndex + { + position324 := position + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l323 + } + position++ + l325: + { + position326, tokenIndex326 := position, tokenIndex + { + position327, tokenIndex327 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l328 + } + position++ + goto l327 + l328: + position, tokenIndex = position327, tokenIndex327 + if buffer[position] != rune('$') { + goto l326 + } + position++ + } + l327: + goto l325 + l326: + position, tokenIndex = position326, tokenIndex326 + } + { + position329, tokenIndex329 := position, tokenIndex + if buffer[position] != rune('b') { + goto l330 + } + position++ + goto l329 + l330: + position, tokenIndex = position329, tokenIndex329 + if buffer[position] != rune('f') { + goto l323 + } + position++ + } + l329: + add(ruleLocalLabelRef, position324) + } + return true + l323: + position, tokenIndex = position323, tokenIndex323 + return false + }, + /* 25 Instruction <- <(InstructionName (WS InstructionArg (WS? ',' WS? InstructionArg)*)? (WS? '{' InstructionArg '}')*)> */ + func() bool { + position331, tokenIndex331 := position, tokenIndex + { + position332 := position + if !_rules[ruleInstructionName]() { + goto l331 + } + { + position333, tokenIndex333 := position, tokenIndex + if !_rules[ruleWS]() { + goto l333 + } + if !_rules[ruleInstructionArg]() { + goto l333 + } + l335: + { + position336, tokenIndex336 := position, tokenIndex + { + position337, tokenIndex337 := position, tokenIndex + if !_rules[ruleWS]() { + goto l337 + } + goto l338 + l337: + position, tokenIndex = position337, tokenIndex337 + } + l338: + if buffer[position] != rune(',') { + goto l336 + } + position++ + { + position339, tokenIndex339 := position, tokenIndex + if !_rules[ruleWS]() { + goto l339 + } + goto l340 + l339: + position, tokenIndex = position339, tokenIndex339 + } + l340: + if !_rules[ruleInstructionArg]() { + goto l336 + } + goto l335 + l336: + position, tokenIndex = position336, tokenIndex336 + } + goto l334 + l333: + position, tokenIndex = position333, tokenIndex333 + } + l334: + l341: + { + position342, tokenIndex342 := position, tokenIndex + { + position343, tokenIndex343 := position, tokenIndex + if !_rules[ruleWS]() { + goto l343 + } + goto l344 + l343: + position, tokenIndex = position343, tokenIndex343 + } + l344: + if buffer[position] != rune('{') { + goto l342 + } + position++ + if !_rules[ruleInstructionArg]() { + goto l342 + } + if buffer[position] != rune('}') { + goto l342 + } + position++ + goto l341 + l342: + position, tokenIndex = position342, tokenIndex342 + } + add(ruleInstruction, position332) + } + return true + l331: + position, tokenIndex = position331, tokenIndex331 + return false + }, + /* 26 InstructionName <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))* ('.' / '+' / '-')?)> */ + func() bool { + position345, tokenIndex345 := position, tokenIndex + { + position346 := position + { + position347, tokenIndex347 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l348 + } + position++ + goto l347 + l348: + position, tokenIndex = position347, tokenIndex347 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l345 + } + position++ + } + l347: + l349: + { + position350, tokenIndex350 := position, tokenIndex + { + position351, tokenIndex351 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l352 + } + position++ + goto l351 + l352: + position, tokenIndex = position351, tokenIndex351 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l353 + } + position++ + goto l351 + l353: + position, tokenIndex = position351, tokenIndex351 + { + position354, tokenIndex354 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l355 + } + position++ + goto l354 + l355: + position, tokenIndex = position354, tokenIndex354 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l350 + } + position++ + } + l354: + } + l351: + goto l349 + l350: + position, tokenIndex = position350, tokenIndex350 + } + { + position356, tokenIndex356 := position, tokenIndex + { + position358, tokenIndex358 := position, tokenIndex + if buffer[position] != rune('.') { + goto l359 + } + position++ + goto l358 + l359: + position, tokenIndex = position358, tokenIndex358 + if buffer[position] != rune('+') { + goto l360 + } + position++ + goto l358 + l360: + position, tokenIndex = position358, tokenIndex358 + if buffer[position] != rune('-') { + goto l356 + } + position++ + } + l358: + goto l357 + l356: + position, tokenIndex = position356, tokenIndex356 + } + l357: + add(ruleInstructionName, position346) + } + return true + l345: + position, tokenIndex = position345, tokenIndex345 + return false + }, + /* 27 InstructionArg <- <(IndirectionIndicator? (RegisterOrConstant / LocalLabelRef / TOCRefHigh / TOCRefLow / MemoryRef))> */ + func() bool { + position361, tokenIndex361 := position, tokenIndex + { + position362 := position + { + position363, tokenIndex363 := position, tokenIndex + if !_rules[ruleIndirectionIndicator]() { + goto l363 + } + goto l364 + l363: + position, tokenIndex = position363, tokenIndex363 + } + l364: + { + position365, tokenIndex365 := position, tokenIndex + if !_rules[ruleRegisterOrConstant]() { + goto l366 + } + goto l365 + l366: + position, tokenIndex = position365, tokenIndex365 + if !_rules[ruleLocalLabelRef]() { + goto l367 + } + goto l365 + l367: + position, tokenIndex = position365, tokenIndex365 + if !_rules[ruleTOCRefHigh]() { + goto l368 + } + goto l365 + l368: + position, tokenIndex = position365, tokenIndex365 + if !_rules[ruleTOCRefLow]() { + goto l369 + } + goto l365 + l369: + position, tokenIndex = position365, tokenIndex365 + if !_rules[ruleMemoryRef]() { + goto l361 + } + } + l365: + add(ruleInstructionArg, position362) + } + return true + l361: + position, tokenIndex = position361, tokenIndex361 + return false + }, + /* 28 TOCRefHigh <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('h' / 'H') ('a' / 'A')))> */ + func() bool { + position370, tokenIndex370 := position, tokenIndex + { + position371 := position + if buffer[position] != rune('.') { + goto l370 + } + position++ + if buffer[position] != rune('T') { + goto l370 + } + position++ + if buffer[position] != rune('O') { + goto l370 + } + position++ + if buffer[position] != rune('C') { + goto l370 + } + position++ + if buffer[position] != rune('.') { + goto l370 + } + position++ + if buffer[position] != rune('-') { + goto l370 + } + position++ + { + position372, tokenIndex372 := position, tokenIndex + if buffer[position] != rune('0') { + goto l373 + } + position++ + if buffer[position] != rune('b') { + goto l373 + } + position++ + goto l372 + l373: + position, tokenIndex = position372, tokenIndex372 + if buffer[position] != rune('.') { + goto l370 + } + position++ + if buffer[position] != rune('L') { + goto l370 + } + position++ + { + position376, tokenIndex376 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l377 + } + position++ + goto l376 + l377: + position, tokenIndex = position376, tokenIndex376 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l378 + } + position++ + goto l376 + l378: + position, tokenIndex = position376, tokenIndex376 + if buffer[position] != rune('_') { + goto l379 + } + position++ + goto l376 + l379: + position, tokenIndex = position376, tokenIndex376 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l370 + } + position++ + } + l376: + l374: + { + position375, tokenIndex375 := position, tokenIndex + { + position380, tokenIndex380 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l381 + } + position++ + goto l380 + l381: + position, tokenIndex = position380, tokenIndex380 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l382 + } + position++ + goto l380 + l382: + position, tokenIndex = position380, tokenIndex380 + if buffer[position] != rune('_') { + goto l383 + } + position++ + goto l380 + l383: + position, tokenIndex = position380, tokenIndex380 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l375 + } + position++ + } + l380: + goto l374 + l375: + position, tokenIndex = position375, tokenIndex375 + } + } + l372: + if buffer[position] != rune('@') { + goto l370 + } + position++ + { + position384, tokenIndex384 := position, tokenIndex + if buffer[position] != rune('h') { + goto l385 + } + position++ + goto l384 + l385: + position, tokenIndex = position384, tokenIndex384 + if buffer[position] != rune('H') { + goto l370 + } + position++ + } + l384: + { + position386, tokenIndex386 := position, tokenIndex + if buffer[position] != rune('a') { + goto l387 + } + position++ + goto l386 + l387: + position, tokenIndex = position386, tokenIndex386 + if buffer[position] != rune('A') { + goto l370 + } + position++ + } + l386: + add(ruleTOCRefHigh, position371) + } + return true + l370: + position, tokenIndex = position370, tokenIndex370 + return false + }, + /* 29 TOCRefLow <- <('.' 'T' 'O' 'C' '.' '-' (('0' 'b') / ('.' 'L' ([a-z] / [A-Z] / '_' / [0-9])+)) ('@' ('l' / 'L')))> */ + func() bool { + position388, tokenIndex388 := position, tokenIndex + { + position389 := position + if buffer[position] != rune('.') { + goto l388 + } + position++ + if buffer[position] != rune('T') { + goto l388 + } + position++ + if buffer[position] != rune('O') { + goto l388 + } + position++ + if buffer[position] != rune('C') { + goto l388 + } + position++ + if buffer[position] != rune('.') { + goto l388 + } + position++ + if buffer[position] != rune('-') { + goto l388 + } + position++ + { + position390, tokenIndex390 := position, tokenIndex + if buffer[position] != rune('0') { + goto l391 + } + position++ + if buffer[position] != rune('b') { + goto l391 + } + position++ + goto l390 + l391: + position, tokenIndex = position390, tokenIndex390 + if buffer[position] != rune('.') { + goto l388 + } + position++ + if buffer[position] != rune('L') { + goto l388 + } + position++ + { + position394, tokenIndex394 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l395 + } + position++ + goto l394 + l395: + position, tokenIndex = position394, tokenIndex394 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l396 + } + position++ + goto l394 + l396: + position, tokenIndex = position394, tokenIndex394 + if buffer[position] != rune('_') { + goto l397 + } + position++ + goto l394 + l397: + position, tokenIndex = position394, tokenIndex394 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l388 + } + position++ + } + l394: + l392: + { + position393, tokenIndex393 := position, tokenIndex + { + position398, tokenIndex398 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l399 + } + position++ + goto l398 + l399: + position, tokenIndex = position398, tokenIndex398 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l400 + } + position++ + goto l398 + l400: + position, tokenIndex = position398, tokenIndex398 + if buffer[position] != rune('_') { + goto l401 + } + position++ + goto l398 + l401: + position, tokenIndex = position398, tokenIndex398 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l393 + } + position++ + } + l398: + goto l392 + l393: + position, tokenIndex = position393, tokenIndex393 + } + } + l390: + if buffer[position] != rune('@') { + goto l388 + } + position++ + { + position402, tokenIndex402 := position, tokenIndex + if buffer[position] != rune('l') { + goto l403 + } + position++ + goto l402 + l403: + position, tokenIndex = position402, tokenIndex402 + if buffer[position] != rune('L') { + goto l388 + } + position++ + } + l402: + add(ruleTOCRefLow, position389) + } + return true + l388: + position, tokenIndex = position388, tokenIndex388 + return false + }, + /* 30 IndirectionIndicator <- <'*'> */ + func() bool { + position404, tokenIndex404 := position, tokenIndex + { + position405 := position + if buffer[position] != rune('*') { + goto l404 + } + position++ + add(ruleIndirectionIndicator, position405) + } + return true + l404: + position, tokenIndex = position404, tokenIndex404 + return false + }, + /* 31 RegisterOrConstant <- <((('%' ([a-z] / [A-Z]) ([a-z] / [A-Z] / ([0-9] / [0-9]))*) / ('$'? ((Offset Offset) / Offset))) !('f' / 'b' / ':' / '(' / '+' / '-'))> */ + func() bool { + position406, tokenIndex406 := position, tokenIndex + { + position407 := position + { + position408, tokenIndex408 := position, tokenIndex + if buffer[position] != rune('%') { + goto l409 + } + position++ + { + position410, tokenIndex410 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l411 + } + position++ + goto l410 + l411: + position, tokenIndex = position410, tokenIndex410 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l409 + } + position++ + } + l410: + l412: + { + position413, tokenIndex413 := position, tokenIndex + { + position414, tokenIndex414 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l415 + } + position++ + goto l414 + l415: + position, tokenIndex = position414, tokenIndex414 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l416 + } + position++ + goto l414 + l416: + position, tokenIndex = position414, tokenIndex414 + { + position417, tokenIndex417 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l418 + } + position++ + goto l417 + l418: + position, tokenIndex = position417, tokenIndex417 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l413 + } + position++ + } + l417: + } + l414: + goto l412 + l413: + position, tokenIndex = position413, tokenIndex413 + } + goto l408 + l409: + position, tokenIndex = position408, tokenIndex408 + { + position419, tokenIndex419 := position, tokenIndex + if buffer[position] != rune('$') { + goto l419 + } + position++ + goto l420 + l419: + position, tokenIndex = position419, tokenIndex419 + } + l420: + { + position421, tokenIndex421 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l422 + } + if !_rules[ruleOffset]() { + goto l422 + } + goto l421 + l422: + position, tokenIndex = position421, tokenIndex421 + if !_rules[ruleOffset]() { + goto l406 + } + } + l421: + } + l408: + { + position423, tokenIndex423 := position, tokenIndex + { + position424, tokenIndex424 := position, tokenIndex + if buffer[position] != rune('f') { + goto l425 + } + position++ + goto l424 + l425: + position, tokenIndex = position424, tokenIndex424 + if buffer[position] != rune('b') { + 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 buffer[position] != rune('(') { + goto l428 + } + position++ + goto l424 + l428: + position, tokenIndex = position424, tokenIndex424 + if buffer[position] != rune('+') { + goto l429 + } + position++ + goto l424 + l429: + position, tokenIndex = position424, tokenIndex424 + if buffer[position] != rune('-') { + goto l423 + } + position++ + } + l424: + goto l406 + l423: + position, tokenIndex = position423, tokenIndex423 + } + add(ruleRegisterOrConstant, position407) + } + return true + l406: + position, tokenIndex = position406, tokenIndex406 + return false + }, + /* 32 MemoryRef <- <((SymbolRef BaseIndexScale) / SymbolRef / (Offset* BaseIndexScale) / (SegmentRegister Offset BaseIndexScale) / (SegmentRegister BaseIndexScale) / (SegmentRegister Offset) / BaseIndexScale)> */ + func() bool { + position430, tokenIndex430 := position, tokenIndex + { + position431 := position + { + position432, tokenIndex432 := position, tokenIndex + if !_rules[ruleSymbolRef]() { + goto l433 + } + if !_rules[ruleBaseIndexScale]() { + goto l433 + } + goto l432 + l433: + position, tokenIndex = position432, tokenIndex432 + if !_rules[ruleSymbolRef]() { + goto l434 + } + goto l432 + l434: + position, tokenIndex = position432, tokenIndex432 + l436: + { + position437, tokenIndex437 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l437 + } + goto l436 + l437: + position, tokenIndex = position437, tokenIndex437 + } + if !_rules[ruleBaseIndexScale]() { + goto l435 + } + goto l432 + l435: + position, tokenIndex = position432, tokenIndex432 + if !_rules[ruleSegmentRegister]() { + goto l438 + } + if !_rules[ruleOffset]() { + goto l438 + } + if !_rules[ruleBaseIndexScale]() { + goto l438 + } + goto l432 + l438: + position, tokenIndex = position432, tokenIndex432 + if !_rules[ruleSegmentRegister]() { + goto l439 + } + if !_rules[ruleBaseIndexScale]() { + goto l439 + } + goto l432 + l439: + position, tokenIndex = position432, tokenIndex432 + if !_rules[ruleSegmentRegister]() { + goto l440 + } + if !_rules[ruleOffset]() { + goto l440 + } + goto l432 + l440: + position, tokenIndex = position432, tokenIndex432 + if !_rules[ruleBaseIndexScale]() { + goto l430 + } + } + l432: + add(ruleMemoryRef, position431) + } + return true + l430: + position, tokenIndex = position430, tokenIndex430 + return false + }, + /* 33 SymbolRef <- <((Offset* '+')? (LocalSymbol / SymbolName) Offset* ('@' Section Offset*)?)> */ + func() bool { + position441, tokenIndex441 := position, tokenIndex + { + position442 := position + { + position443, tokenIndex443 := position, tokenIndex + l445: + { + position446, tokenIndex446 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l446 + } + goto l445 + l446: + position, tokenIndex = position446, tokenIndex446 + } + if buffer[position] != rune('+') { + goto l443 + } + position++ + goto l444 + l443: + position, tokenIndex = position443, tokenIndex443 + } + l444: + { + position447, tokenIndex447 := position, tokenIndex + if !_rules[ruleLocalSymbol]() { + goto l448 + } + goto l447 + l448: + position, tokenIndex = position447, tokenIndex447 + if !_rules[ruleSymbolName]() { + goto l441 + } + } + l447: + l449: + { + position450, tokenIndex450 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l450 + } + goto l449 + l450: + position, tokenIndex = position450, tokenIndex450 + } + { + position451, tokenIndex451 := position, tokenIndex + if buffer[position] != rune('@') { + goto l451 + } + position++ + if !_rules[ruleSection]() { + goto l451 + } + l453: + { + position454, tokenIndex454 := position, tokenIndex + if !_rules[ruleOffset]() { + goto l454 + } + goto l453 + l454: + position, tokenIndex = position454, tokenIndex454 + } + goto l452 + l451: + position, tokenIndex = position451, tokenIndex451 + } + l452: + add(ruleSymbolRef, position442) + } + return true + l441: + position, tokenIndex = position441, tokenIndex441 + return false + }, + /* 34 BaseIndexScale <- <('(' RegisterOrConstant? WS? (',' WS? RegisterOrConstant WS? (',' [0-9]+)?)? ')')> */ + func() bool { + position455, tokenIndex455 := position, tokenIndex + { + position456 := position + if buffer[position] != rune('(') { + goto l455 + } + position++ + { + position457, tokenIndex457 := position, tokenIndex + if !_rules[ruleRegisterOrConstant]() { + goto l457 + } + goto l458 + l457: + position, tokenIndex = position457, tokenIndex457 + } + l458: + { + position459, tokenIndex459 := position, tokenIndex + if !_rules[ruleWS]() { + goto l459 + } + goto l460 + l459: + position, tokenIndex = position459, tokenIndex459 + } + l460: + { + position461, tokenIndex461 := position, tokenIndex + if buffer[position] != rune(',') { + goto l461 + } + position++ + { + position463, tokenIndex463 := position, tokenIndex + if !_rules[ruleWS]() { + goto l463 + } + goto l464 + l463: + position, tokenIndex = position463, tokenIndex463 + } + l464: + if !_rules[ruleRegisterOrConstant]() { + goto l461 + } + { + position465, tokenIndex465 := position, tokenIndex + if !_rules[ruleWS]() { + goto l465 + } + goto l466 + l465: + position, tokenIndex = position465, tokenIndex465 + } + l466: + { + position467, tokenIndex467 := position, tokenIndex + if buffer[position] != rune(',') { + goto l467 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l467 + } + position++ + l469: + { + position470, tokenIndex470 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l470 + } + position++ + goto l469 + l470: + position, tokenIndex = position470, tokenIndex470 + } + goto l468 + l467: + position, tokenIndex = position467, tokenIndex467 + } + l468: + goto l462 + l461: + position, tokenIndex = position461, tokenIndex461 + } + l462: + if buffer[position] != rune(')') { + goto l455 + } + position++ + add(ruleBaseIndexScale, position456) + } + return true + l455: + position, tokenIndex = position455, tokenIndex455 + return false + }, + /* 35 Operator <- <('+' / '-')> */ + func() bool { + position471, tokenIndex471 := position, tokenIndex + { + position472 := position + { + position473, tokenIndex473 := position, tokenIndex + if buffer[position] != rune('+') { + goto l474 + } + position++ + goto l473 + l474: + position, tokenIndex = position473, tokenIndex473 + if buffer[position] != rune('-') { + goto l471 + } + position++ + } + l473: + add(ruleOperator, position472) + } + return true + l471: + position, tokenIndex = position471, tokenIndex471 + return false + }, + /* 36 Offset <- <('+'? '-'? (('0' ('b' / 'B') ('0' / '1')+) / ('0' ('x' / 'X') ([0-9] / [0-9] / ([a-f] / [A-F]))+) / [0-9]+))> */ + func() bool { + position475, tokenIndex475 := position, tokenIndex + { + position476 := position + { + position477, tokenIndex477 := position, tokenIndex + if buffer[position] != rune('+') { + goto l477 + } + position++ + goto l478 + l477: + position, tokenIndex = position477, tokenIndex477 + } + l478: + { + position479, tokenIndex479 := position, tokenIndex + if buffer[position] != rune('-') { + goto l479 + } + position++ + goto l480 + l479: + position, tokenIndex = position479, tokenIndex479 + } + l480: + { + position481, tokenIndex481 := position, tokenIndex + if buffer[position] != rune('0') { + goto l482 + } + position++ + { + position483, tokenIndex483 := position, tokenIndex + if buffer[position] != rune('b') { + goto l484 + } + position++ + goto l483 + l484: + position, tokenIndex = position483, tokenIndex483 + if buffer[position] != rune('B') { + goto l482 + } + position++ + } + l483: + { + position487, tokenIndex487 := position, tokenIndex + if buffer[position] != rune('0') { + goto l488 + } + position++ + goto l487 + l488: + position, tokenIndex = position487, tokenIndex487 + if buffer[position] != rune('1') { + goto l482 + } + position++ + } + l487: + l485: + { + position486, tokenIndex486 := position, tokenIndex + { + position489, tokenIndex489 := position, tokenIndex + if buffer[position] != rune('0') { + goto l490 + } + position++ + goto l489 + l490: + position, tokenIndex = position489, tokenIndex489 + if buffer[position] != rune('1') { + goto l486 + } + position++ + } + l489: + goto l485 + l486: + position, tokenIndex = position486, tokenIndex486 + } + goto l481 + l482: + position, tokenIndex = position481, tokenIndex481 + if buffer[position] != rune('0') { + goto l491 + } + position++ + { + position492, tokenIndex492 := position, tokenIndex + if buffer[position] != rune('x') { + goto l493 + } + position++ + goto l492 + l493: + position, tokenIndex = position492, tokenIndex492 + if buffer[position] != rune('X') { + goto l491 + } + position++ + } + l492: + { + position496, tokenIndex496 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l497 + } + position++ + goto l496 + l497: + position, tokenIndex = position496, tokenIndex496 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l498 + } + position++ + goto l496 + l498: + position, tokenIndex = position496, tokenIndex496 + { + position499, tokenIndex499 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('f') { + goto l500 + } + position++ + goto l499 + l500: + position, tokenIndex = position499, tokenIndex499 + if c := buffer[position]; c < rune('A') || c > rune('F') { + goto l491 + } + position++ + } + l499: + } + l496: + l494: + { + position495, tokenIndex495 := position, tokenIndex + { + position501, tokenIndex501 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l502 + } + position++ + goto l501 + l502: + position, tokenIndex = position501, tokenIndex501 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l503 + } + position++ + goto l501 + l503: + position, tokenIndex = position501, tokenIndex501 + { + position504, tokenIndex504 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('f') { + goto l505 + } + position++ + goto l504 + l505: + position, tokenIndex = position504, tokenIndex504 + if c := buffer[position]; c < rune('A') || c > rune('F') { + goto l495 + } + position++ + } + l504: + } + l501: + goto l494 + l495: + position, tokenIndex = position495, tokenIndex495 + } + goto l481 + l491: + position, tokenIndex = position481, tokenIndex481 + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l475 + } + position++ + l506: + { + position507, tokenIndex507 := position, tokenIndex + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l507 + } + position++ + goto l506 + l507: + position, tokenIndex = position507, tokenIndex507 + } + } + l481: + add(ruleOffset, position476) + } + return true + l475: + position, tokenIndex = position475, tokenIndex475 + return false + }, + /* 37 Section <- <([a-z] / [A-Z] / '@')+> */ + func() bool { + position508, tokenIndex508 := position, tokenIndex + { + position509 := position + { + position512, tokenIndex512 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l513 + } + position++ + goto l512 + l513: + position, tokenIndex = position512, tokenIndex512 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l514 + } + position++ + goto l512 + l514: + position, tokenIndex = position512, tokenIndex512 + if buffer[position] != rune('@') { + goto l508 + } + position++ + } + l512: + l510: + { + position511, tokenIndex511 := position, tokenIndex + { + position515, tokenIndex515 := position, tokenIndex + if c := buffer[position]; c < rune('a') || c > rune('z') { + goto l516 + } + position++ + goto l515 + l516: + position, tokenIndex = position515, tokenIndex515 + if c := buffer[position]; c < rune('A') || c > rune('Z') { + goto l517 + } + position++ + goto l515 + l517: + position, tokenIndex = position515, tokenIndex515 + if buffer[position] != rune('@') { + goto l511 + } + position++ + } + l515: + goto l510 + l511: + position, tokenIndex = position511, tokenIndex511 + } + add(ruleSection, position509) + } + return true + l508: + position, tokenIndex = position508, tokenIndex508 + return false + }, + /* 38 SegmentRegister <- <('%' ([c-g] / 's') ('s' ':'))> */ + func() bool { + position518, tokenIndex518 := position, tokenIndex + { + position519 := position + if buffer[position] != rune('%') { + goto l518 + } + position++ + { + position520, tokenIndex520 := position, tokenIndex + if c := buffer[position]; c < rune('c') || c > rune('g') { + goto l521 + } + position++ + goto l520 + l521: + position, tokenIndex = position520, tokenIndex520 + if buffer[position] != rune('s') { + goto l518 + } + position++ + } + l520: + if buffer[position] != rune('s') { + goto l518 + } + position++ + if buffer[position] != rune(':') { + goto l518 + } + position++ + add(ruleSegmentRegister, position519) + } + return true + l518: + position, tokenIndex = position518, tokenIndex518 + return false + }, + } + p.rules = _rules +} |