erd.peg.go

package main

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

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

const endSymbol rune = 1114112

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

const (
	ruleUnknown pegRule = iota
	ruleroot
	ruleEOT
	ruleexpression
	ruleempty_line
	rulecomment_line
	rulecolor_info
	rulecolor_key_value
	ruletitle_info
	ruletable_info
	ruletable_title
	ruletable_column
	rulecolumn_name
	rulerelation_info
	rulerelation_left
	rulecardinality_left
	rulerelation_right
	rulecardinality_right
	ruletitle_attribute
	ruletable_attribute
	rulecolumn_attribute
	rulerelation_attribute
	ruleattribute_key
	ruleattribute_value
	rulebare_value
	rulequoted_value
	ruleattribute_sep
	rulecomment_string
	rulews
	rulenewline
	rulenewline_or_eot
	rulespace
	rulestring
	rulestring_in_quote
	rulecardinality
	rulePegText
	ruleAction0
	ruleAction1
	ruleAction2
	ruleAction3
	ruleAction4
	ruleAction5
	ruleAction6
	ruleAction7
	ruleAction8
	ruleAction9
	ruleAction10
	ruleAction11
	ruleAction12
	ruleAction13
	ruleAction14
	ruleAction15
	ruleAction16
	ruleAction17
)

var rul3s = [...]string{
	"Unknown",
	"root",
	"EOT",
	"expression",
	"empty_line",
	"comment_line",
	"color_info",
	"color_key_value",
	"title_info",
	"table_info",
	"table_title",
	"table_column",
	"column_name",
	"relation_info",
	"relation_left",
	"cardinality_left",
	"relation_right",
	"cardinality_right",
	"title_attribute",
	"table_attribute",
	"column_attribute",
	"relation_attribute",
	"attribute_key",
	"attribute_value",
	"bare_value",
	"quoted_value",
	"attribute_sep",
	"comment_string",
	"ws",
	"newline",
	"newline_or_eot",
	"space",
	"string",
	"string_in_quote",
	"cardinality",
	"PegText",
	"Action0",
	"Action1",
	"Action2",
	"Action3",
	"Action4",
	"Action5",
	"Action6",
	"Action7",
	"Action8",
	"Action9",
	"Action10",
	"Action11",
	"Action12",
	"Action13",
	"Action14",
	"Action15",
	"Action16",
	"Action17",
}

type token32 struct {
	pegRule
	begin, end uint32
}

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

type node32 struct {
	token32
	up, next *node32
}

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

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

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

type tokens32 struct {
	tree []token32
}

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

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

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

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

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

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

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

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

type Parser struct {
	Erd

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

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

func (p *Parser) 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   *Parser
	max token32
}

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

	return err
}

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

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

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

func (p *Parser) Execute() {
	buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0
	for _, token := range p.Tokens() {
		switch token.pegRule {

		case rulePegText:
			begin, end = int(token.begin), int(token.end)
			text = string(_buffer[begin:end])

		case ruleAction0:
			p.Err(begin, buffer)
		case ruleAction1:
			p.Err(begin, buffer)
		case ruleAction2:
			p.ClearTableAndColumn()
		case ruleAction3:
			p.AddColorDefine()
		case ruleAction4:
			p.AddTable(text)
		case ruleAction5:
			p.AddColumn(text)
		case ruleAction6:
			p.AddRelation()
		case ruleAction7:
			p.SetRelationLeft(text)
		case ruleAction8:
			p.SetCardinalityLeft(text)
		case ruleAction9:
			p.SetRelationRight(text)
		case ruleAction10:
			p.SetCardinalityRight(text)
		case ruleAction11:
			p.AddTitleKeyValue()
		case ruleAction12:
			p.AddTableKeyValue()
		case ruleAction13:
			p.AddColumnKeyValue()
		case ruleAction14:
			p.AddRelationKeyValue()
		case ruleAction15:
			p.SetKey(text)
		case ruleAction16:
			p.SetValue(text)
		case ruleAction17:
			p.SetValue(text)

		}
	}
	_, _, _, _, _ = buffer, _buffer, text, begin, end
}

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

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

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

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

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

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

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

	_rules = [...]func() bool{
		nil,
		/* 0 root <- <((expression EOT) / (expression <.+> Action0 EOT) / (<.+> Action1 EOT))> */
		func() bool {
			position0, tokenIndex0 := position, tokenIndex
			{
				position1 := position
				{
					position2, tokenIndex2 := position, tokenIndex
					if !_rules[ruleexpression]() {
						goto l3
					}
					if !_rules[ruleEOT]() {
						goto l3
					}
					goto l2
				l3:
					position, tokenIndex = position2, tokenIndex2
					if !_rules[ruleexpression]() {
						goto l4
					}
					{
						position5 := position
						if !matchDot() {
							goto l4
						}
					l6:
						{
							position7, tokenIndex7 := position, tokenIndex
							if !matchDot() {
								goto l7
							}
							goto l6
						l7:
							position, tokenIndex = position7, tokenIndex7
						}
						add(rulePegText, position5)
					}
					if !_rules[ruleAction0]() {
						goto l4
					}
					if !_rules[ruleEOT]() {
						goto l4
					}
					goto l2
				l4:
					position, tokenIndex = position2, tokenIndex2
					{
						position8 := position
						if !matchDot() {
							goto l0
						}
					l9:
						{
							position10, tokenIndex10 := position, tokenIndex
							if !matchDot() {
								goto l10
							}
							goto l9
						l10:
							position, tokenIndex = position10, tokenIndex10
						}
						add(rulePegText, position8)
					}
					if !_rules[ruleAction1]() {
						goto l0
					}
					if !_rules[ruleEOT]() {
						goto l0
					}
				}
			l2:
				add(ruleroot, position1)
			}
			return true
		l0:
			position, tokenIndex = position0, tokenIndex0
			return false
		},
		/* 1 EOT <- <!.> */
		func() bool {
			position11, tokenIndex11 := position, tokenIndex
			{
				position12 := position
				{
					position13, tokenIndex13 := position, tokenIndex
					if !matchDot() {
						goto l13
					}
					goto l11
				l13:
					position, tokenIndex = position13, tokenIndex13
				}
				add(ruleEOT, position12)
			}
			return true
		l11:
			position, tokenIndex = position11, tokenIndex11
			return false
		},
		/* 2 expression <- <(title_info / color_info / relation_info / table_info / comment_line / empty_line)*> */
		func() bool {
			{
				position15 := position
			l16:
				{
					position17, tokenIndex17 := position, tokenIndex
					{
						position18, tokenIndex18 := position, tokenIndex
						if !_rules[ruletitle_info]() {
							goto l19
						}
						goto l18
					l19:
						position, tokenIndex = position18, tokenIndex18
						if !_rules[rulecolor_info]() {
							goto l20
						}
						goto l18
					l20:
						position, tokenIndex = position18, tokenIndex18
						if !_rules[rulerelation_info]() {
							goto l21
						}
						goto l18
					l21:
						position, tokenIndex = position18, tokenIndex18
						if !_rules[ruletable_info]() {
							goto l22
						}
						goto l18
					l22:
						position, tokenIndex = position18, tokenIndex18
						if !_rules[rulecomment_line]() {
							goto l23
						}
						goto l18
					l23:
						position, tokenIndex = position18, tokenIndex18
						if !_rules[ruleempty_line]() {
							goto l17
						}
					}
				l18:
					goto l16
				l17:
					position, tokenIndex = position17, tokenIndex17
				}
				add(ruleexpression, position15)
			}
			return true
		},
		/* 3 empty_line <- <(ws Action2)> */
		func() bool {
			position24, tokenIndex24 := position, tokenIndex
			{
				position25 := position
				if !_rules[rulews]() {
					goto l24
				}
				if !_rules[ruleAction2]() {
					goto l24
				}
				add(ruleempty_line, position25)
			}
			return true
		l24:
			position, tokenIndex = position24, tokenIndex24
			return false
		},
		/* 4 comment_line <- <(space* '#' comment_string newline)> */
		func() bool {
			position26, tokenIndex26 := position, tokenIndex
			{
				position27 := position
			l28:
				{
					position29, tokenIndex29 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l29
					}
					goto l28
				l29:
					position, tokenIndex = position29, tokenIndex29
				}
				if buffer[position] != rune('#') {
					goto l26
				}
				position++
				if !_rules[rulecomment_string]() {
					goto l26
				}
				if !_rules[rulenewline]() {
					goto l26
				}
				add(rulecomment_line, position27)
			}
			return true
		l26:
			position, tokenIndex = position26, tokenIndex26
			return false
		},
		/* 5 color_info <- <('c' 'o' 'l' 'o' 'r' 's' ws* '{' ws* (color_key_value ws* attribute_sep? ws*)* ws* '}' newline)> */
		func() bool {
			position30, tokenIndex30 := position, tokenIndex
			{
				position31 := position
				if buffer[position] != rune('c') {
					goto l30
				}
				position++
				if buffer[position] != rune('o') {
					goto l30
				}
				position++
				if buffer[position] != rune('l') {
					goto l30
				}
				position++
				if buffer[position] != rune('o') {
					goto l30
				}
				position++
				if buffer[position] != rune('r') {
					goto l30
				}
				position++
				if buffer[position] != rune('s') {
					goto l30
				}
				position++
			l32:
				{
					position33, tokenIndex33 := position, tokenIndex
					if !_rules[rulews]() {
						goto l33
					}
					goto l32
				l33:
					position, tokenIndex = position33, tokenIndex33
				}
				if buffer[position] != rune('{') {
					goto l30
				}
				position++
			l34:
				{
					position35, tokenIndex35 := position, tokenIndex
					if !_rules[rulews]() {
						goto l35
					}
					goto l34
				l35:
					position, tokenIndex = position35, tokenIndex35
				}
			l36:
				{
					position37, tokenIndex37 := position, tokenIndex
					if !_rules[rulecolor_key_value]() {
						goto l37
					}
				l38:
					{
						position39, tokenIndex39 := position, tokenIndex
						if !_rules[rulews]() {
							goto l39
						}
						goto l38
					l39:
						position, tokenIndex = position39, tokenIndex39
					}
					{
						position40, tokenIndex40 := position, tokenIndex
						if !_rules[ruleattribute_sep]() {
							goto l40
						}
						goto l41
					l40:
						position, tokenIndex = position40, tokenIndex40
					}
				l41:
				l42:
					{
						position43, tokenIndex43 := position, tokenIndex
						if !_rules[rulews]() {
							goto l43
						}
						goto l42
					l43:
						position, tokenIndex = position43, tokenIndex43
					}
					goto l36
				l37:
					position, tokenIndex = position37, tokenIndex37
				}
			l44:
				{
					position45, tokenIndex45 := position, tokenIndex
					if !_rules[rulews]() {
						goto l45
					}
					goto l44
				l45:
					position, tokenIndex = position45, tokenIndex45
				}
				if buffer[position] != rune('}') {
					goto l30
				}
				position++
				if !_rules[rulenewline]() {
					goto l30
				}
				add(rulecolor_info, position31)
			}
			return true
		l30:
			position, tokenIndex = position30, tokenIndex30
			return false
		},
		/* 6 color_key_value <- <(attribute_key space* ':' space* attribute_value Action3)> */
		func() bool {
			position46, tokenIndex46 := position, tokenIndex
			{
				position47 := position
				if !_rules[ruleattribute_key]() {
					goto l46
				}
			l48:
				{
					position49, tokenIndex49 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l49
					}
					goto l48
				l49:
					position, tokenIndex = position49, tokenIndex49
				}
				if buffer[position] != rune(':') {
					goto l46
				}
				position++
			l50:
				{
					position51, tokenIndex51 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l51
					}
					goto l50
				l51:
					position, tokenIndex = position51, tokenIndex51
				}
				if !_rules[ruleattribute_value]() {
					goto l46
				}
				if !_rules[ruleAction3]() {
					goto l46
				}
				add(rulecolor_key_value, position47)
			}
			return true
		l46:
			position, tokenIndex = position46, tokenIndex46
			return false
		},
		/* 7 title_info <- <('t' 'i' 't' 'l' 'e' ws* '{' ws* (title_attribute ws* attribute_sep? ws*)* ws* '}' newline)> */
		func() bool {
			position52, tokenIndex52 := position, tokenIndex
			{
				position53 := position
				if buffer[position] != rune('t') {
					goto l52
				}
				position++
				if buffer[position] != rune('i') {
					goto l52
				}
				position++
				if buffer[position] != rune('t') {
					goto l52
				}
				position++
				if buffer[position] != rune('l') {
					goto l52
				}
				position++
				if buffer[position] != rune('e') {
					goto l52
				}
				position++
			l54:
				{
					position55, tokenIndex55 := position, tokenIndex
					if !_rules[rulews]() {
						goto l55
					}
					goto l54
				l55:
					position, tokenIndex = position55, tokenIndex55
				}
				if buffer[position] != rune('{') {
					goto l52
				}
				position++
			l56:
				{
					position57, tokenIndex57 := position, tokenIndex
					if !_rules[rulews]() {
						goto l57
					}
					goto l56
				l57:
					position, tokenIndex = position57, tokenIndex57
				}
			l58:
				{
					position59, tokenIndex59 := position, tokenIndex
					if !_rules[ruletitle_attribute]() {
						goto l59
					}
				l60:
					{
						position61, tokenIndex61 := position, tokenIndex
						if !_rules[rulews]() {
							goto l61
						}
						goto l60
					l61:
						position, tokenIndex = position61, tokenIndex61
					}
					{
						position62, tokenIndex62 := position, tokenIndex
						if !_rules[ruleattribute_sep]() {
							goto l62
						}
						goto l63
					l62:
						position, tokenIndex = position62, tokenIndex62
					}
				l63:
				l64:
					{
						position65, tokenIndex65 := position, tokenIndex
						if !_rules[rulews]() {
							goto l65
						}
						goto l64
					l65:
						position, tokenIndex = position65, tokenIndex65
					}
					goto l58
				l59:
					position, tokenIndex = position59, tokenIndex59
				}
			l66:
				{
					position67, tokenIndex67 := position, tokenIndex
					if !_rules[rulews]() {
						goto l67
					}
					goto l66
				l67:
					position, tokenIndex = position67, tokenIndex67
				}
				if buffer[position] != rune('}') {
					goto l52
				}
				position++
				if !_rules[rulenewline]() {
					goto l52
				}
				add(ruletitle_info, position53)
			}
			return true
		l52:
			position, tokenIndex = position52, tokenIndex52
			return false
		},
		/* 8 table_info <- <('[' table_title ']' (space* '{' ws* (table_attribute ws* attribute_sep?)* ws* '}' space*)? newline_or_eot (table_column / empty_line)*)> */
		func() bool {
			position68, tokenIndex68 := position, tokenIndex
			{
				position69 := position
				if buffer[position] != rune('[') {
					goto l68
				}
				position++
				if !_rules[ruletable_title]() {
					goto l68
				}
				if buffer[position] != rune(']') {
					goto l68
				}
				position++
				{
					position70, tokenIndex70 := position, tokenIndex
				l72:
					{
						position73, tokenIndex73 := position, tokenIndex
						if !_rules[rulespace]() {
							goto l73
						}
						goto l72
					l73:
						position, tokenIndex = position73, tokenIndex73
					}
					if buffer[position] != rune('{') {
						goto l70
					}
					position++
				l74:
					{
						position75, tokenIndex75 := position, tokenIndex
						if !_rules[rulews]() {
							goto l75
						}
						goto l74
					l75:
						position, tokenIndex = position75, tokenIndex75
					}
				l76:
					{
						position77, tokenIndex77 := position, tokenIndex
						if !_rules[ruletable_attribute]() {
							goto l77
						}
					l78:
						{
							position79, tokenIndex79 := position, tokenIndex
							if !_rules[rulews]() {
								goto l79
							}
							goto l78
						l79:
							position, tokenIndex = position79, tokenIndex79
						}
						{
							position80, tokenIndex80 := position, tokenIndex
							if !_rules[ruleattribute_sep]() {
								goto l80
							}
							goto l81
						l80:
							position, tokenIndex = position80, tokenIndex80
						}
					l81:
						goto l76
					l77:
						position, tokenIndex = position77, tokenIndex77
					}
				l82:
					{
						position83, tokenIndex83 := position, tokenIndex
						if !_rules[rulews]() {
							goto l83
						}
						goto l82
					l83:
						position, tokenIndex = position83, tokenIndex83
					}
					if buffer[position] != rune('}') {
						goto l70
					}
					position++
				l84:
					{
						position85, tokenIndex85 := position, tokenIndex
						if !_rules[rulespace]() {
							goto l85
						}
						goto l84
					l85:
						position, tokenIndex = position85, tokenIndex85
					}
					goto l71
				l70:
					position, tokenIndex = position70, tokenIndex70
				}
			l71:
				if !_rules[rulenewline_or_eot]() {
					goto l68
				}
			l86:
				{
					position87, tokenIndex87 := position, tokenIndex
					{
						position88, tokenIndex88 := position, tokenIndex
						if !_rules[ruletable_column]() {
							goto l89
						}
						goto l88
					l89:
						position, tokenIndex = position88, tokenIndex88
						if !_rules[ruleempty_line]() {
							goto l87
						}
					}
				l88:
					goto l86
				l87:
					position, tokenIndex = position87, tokenIndex87
				}
				add(ruletable_info, position69)
			}
			return true
		l68:
			position, tokenIndex = position68, tokenIndex68
			return false
		},
		/* 9 table_title <- <(<string> Action4)> */
		func() bool {
			position90, tokenIndex90 := position, tokenIndex
			{
				position91 := position
				{
					position92 := position
					if !_rules[rulestring]() {
						goto l90
					}
					add(rulePegText, position92)
				}
				if !_rules[ruleAction4]() {
					goto l90
				}
				add(ruletable_title, position91)
			}
			return true
		l90:
			position, tokenIndex = position90, tokenIndex90
			return false
		},
		/* 10 table_column <- <(space* column_name (space* '{' ws* (column_attribute ws* attribute_sep?)* ws* '}' space*)? newline_or_eot)> */
		func() bool {
			position93, tokenIndex93 := position, tokenIndex
			{
				position94 := position
			l95:
				{
					position96, tokenIndex96 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l96
					}
					goto l95
				l96:
					position, tokenIndex = position96, tokenIndex96
				}
				if !_rules[rulecolumn_name]() {
					goto l93
				}
				{
					position97, tokenIndex97 := position, tokenIndex
				l99:
					{
						position100, tokenIndex100 := position, tokenIndex
						if !_rules[rulespace]() {
							goto l100
						}
						goto l99
					l100:
						position, tokenIndex = position100, tokenIndex100
					}
					if buffer[position] != rune('{') {
						goto l97
					}
					position++
				l101:
					{
						position102, tokenIndex102 := position, tokenIndex
						if !_rules[rulews]() {
							goto l102
						}
						goto l101
					l102:
						position, tokenIndex = position102, tokenIndex102
					}
				l103:
					{
						position104, tokenIndex104 := position, tokenIndex
						if !_rules[rulecolumn_attribute]() {
							goto l104
						}
					l105:
						{
							position106, tokenIndex106 := position, tokenIndex
							if !_rules[rulews]() {
								goto l106
							}
							goto l105
						l106:
							position, tokenIndex = position106, tokenIndex106
						}
						{
							position107, tokenIndex107 := position, tokenIndex
							if !_rules[ruleattribute_sep]() {
								goto l107
							}
							goto l108
						l107:
							position, tokenIndex = position107, tokenIndex107
						}
					l108:
						goto l103
					l104:
						position, tokenIndex = position104, tokenIndex104
					}
				l109:
					{
						position110, tokenIndex110 := position, tokenIndex
						if !_rules[rulews]() {
							goto l110
						}
						goto l109
					l110:
						position, tokenIndex = position110, tokenIndex110
					}
					if buffer[position] != rune('}') {
						goto l97
					}
					position++
				l111:
					{
						position112, tokenIndex112 := position, tokenIndex
						if !_rules[rulespace]() {
							goto l112
						}
						goto l111
					l112:
						position, tokenIndex = position112, tokenIndex112
					}
					goto l98
				l97:
					position, tokenIndex = position97, tokenIndex97
				}
			l98:
				if !_rules[rulenewline_or_eot]() {
					goto l93
				}
				add(ruletable_column, position94)
			}
			return true
		l93:
			position, tokenIndex = position93, tokenIndex93
			return false
		},
		/* 11 column_name <- <(<string> Action5)> */
		func() bool {
			position113, tokenIndex113 := position, tokenIndex
			{
				position114 := position
				{
					position115 := position
					if !_rules[rulestring]() {
						goto l113
					}
					add(rulePegText, position115)
				}
				if !_rules[ruleAction5]() {
					goto l113
				}
				add(rulecolumn_name, position114)
			}
			return true
		l113:
			position, tokenIndex = position113, tokenIndex113
			return false
		},
		/* 12 relation_info <- <(space* relation_left space* cardinality_left ('-' '-') cardinality_right space* relation_right (ws* '{' ws* (relation_attribute ws* attribute_sep? ws*)* ws* '}')? newline_or_eot Action6)> */
		func() bool {
			position116, tokenIndex116 := position, tokenIndex
			{
				position117 := position
			l118:
				{
					position119, tokenIndex119 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l119
					}
					goto l118
				l119:
					position, tokenIndex = position119, tokenIndex119
				}
				if !_rules[rulerelation_left]() {
					goto l116
				}
			l120:
				{
					position121, tokenIndex121 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l121
					}
					goto l120
				l121:
					position, tokenIndex = position121, tokenIndex121
				}
				if !_rules[rulecardinality_left]() {
					goto l116
				}
				if buffer[position] != rune('-') {
					goto l116
				}
				position++
				if buffer[position] != rune('-') {
					goto l116
				}
				position++
				if !_rules[rulecardinality_right]() {
					goto l116
				}
			l122:
				{
					position123, tokenIndex123 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l123
					}
					goto l122
				l123:
					position, tokenIndex = position123, tokenIndex123
				}
				if !_rules[rulerelation_right]() {
					goto l116
				}
				{
					position124, tokenIndex124 := position, tokenIndex
				l126:
					{
						position127, tokenIndex127 := position, tokenIndex
						if !_rules[rulews]() {
							goto l127
						}
						goto l126
					l127:
						position, tokenIndex = position127, tokenIndex127
					}
					if buffer[position] != rune('{') {
						goto l124
					}
					position++
				l128:
					{
						position129, tokenIndex129 := position, tokenIndex
						if !_rules[rulews]() {
							goto l129
						}
						goto l128
					l129:
						position, tokenIndex = position129, tokenIndex129
					}
				l130:
					{
						position131, tokenIndex131 := position, tokenIndex
						if !_rules[rulerelation_attribute]() {
							goto l131
						}
					l132:
						{
							position133, tokenIndex133 := position, tokenIndex
							if !_rules[rulews]() {
								goto l133
							}
							goto l132
						l133:
							position, tokenIndex = position133, tokenIndex133
						}
						{
							position134, tokenIndex134 := position, tokenIndex
							if !_rules[ruleattribute_sep]() {
								goto l134
							}
							goto l135
						l134:
							position, tokenIndex = position134, tokenIndex134
						}
					l135:
					l136:
						{
							position137, tokenIndex137 := position, tokenIndex
							if !_rules[rulews]() {
								goto l137
							}
							goto l136
						l137:
							position, tokenIndex = position137, tokenIndex137
						}
						goto l130
					l131:
						position, tokenIndex = position131, tokenIndex131
					}
				l138:
					{
						position139, tokenIndex139 := position, tokenIndex
						if !_rules[rulews]() {
							goto l139
						}
						goto l138
					l139:
						position, tokenIndex = position139, tokenIndex139
					}
					if buffer[position] != rune('}') {
						goto l124
					}
					position++
					goto l125
				l124:
					position, tokenIndex = position124, tokenIndex124
				}
			l125:
				if !_rules[rulenewline_or_eot]() {
					goto l116
				}
				if !_rules[ruleAction6]() {
					goto l116
				}
				add(rulerelation_info, position117)
			}
			return true
		l116:
			position, tokenIndex = position116, tokenIndex116
			return false
		},
		/* 13 relation_left <- <(<string> Action7)> */
		func() bool {
			position140, tokenIndex140 := position, tokenIndex
			{
				position141 := position
				{
					position142 := position
					if !_rules[rulestring]() {
						goto l140
					}
					add(rulePegText, position142)
				}
				if !_rules[ruleAction7]() {
					goto l140
				}
				add(rulerelation_left, position141)
			}
			return true
		l140:
			position, tokenIndex = position140, tokenIndex140
			return false
		},
		/* 14 cardinality_left <- <(<cardinality> Action8)> */
		func() bool {
			position143, tokenIndex143 := position, tokenIndex
			{
				position144 := position
				{
					position145 := position
					if !_rules[rulecardinality]() {
						goto l143
					}
					add(rulePegText, position145)
				}
				if !_rules[ruleAction8]() {
					goto l143
				}
				add(rulecardinality_left, position144)
			}
			return true
		l143:
			position, tokenIndex = position143, tokenIndex143
			return false
		},
		/* 15 relation_right <- <(<string> Action9)> */
		func() bool {
			position146, tokenIndex146 := position, tokenIndex
			{
				position147 := position
				{
					position148 := position
					if !_rules[rulestring]() {
						goto l146
					}
					add(rulePegText, position148)
				}
				if !_rules[ruleAction9]() {
					goto l146
				}
				add(rulerelation_right, position147)
			}
			return true
		l146:
			position, tokenIndex = position146, tokenIndex146
			return false
		},
		/* 16 cardinality_right <- <(<cardinality> Action10)> */
		func() bool {
			position149, tokenIndex149 := position, tokenIndex
			{
				position150 := position
				{
					position151 := position
					if !_rules[rulecardinality]() {
						goto l149
					}
					add(rulePegText, position151)
				}
				if !_rules[ruleAction10]() {
					goto l149
				}
				add(rulecardinality_right, position150)
			}
			return true
		l149:
			position, tokenIndex = position149, tokenIndex149
			return false
		},
		/* 17 title_attribute <- <(attribute_key space* ':' space* attribute_value Action11)> */
		func() bool {
			position152, tokenIndex152 := position, tokenIndex
			{
				position153 := position
				if !_rules[ruleattribute_key]() {
					goto l152
				}
			l154:
				{
					position155, tokenIndex155 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l155
					}
					goto l154
				l155:
					position, tokenIndex = position155, tokenIndex155
				}
				if buffer[position] != rune(':') {
					goto l152
				}
				position++
			l156:
				{
					position157, tokenIndex157 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l157
					}
					goto l156
				l157:
					position, tokenIndex = position157, tokenIndex157
				}
				if !_rules[ruleattribute_value]() {
					goto l152
				}
				if !_rules[ruleAction11]() {
					goto l152
				}
				add(ruletitle_attribute, position153)
			}
			return true
		l152:
			position, tokenIndex = position152, tokenIndex152
			return false
		},
		/* 18 table_attribute <- <(attribute_key space* ':' space* attribute_value Action12)> */
		func() bool {
			position158, tokenIndex158 := position, tokenIndex
			{
				position159 := position
				if !_rules[ruleattribute_key]() {
					goto l158
				}
			l160:
				{
					position161, tokenIndex161 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l161
					}
					goto l160
				l161:
					position, tokenIndex = position161, tokenIndex161
				}
				if buffer[position] != rune(':') {
					goto l158
				}
				position++
			l162:
				{
					position163, tokenIndex163 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l163
					}
					goto l162
				l163:
					position, tokenIndex = position163, tokenIndex163
				}
				if !_rules[ruleattribute_value]() {
					goto l158
				}
				if !_rules[ruleAction12]() {
					goto l158
				}
				add(ruletable_attribute, position159)
			}
			return true
		l158:
			position, tokenIndex = position158, tokenIndex158
			return false
		},
		/* 19 column_attribute <- <(attribute_key space* ':' space* attribute_value Action13)> */
		func() bool {
			position164, tokenIndex164 := position, tokenIndex
			{
				position165 := position
				if !_rules[ruleattribute_key]() {
					goto l164
				}
			l166:
				{
					position167, tokenIndex167 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l167
					}
					goto l166
				l167:
					position, tokenIndex = position167, tokenIndex167
				}
				if buffer[position] != rune(':') {
					goto l164
				}
				position++
			l168:
				{
					position169, tokenIndex169 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l169
					}
					goto l168
				l169:
					position, tokenIndex = position169, tokenIndex169
				}
				if !_rules[ruleattribute_value]() {
					goto l164
				}
				if !_rules[ruleAction13]() {
					goto l164
				}
				add(rulecolumn_attribute, position165)
			}
			return true
		l164:
			position, tokenIndex = position164, tokenIndex164
			return false
		},
		/* 20 relation_attribute <- <(attribute_key space* ':' space* attribute_value Action14)> */
		func() bool {
			position170, tokenIndex170 := position, tokenIndex
			{
				position171 := position
				if !_rules[ruleattribute_key]() {
					goto l170
				}
			l172:
				{
					position173, tokenIndex173 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l173
					}
					goto l172
				l173:
					position, tokenIndex = position173, tokenIndex173
				}
				if buffer[position] != rune(':') {
					goto l170
				}
				position++
			l174:
				{
					position175, tokenIndex175 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l175
					}
					goto l174
				l175:
					position, tokenIndex = position175, tokenIndex175
				}
				if !_rules[ruleattribute_value]() {
					goto l170
				}
				if !_rules[ruleAction14]() {
					goto l170
				}
				add(rulerelation_attribute, position171)
			}
			return true
		l170:
			position, tokenIndex = position170, tokenIndex170
			return false
		},
		/* 21 attribute_key <- <(<string> Action15)> */
		func() bool {
			position176, tokenIndex176 := position, tokenIndex
			{
				position177 := position
				{
					position178 := position
					if !_rules[rulestring]() {
						goto l176
					}
					add(rulePegText, position178)
				}
				if !_rules[ruleAction15]() {
					goto l176
				}
				add(ruleattribute_key, position177)
			}
			return true
		l176:
			position, tokenIndex = position176, tokenIndex176
			return false
		},
		/* 22 attribute_value <- <(bare_value / quoted_value)> */
		func() bool {
			position179, tokenIndex179 := position, tokenIndex
			{
				position180 := position
				{
					position181, tokenIndex181 := position, tokenIndex
					if !_rules[rulebare_value]() {
						goto l182
					}
					goto l181
				l182:
					position, tokenIndex = position181, tokenIndex181
					if !_rules[rulequoted_value]() {
						goto l179
					}
				}
			l181:
				add(ruleattribute_value, position180)
			}
			return true
		l179:
			position, tokenIndex = position179, tokenIndex179
			return false
		},
		/* 23 bare_value <- <(<string> Action16)> */
		func() bool {
			position183, tokenIndex183 := position, tokenIndex
			{
				position184 := position
				{
					position185 := position
					if !_rules[rulestring]() {
						goto l183
					}
					add(rulePegText, position185)
				}
				if !_rules[ruleAction16]() {
					goto l183
				}
				add(rulebare_value, position184)
			}
			return true
		l183:
			position, tokenIndex = position183, tokenIndex183
			return false
		},
		/* 24 quoted_value <- <(<('"' string_in_quote '"')> Action17)> */
		func() bool {
			position186, tokenIndex186 := position, tokenIndex
			{
				position187 := position
				{
					position188 := position
					if buffer[position] != rune('"') {
						goto l186
					}
					position++
					if !_rules[rulestring_in_quote]() {
						goto l186
					}
					if buffer[position] != rune('"') {
						goto l186
					}
					position++
					add(rulePegText, position188)
				}
				if !_rules[ruleAction17]() {
					goto l186
				}
				add(rulequoted_value, position187)
			}
			return true
		l186:
			position, tokenIndex = position186, tokenIndex186
			return false
		},
		/* 25 attribute_sep <- <(space* ',' space*)> */
		func() bool {
			position189, tokenIndex189 := position, tokenIndex
			{
				position190 := position
			l191:
				{
					position192, tokenIndex192 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l192
					}
					goto l191
				l192:
					position, tokenIndex = position192, tokenIndex192
				}
				if buffer[position] != rune(',') {
					goto l189
				}
				position++
			l193:
				{
					position194, tokenIndex194 := position, tokenIndex
					if !_rules[rulespace]() {
						goto l194
					}
					goto l193
				l194:
					position, tokenIndex = position194, tokenIndex194
				}
				add(ruleattribute_sep, position190)
			}
			return true
		l189:
			position, tokenIndex = position189, tokenIndex189
			return false
		},
		/* 26 comment_string <- <(!('\r' / '\n') .)*> */
		func() bool {
			{
				position196 := position
			l197:
				{
					position198, tokenIndex198 := position, tokenIndex
					{
						position199, tokenIndex199 := position, tokenIndex
						{
							position200, tokenIndex200 := position, tokenIndex
							if buffer[position] != rune('\r') {
								goto l201
							}
							position++
							goto l200
						l201:
							position, tokenIndex = position200, tokenIndex200
							if buffer[position] != rune('\n') {
								goto l199
							}
							position++
						}
					l200:
						goto l198
					l199:
						position, tokenIndex = position199, tokenIndex199
					}
					if !matchDot() {
						goto l198
					}
					goto l197
				l198:
					position, tokenIndex = position198, tokenIndex198
				}
				add(rulecomment_string, position196)
			}
			return true
		},
		/* 27 ws <- <(' ' / '\t' / '\r' / '\n')+> */
		func() bool {
			position202, tokenIndex202 := position, tokenIndex
			{
				position203 := position
				{
					position206, tokenIndex206 := position, tokenIndex
					if buffer[position] != rune(' ') {
						goto l207
					}
					position++
					goto l206
				l207:
					position, tokenIndex = position206, tokenIndex206
					if buffer[position] != rune('\t') {
						goto l208
					}
					position++
					goto l206
				l208:
					position, tokenIndex = position206, tokenIndex206
					if buffer[position] != rune('\r') {
						goto l209
					}
					position++
					goto l206
				l209:
					position, tokenIndex = position206, tokenIndex206
					if buffer[position] != rune('\n') {
						goto l202
					}
					position++
				}
			l206:
			l204:
				{
					position205, tokenIndex205 := position, tokenIndex
					{
						position210, tokenIndex210 := position, tokenIndex
						if buffer[position] != rune(' ') {
							goto l211
						}
						position++
						goto l210
					l211:
						position, tokenIndex = position210, tokenIndex210
						if buffer[position] != rune('\t') {
							goto l212
						}
						position++
						goto l210
					l212:
						position, tokenIndex = position210, tokenIndex210
						if buffer[position] != rune('\r') {
							goto l213
						}
						position++
						goto l210
					l213:
						position, tokenIndex = position210, tokenIndex210
						if buffer[position] != rune('\n') {
							goto l205
						}
						position++
					}
				l210:
					goto l204
				l205:
					position, tokenIndex = position205, tokenIndex205
				}
				add(rulews, position203)
			}
			return true
		l202:
			position, tokenIndex = position202, tokenIndex202
			return false
		},
		/* 28 newline <- <(('\r' '\n') / '\n' / '\r')> */
		func() bool {
			position214, tokenIndex214 := position, tokenIndex
			{
				position215 := position
				{
					position216, tokenIndex216 := position, tokenIndex
					if buffer[position] != rune('\r') {
						goto l217
					}
					position++
					if buffer[position] != rune('\n') {
						goto l217
					}
					position++
					goto l216
				l217:
					position, tokenIndex = position216, tokenIndex216
					if buffer[position] != rune('\n') {
						goto l218
					}
					position++
					goto l216
				l218:
					position, tokenIndex = position216, tokenIndex216
					if buffer[position] != rune('\r') {
						goto l214
					}
					position++
				}
			l216:
				add(rulenewline, position215)
			}
			return true
		l214:
			position, tokenIndex = position214, tokenIndex214
			return false
		},
		/* 29 newline_or_eot <- <(newline / EOT)> */
		func() bool {
			position219, tokenIndex219 := position, tokenIndex
			{
				position220 := position
				{
					position221, tokenIndex221 := position, tokenIndex
					if !_rules[rulenewline]() {
						goto l222
					}
					goto l221
				l222:
					position, tokenIndex = position221, tokenIndex221
					if !_rules[ruleEOT]() {
						goto l219
					}
				}
			l221:
				add(rulenewline_or_eot, position220)
			}
			return true
		l219:
			position, tokenIndex = position219, tokenIndex219
			return false
		},
		/* 30 space <- <(' ' / '\t')+> */
		func() bool {
			position223, tokenIndex223 := position, tokenIndex
			{
				position224 := position
				{
					position227, tokenIndex227 := position, tokenIndex
					if buffer[position] != rune(' ') {
						goto l228
					}
					position++
					goto l227
				l228:
					position, tokenIndex = position227, tokenIndex227
					if buffer[position] != rune('\t') {
						goto l223
					}
					position++
				}
			l227:
			l225:
				{
					position226, tokenIndex226 := position, tokenIndex
					{
						position229, tokenIndex229 := position, tokenIndex
						if buffer[position] != rune(' ') {
							goto l230
						}
						position++
						goto l229
					l230:
						position, tokenIndex = position229, tokenIndex229
						if buffer[position] != rune('\t') {
							goto l226
						}
						position++
					}
				l229:
					goto l225
				l226:
					position, tokenIndex = position226, tokenIndex226
				}
				add(rulespace, position224)
			}
			return true
		l223:
			position, tokenIndex = position223, tokenIndex223
			return false
		},
		/* 31 string <- <(!('"' / '\t' / '\r' / '\n' / '/' / ':' / ',' / '[' / ']' / '{' / '}' / ' ') .)+> */
		func() bool {
			position231, tokenIndex231 := position, tokenIndex
			{
				position232 := position
				{
					position235, tokenIndex235 := position, tokenIndex
					{
						position236, tokenIndex236 := position, tokenIndex
						if buffer[position] != rune('"') {
							goto l237
						}
						position++
						goto l236
					l237:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('\t') {
							goto l238
						}
						position++
						goto l236
					l238:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('\r') {
							goto l239
						}
						position++
						goto l236
					l239:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('\n') {
							goto l240
						}
						position++
						goto l236
					l240:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('/') {
							goto l241
						}
						position++
						goto l236
					l241:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune(':') {
							goto l242
						}
						position++
						goto l236
					l242:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune(',') {
							goto l243
						}
						position++
						goto l236
					l243:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('[') {
							goto l244
						}
						position++
						goto l236
					l244:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune(']') {
							goto l245
						}
						position++
						goto l236
					l245:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('{') {
							goto l246
						}
						position++
						goto l236
					l246:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune('}') {
							goto l247
						}
						position++
						goto l236
					l247:
						position, tokenIndex = position236, tokenIndex236
						if buffer[position] != rune(' ') {
							goto l235
						}
						position++
					}
				l236:
					goto l231
				l235:
					position, tokenIndex = position235, tokenIndex235
				}
				if !matchDot() {
					goto l231
				}
			l233:
				{
					position234, tokenIndex234 := position, tokenIndex
					{
						position248, tokenIndex248 := position, tokenIndex
						{
							position249, tokenIndex249 := position, tokenIndex
							if buffer[position] != rune('"') {
								goto l250
							}
							position++
							goto l249
						l250:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('\t') {
								goto l251
							}
							position++
							goto l249
						l251:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('\r') {
								goto l252
							}
							position++
							goto l249
						l252:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('\n') {
								goto l253
							}
							position++
							goto l249
						l253:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('/') {
								goto l254
							}
							position++
							goto l249
						l254:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune(':') {
								goto l255
							}
							position++
							goto l249
						l255:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune(',') {
								goto l256
							}
							position++
							goto l249
						l256:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('[') {
								goto l257
							}
							position++
							goto l249
						l257:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune(']') {
								goto l258
							}
							position++
							goto l249
						l258:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('{') {
								goto l259
							}
							position++
							goto l249
						l259:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune('}') {
								goto l260
							}
							position++
							goto l249
						l260:
							position, tokenIndex = position249, tokenIndex249
							if buffer[position] != rune(' ') {
								goto l248
							}
							position++
						}
					l249:
						goto l234
					l248:
						position, tokenIndex = position248, tokenIndex248
					}
					if !matchDot() {
						goto l234
					}
					goto l233
				l234:
					position, tokenIndex = position234, tokenIndex234
				}
				add(rulestring, position232)
			}
			return true
		l231:
			position, tokenIndex = position231, tokenIndex231
			return false
		},
		/* 32 string_in_quote <- <(!('"' / '\t' / '\r' / '\n') .)+> */
		func() bool {
			position261, tokenIndex261 := position, tokenIndex
			{
				position262 := position
				{
					position265, tokenIndex265 := position, tokenIndex
					{
						position266, tokenIndex266 := position, tokenIndex
						if buffer[position] != rune('"') {
							goto l267
						}
						position++
						goto l266
					l267:
						position, tokenIndex = position266, tokenIndex266
						if buffer[position] != rune('\t') {
							goto l268
						}
						position++
						goto l266
					l268:
						position, tokenIndex = position266, tokenIndex266
						if buffer[position] != rune('\r') {
							goto l269
						}
						position++
						goto l266
					l269:
						position, tokenIndex = position266, tokenIndex266
						if buffer[position] != rune('\n') {
							goto l265
						}
						position++
					}
				l266:
					goto l261
				l265:
					position, tokenIndex = position265, tokenIndex265
				}
				if !matchDot() {
					goto l261
				}
			l263:
				{
					position264, tokenIndex264 := position, tokenIndex
					{
						position270, tokenIndex270 := position, tokenIndex
						{
							position271, tokenIndex271 := position, tokenIndex
							if buffer[position] != rune('"') {
								goto l272
							}
							position++
							goto l271
						l272:
							position, tokenIndex = position271, tokenIndex271
							if buffer[position] != rune('\t') {
								goto l273
							}
							position++
							goto l271
						l273:
							position, tokenIndex = position271, tokenIndex271
							if buffer[position] != rune('\r') {
								goto l274
							}
							position++
							goto l271
						l274:
							position, tokenIndex = position271, tokenIndex271
							if buffer[position] != rune('\n') {
								goto l270
							}
							position++
						}
					l271:
						goto l264
					l270:
						position, tokenIndex = position270, tokenIndex270
					}
					if !matchDot() {
						goto l264
					}
					goto l263
				l264:
					position, tokenIndex = position264, tokenIndex264
				}
				add(rulestring_in_quote, position262)
			}
			return true
		l261:
			position, tokenIndex = position261, tokenIndex261
			return false
		},
		/* 33 cardinality <- <('0' / '1' / '?' / '*' / '+')> */
		func() bool {
			position275, tokenIndex275 := position, tokenIndex
			{
				position276 := position
				{
					position277, tokenIndex277 := position, tokenIndex
					if buffer[position] != rune('0') {
						goto l278
					}
					position++
					goto l277
				l278:
					position, tokenIndex = position277, tokenIndex277
					if buffer[position] != rune('1') {
						goto l279
					}
					position++
					goto l277
				l279:
					position, tokenIndex = position277, tokenIndex277
					if buffer[position] != rune('?') {
						goto l280
					}
					position++
					goto l277
				l280:
					position, tokenIndex = position277, tokenIndex277
					if buffer[position] != rune('*') {
						goto l281
					}
					position++
					goto l277
				l281:
					position, tokenIndex = position277, tokenIndex277
					if buffer[position] != rune('+') {
						goto l275
					}
					position++
				}
			l277:
				add(rulecardinality, position276)
			}
			return true
		l275:
			position, tokenIndex = position275, tokenIndex275
			return false
		},
		nil,
		/* 36 Action0 <- <{p.Err(begin, buffer)}> */
		func() bool {
			{
				add(ruleAction0, position)
			}
			return true
		},
		/* 37 Action1 <- <{p.Err(begin, buffer)}> */
		func() bool {
			{
				add(ruleAction1, position)
			}
			return true
		},
		/* 38 Action2 <- <{ p.ClearTableAndColumn() }> */
		func() bool {
			{
				add(ruleAction2, position)
			}
			return true
		},
		/* 39 Action3 <- <{ p.AddColorDefine() }> */
		func() bool {
			{
				add(ruleAction3, position)
			}
			return true
		},
		/* 40 Action4 <- <{ p.AddTable(text) }> */
		func() bool {
			{
				add(ruleAction4, position)
			}
			return true
		},
		/* 41 Action5 <- <{ p.AddColumn(text) }> */
		func() bool {
			{
				add(ruleAction5, position)
			}
			return true
		},
		/* 42 Action6 <- <{ p.AddRelation() }> */
		func() bool {
			{
				add(ruleAction6, position)
			}
			return true
		},
		/* 43 Action7 <- <{ p.SetRelationLeft(text) }> */
		func() bool {
			{
				add(ruleAction7, position)
			}
			return true
		},
		/* 44 Action8 <- <{ p.SetCardinalityLeft(text)}> */
		func() bool {
			{
				add(ruleAction8, position)
			}
			return true
		},
		/* 45 Action9 <- <{ p.SetRelationRight(text) }> */
		func() bool {
			{
				add(ruleAction9, position)
			}
			return true
		},
		/* 46 Action10 <- <{ p.SetCardinalityRight(text)}> */
		func() bool {
			{
				add(ruleAction10, position)
			}
			return true
		},
		/* 47 Action11 <- <{ p.AddTitleKeyValue() }> */
		func() bool {
			{
				add(ruleAction11, position)
			}
			return true
		},
		/* 48 Action12 <- <{ p.AddTableKeyValue() }> */
		func() bool {
			{
				add(ruleAction12, position)
			}
			return true
		},
		/* 49 Action13 <- <{ p.AddColumnKeyValue() }> */
		func() bool {
			{
				add(ruleAction13, position)
			}
			return true
		},
		/* 50 Action14 <- <{ p.AddRelationKeyValue() }> */
		func() bool {
			{
				add(ruleAction14, position)
			}
			return true
		},
		/* 51 Action15 <- <{ p.SetKey(text) }> */
		func() bool {
			{
				add(ruleAction15, position)
			}
			return true
		},
		/* 52 Action16 <- <{ p.SetValue(text) }> */
		func() bool {
			{
				add(ruleAction16, position)
			}
			return true
		},
		/* 53 Action17 <- <{ p.SetValue(text) }> */
		func() bool {
			{
				add(ruleAction17, position)
			}
			return true
		},
	}
	p.rules = _rules
	return nil
}