vendor/github.com/tendermint/tmlibs/pubsub/query/query.peg.go

   1 // nolint
   2 package query
   3
   4 import (
   5         "fmt"
   6         "math"
   7         "sort"
   8         "strconv"
   9 )
  10
  11 const endSymbol rune = 1114112
  12
  13 /* The rule types inferred from the grammar are below. */
  14 type pegRule uint8
  15
  16 const (
  17         ruleUnknown pegRule = iota
  18         rulee
  19         rulecondition
  20         ruletag
  21         rulevalue
  22         rulenumber
  23         ruledigit
  24         ruletime
  25         ruledate
  26         ruleyear
  27         rulemonth
  28         ruleday
  29         ruleand
  30         ruleequal
  31         rulecontains
  32         rulele
  33         rulege
  34         rulel
  35         ruleg
  36         rulePegText
  37 )
  38
  39 var rul3s = [...]string{
  40         "Unknown",
  41         "e",
  42         "condition",
  43         "tag",
  44         "value",
  45         "number",
  46         "digit",
  47         "time",
  48         "date",
  49         "year",
  50         "month",
  51         "day",
  52         "and",
  53         "equal",
  54         "contains",
  55         "le",
  56         "ge",
  57         "l",
  58         "g",
  59         "PegText",
  60 }
  61
  62 type token32 struct {
  63         pegRule
  64         begin, end uint32
  65 }
  66
  67 func (t *token32) String() string {
  68         return fmt.Sprintf("\x1B[34m%v\x1B[m %v %v", rul3s[t.pegRule], t.begin, t.end)
  69 }
  70
  71 type node32 struct {
  72         token32
  73         up, next *node32
  74 }
  75
  76 func (node *node32) print(pretty bool, buffer string) {
  77         var print func(node *node32, depth int)
  78         print = func(node *node32, depth int) {
  79                 for node != nil {
  80                         for c := 0; c < depth; c++ {
  81                                 fmt.Printf(" ")
  82                         }
  83                         rule := rul3s[node.pegRule]
  84                         quote := strconv.Quote(string(([]rune(buffer)[node.begin:node.end])))
  85                         if !pretty {
  86                                 fmt.Printf("%v %v\n", rule, quote)
  87                         } else {
  88                                 fmt.Printf("\x1B[34m%v\x1B[m %v\n", rule, quote)
  89                         }
  90                         if node.up != nil {
  91                                 print(node.up, depth+1)
  92                         }
  93                         node = node.next
  94                 }
  95         }
  96         print(node, 0)
  97 }
  98
  99 func (node *node32) Print(buffer string) {
 100         node.print(false, buffer)
 101 }
 102
 103 func (node *node32) PrettyPrint(buffer string) {
 104         node.print(true, buffer)
 105 }
 106
 107 type tokens32 struct {
 108         tree []token32
 109 }
 110
 111 func (t *tokens32) Trim(length uint32) {
 112         t.tree = t.tree[:length]
 113 }
 114
 115 func (t *tokens32) Print() {
 116         for _, token := range t.tree {
 117                 fmt.Println(token.String())
 118         }
 119 }
 120
 121 func (t *tokens32) AST() *node32 {
 122         type element struct {
 123                 node *node32
 124                 down *element
 125         }
 126         tokens := t.Tokens()
 127         var stack *element
 128         for _, token := range tokens {
 129                 if token.begin == token.end {
 130                         continue
 131                 }
 132                 node := &node32{token32: token}
 133                 for stack != nil && stack.node.begin >= token.begin && stack.node.end <= token.end {
 134                         stack.node.next = node.up
 135                         node.up = stack.node
 136                         stack = stack.down
 137                 }
 138                 stack = &element{node: node, down: stack}
 139         }
 140         if stack != nil {
 141                 return stack.node
 142         }
 143         return nil
 144 }
 145
 146 func (t *tokens32) PrintSyntaxTree(buffer string) {
 147         t.AST().Print(buffer)
 148 }
 149
 150 func (t *tokens32) PrettyPrintSyntaxTree(buffer string) {
 151         t.AST().PrettyPrint(buffer)
 152 }
 153
 154 func (t *tokens32) Add(rule pegRule, begin, end, index uint32) {
 155         if tree := t.tree; int(index) >= len(tree) {
 156                 expanded := make([]token32, 2*len(tree))
 157                 copy(expanded, tree)
 158                 t.tree = expanded
 159         }
 160         t.tree[index] = token32{
 161                 pegRule: rule,
 162                 begin:   begin,
 163                 end:     end,
 164         }
 165 }
 166
 167 func (t *tokens32) Tokens() []token32 {
 168         return t.tree
 169 }
 170
 171 type QueryParser struct {
 172         Buffer string
 173         buffer []rune
 174         rules  [20]func() bool
 175         parse  func(rule ...int) error
 176         reset  func()
 177         Pretty bool
 178         tokens32
 179 }
 180
 181 func (p *QueryParser) Parse(rule ...int) error {
 182         return p.parse(rule...)
 183 }
 184
 185 func (p *QueryParser) Reset() {
 186         p.reset()
 187 }
 188
 189 type textPosition struct {
 190         line, symbol int
 191 }
 192
 193 type textPositionMap map[int]textPosition
 194
 195 func translatePositions(buffer []rune, positions []int) textPositionMap {
 196         length, translations, j, line, symbol := len(positions), make(textPositionMap, len(positions)), 0, 1, 0
 197         sort.Ints(positions)
 198
 199 search:
 200         for i, c := range buffer {
 201                 if c == '\n' {
 202                         line, symbol = line+1, 0
 203                 } else {
 204                         symbol++
 205                 }
 206                 if i == positions[j] {
 207                         translations[positions[j]] = textPosition{line, symbol}
 208                         for j++; j < length; j++ {
 209                                 if i != positions[j] {
 210                                         continue search
 211                                 }
 212                         }
 213                         break search
 214                 }
 215         }
 216
 217         return translations
 218 }
 219
 220 type parseError struct {
 221         p   *QueryParser
 222         max token32
 223 }
 224
 225 func (e *parseError) Error() string {
 226         tokens, error := []token32{e.max}, "\n"
 227         positions, p := make([]int, 2*len(tokens)), 0
 228         for _, token := range tokens {
 229                 positions[p], p = int(token.begin), p+1
 230                 positions[p], p = int(token.end), p+1
 231         }
 232         translations := translatePositions(e.p.buffer, positions)
 233         format := "parse error near %v (line %v symbol %v - line %v symbol %v):\n%v\n"
 234         if e.p.Pretty {
 235                 format = "parse error near \x1B[34m%v\x1B[m (line %v symbol %v - line %v symbol %v):\n%v\n"
 236         }
 237         for _, token := range tokens {
 238                 begin, end := int(token.begin), int(token.end)
 239                 error += fmt.Sprintf(format,
 240                         rul3s[token.pegRule],
 241                         translations[begin].line, translations[begin].symbol,
 242                         translations[end].line, translations[end].symbol,
 243                         strconv.Quote(string(e.p.buffer[begin:end])))
 244         }
 245
 246         return error
 247 }
 248
 249 func (p *QueryParser) PrintSyntaxTree() {
 250         if p.Pretty {
 251                 p.tokens32.PrettyPrintSyntaxTree(p.Buffer)
 252         } else {
 253                 p.tokens32.PrintSyntaxTree(p.Buffer)
 254         }
 255 }
 256
 257 func (p *QueryParser) Init() {
 258         var (
 259                 max                  token32
 260                 position, tokenIndex uint32
 261                 buffer               []rune
 262         )
 263         p.reset = func() {
 264                 max = token32{}
 265                 position, tokenIndex = 0, 0
 266
 267                 p.buffer = []rune(p.Buffer)
 268                 if len(p.buffer) == 0 || p.buffer[len(p.buffer)-1] != endSymbol {
 269                         p.buffer = append(p.buffer, endSymbol)
 270                 }
 271                 buffer = p.buffer
 272         }
 273         p.reset()
 274
 275         _rules := p.rules
 276         tree := tokens32{tree: make([]token32, math.MaxInt16)}
 277         p.parse = func(rule ...int) error {
 278                 r := 1
 279                 if len(rule) > 0 {
 280                         r = rule[0]
 281                 }
 282                 matches := p.rules[r]()
 283                 p.tokens32 = tree
 284                 if matches {
 285                         p.Trim(tokenIndex)
 286                         return nil
 287                 }
 288                 return &parseError{p, max}
 289         }
 290
 291         add := func(rule pegRule, begin uint32) {
 292                 tree.Add(rule, begin, position, tokenIndex)
 293                 tokenIndex++
 294                 if begin != position && position > max.end {
 295                         max = token32{rule, begin, position}
 296                 }
 297         }
 298
 299         matchDot := func() bool {
 300                 if buffer[position] != endSymbol {
 301                         position++
 302                         return true
 303                 }
 304                 return false
 305         }
 306
 307         /*matchChar := func(c byte) bool {
 308                 if buffer[position] == c {
 309                         position++
 310                         return true
 311                 }
 312                 return false
 313         }*/
 314
 315         /*matchRange := func(lower byte, upper byte) bool {
 316                 if c := buffer[position]; c >= lower && c <= upper {
 317                         position++
 318                         return true
 319                 }
 320                 return false
 321         }*/
 322
 323         _rules = [...]func() bool{
 324                 nil,
 325                 /* 0 e <- <('"' condition (' '+ and ' '+ condition)* '"' !.)> */
 326                 func() bool {
 327                         position0, tokenIndex0 := position, tokenIndex
 328                         {
 329                                 position1 := position
 330                                 if buffer[position] != rune('"') {
 331                                         goto l0
 332                                 }
 333                                 position++
 334                                 if !_rules[rulecondition]() {
 335                                         goto l0
 336                                 }
 337                         l2:
 338                                 {
 339                                         position3, tokenIndex3 := position, tokenIndex
 340                                         if buffer[position] != rune(' ') {
 341                                                 goto l3
 342                                         }
 343                                         position++
 344                                 l4:
 345                                         {
 346                                                 position5, tokenIndex5 := position, tokenIndex
 347                                                 if buffer[position] != rune(' ') {
 348                                                         goto l5
 349                                                 }
 350                                                 position++
 351                                                 goto l4
 352                                         l5:
 353                                                 position, tokenIndex = position5, tokenIndex5
 354                                         }
 355                                         {
 356                                                 position6 := position
 357                                                 {
 358                                                         position7, tokenIndex7 := position, tokenIndex
 359                                                         if buffer[position] != rune('a') {
 360                                                                 goto l8
 361                                                         }
 362                                                         position++
 363                                                         goto l7
 364                                                 l8:
 365                                                         position, tokenIndex = position7, tokenIndex7
 366                                                         if buffer[position] != rune('A') {
 367                                                                 goto l3
 368                                                         }
 369                                                         position++
 370                                                 }
 371                                         l7:
 372                                                 {
 373                                                         position9, tokenIndex9 := position, tokenIndex
 374                                                         if buffer[position] != rune('n') {
 375                                                                 goto l10
 376                                                         }
 377                                                         position++
 378                                                         goto l9
 379                                                 l10:
 380                                                         position, tokenIndex = position9, tokenIndex9
 381                                                         if buffer[position] != rune('N') {
 382                                                                 goto l3
 383                                                         }
 384                                                         position++
 385                                                 }
 386                                         l9:
 387                                                 {
 388                                                         position11, tokenIndex11 := position, tokenIndex
 389                                                         if buffer[position] != rune('d') {
 390                                                                 goto l12
 391                                                         }
 392                                                         position++
 393                                                         goto l11
 394                                                 l12:
 395                                                         position, tokenIndex = position11, tokenIndex11
 396                                                         if buffer[position] != rune('D') {
 397                                                                 goto l3
 398                                                         }
 399                                                         position++
 400                                                 }
 401                                         l11:
 402                                                 add(ruleand, position6)
 403                                         }
 404                                         if buffer[position] != rune(' ') {
 405                                                 goto l3
 406                                         }
 407                                         position++
 408                                 l13:
 409                                         {
 410                                                 position14, tokenIndex14 := position, tokenIndex
 411                                                 if buffer[position] != rune(' ') {
 412                                                         goto l14
 413                                                 }
 414                                                 position++
 415                                                 goto l13
 416                                         l14:
 417                                                 position, tokenIndex = position14, tokenIndex14
 418                                         }
 419                                         if !_rules[rulecondition]() {
 420                                                 goto l3
 421                                         }
 422                                         goto l2
 423                                 l3:
 424                                         position, tokenIndex = position3, tokenIndex3
 425                                 }
 426                                 if buffer[position] != rune('"') {
 427                                         goto l0
 428                                 }
 429                                 position++
 430                                 {
 431                                         position15, tokenIndex15 := position, tokenIndex
 432                                         if !matchDot() {
 433                                                 goto l15
 434                                         }
 435                                         goto l0
 436                                 l15:
 437                                         position, tokenIndex = position15, tokenIndex15
 438                                 }
 439                                 add(rulee, position1)
 440                         }
 441                         return true
 442                 l0:
 443                         position, tokenIndex = position0, tokenIndex0
 444                         return false
 445                 },
 446                 /* 1 condition <- <(tag ' '* ((le ' '* ((&('D' | 'd') date) | (&('T' | 't') time) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') number))) / (ge ' '* ((&('D' | 'd') date) | (&('T' | 't') time) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') number))) / ((&('=') (equal ' '* ((&('\'') value) | (&('D' | 'd') date) | (&('T' | 't') time) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') number)))) | (&('>') (g ' '* ((&('D' | 'd') date) | (&('T' | 't') time) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') number)))) | (&('<') (l ' '* ((&('D' | 'd') date) | (&('T' | 't') time) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') number)))) | (&('C' | 'c') (contains ' '* value)))))> */
 447                 func() bool {
 448                         position16, tokenIndex16 := position, tokenIndex
 449                         {
 450                                 position17 := position
 451                                 {
 452                                         position18 := position
 453                                         {
 454                                                 position19 := position
 455                                                 {
 456                                                         position22, tokenIndex22 := position, tokenIndex
 457                                                         {
 458                                                                 switch buffer[position] {
 459                                                                 case '<':
 460                                                                         if buffer[position] != rune('<') {
 461                                                                                 goto l22
 462                                                                         }
 463                                                                         position++
 464                                                                         break
 465                                                                 case '>':
 466                                                                         if buffer[position] != rune('>') {
 467                                                                                 goto l22
 468                                                                         }
 469                                                                         position++
 470                                                                         break
 471                                                                 case '=':
 472                                                                         if buffer[position] != rune('=') {
 473                                                                                 goto l22
 474                                                                         }
 475                                                                         position++
 476                                                                         break
 477                                                                 case '\'':
 478                                                                         if buffer[position] != rune('\'') {
 479                                                                                 goto l22
 480                                                                         }
 481                                                                         position++
 482                                                                         break
 483                                                                 case '"':
 484                                                                         if buffer[position] != rune('"') {
 485                                                                                 goto l22
 486                                                                         }
 487                                                                         position++
 488                                                                         break
 489                                                                 case ')':
 490                                                                         if buffer[position] != rune(')') {
 491                                                                                 goto l22
 492                                                                         }
 493                                                                         position++
 494                                                                         break
 495                                                                 case '(':
 496                                                                         if buffer[position] != rune('(') {
 497                                                                                 goto l22
 498                                                                         }
 499                                                                         position++
 500                                                                         break
 501                                                                 case '\\':
 502                                                                         if buffer[position] != rune('\\') {
 503                                                                                 goto l22
 504                                                                         }
 505                                                                         position++
 506                                                                         break
 507                                                                 case '\r':
 508                                                                         if buffer[position] != rune('\r') {
 509                                                                                 goto l22
 510                                                                         }
 511                                                                         position++
 512                                                                         break
 513                                                                 case '\n':
 514                                                                         if buffer[position] != rune('\n') {
 515                                                                                 goto l22
 516                                                                         }
 517                                                                         position++
 518                                                                         break
 519                                                                 case '\t':
 520                                                                         if buffer[position] != rune('\t') {
 521                                                                                 goto l22
 522                                                                         }
 523                                                                         position++
 524                                                                         break
 525                                                                 default:
 526                                                                         if buffer[position] != rune(' ') {
 527                                                                                 goto l22
 528                                                                         }
 529                                                                         position++
 530                                                                         break
 531                                                                 }
 532                                                         }
 533
 534                                                         goto l16
 535                                                 l22:
 536                                                         position, tokenIndex = position22, tokenIndex22
 537                                                 }
 538                                                 if !matchDot() {
 539                                                         goto l16
 540                                                 }
 541                                         l20:
 542                                                 {
 543                                                         position21, tokenIndex21 := position, tokenIndex
 544                                                         {
 545                                                                 position24, tokenIndex24 := position, tokenIndex
 546                                                                 {
 547                                                                         switch buffer[position] {
 548                                                                         case '<':
 549                                                                                 if buffer[position] != rune('<') {
 550                                                                                         goto l24
 551                                                                                 }
 552                                                                                 position++
 553                                                                                 break
 554                                                                         case '>':
 555                                                                                 if buffer[position] != rune('>') {
 556                                                                                         goto l24
 557                                                                                 }
 558                                                                                 position++
 559                                                                                 break
 560                                                                         case '=':
 561                                                                                 if buffer[position] != rune('=') {
 562                                                                                         goto l24
 563                                                                                 }
 564                                                                                 position++
 565                                                                                 break
 566                                                                         case '\'':
 567                                                                                 if buffer[position] != rune('\'') {
 568                                                                                         goto l24
 569                                                                                 }
 570                                                                                 position++
 571                                                                                 break
 572                                                                         case '"':
 573                                                                                 if buffer[position] != rune('"') {
 574                                                                                         goto l24
 575                                                                                 }
 576                                                                                 position++
 577                                                                                 break
 578                                                                         case ')':
 579                                                                                 if buffer[position] != rune(')') {
 580                                                                                         goto l24
 581                                                                                 }
 582                                                                                 position++
 583                                                                                 break
 584                                                                         case '(':
 585                                                                                 if buffer[position] != rune('(') {
 586                                                                                         goto l24
 587                                                                                 }
 588                                                                                 position++
 589                                                                                 break
 590                                                                         case '\\':
 591                                                                                 if buffer[position] != rune('\\') {
 592                                                                                         goto l24
 593                                                                                 }
 594                                                                                 position++
 595                                                                                 break
 596                                                                         case '\r':
 597                                                                                 if buffer[position] != rune('\r') {
 598                                                                                         goto l24
 599                                                                                 }
 600                                                                                 position++
 601                                                                                 break
 602                                                                         case '\n':
 603                                                                                 if buffer[position] != rune('\n') {
 604                                                                                         goto l24
 605                                                                                 }
 606                                                                                 position++
 607                                                                                 break
 608                                                                         case '\t':
 609                                                                                 if buffer[position] != rune('\t') {
 610                                                                                         goto l24
 611                                                                                 }
 612                                                                                 position++
 613                                                                                 break
 614                                                                         default:
 615                                                                                 if buffer[position] != rune(' ') {
 616                                                                                         goto l24
 617                                                                                 }
 618                                                                                 position++
 619                                                                                 break
 620                                                                         }
 621                                                                 }
 622
 623                                                                 goto l21
 624                                                         l24:
 625                                                                 position, tokenIndex = position24, tokenIndex24
 626                                                         }
 627                                                         if !matchDot() {
 628                                                                 goto l21
 629                                                         }
 630                                                         goto l20
 631                                                 l21:
 632                                                         position, tokenIndex = position21, tokenIndex21
 633                                                 }
 634                                                 add(rulePegText, position19)
 635                                         }
 636                                         add(ruletag, position18)
 637                                 }
 638                         l26:
 639                                 {
 640                                         position27, tokenIndex27 := position, tokenIndex
 641                                         if buffer[position] != rune(' ') {
 642                                                 goto l27
 643                                         }
 644                                         position++
 645                                         goto l26
 646                                 l27:
 647                                         position, tokenIndex = position27, tokenIndex27
 648                                 }
 649                                 {
 650                                         position28, tokenIndex28 := position, tokenIndex
 651                                         {
 652                                                 position30 := position
 653                                                 if buffer[position] != rune('<') {
 654                                                         goto l29
 655                                                 }
 656                                                 position++
 657                                                 if buffer[position] != rune('=') {
 658                                                         goto l29
 659                                                 }
 660                                                 position++
 661                                                 add(rulele, position30)
 662                                         }
 663                                 l31:
 664                                         {
 665                                                 position32, tokenIndex32 := position, tokenIndex
 666                                                 if buffer[position] != rune(' ') {
 667                                                         goto l32
 668                                                 }
 669                                                 position++
 670                                                 goto l31
 671                                         l32:
 672                                                 position, tokenIndex = position32, tokenIndex32
 673                                         }
 674                                         {
 675                                                 switch buffer[position] {
 676                                                 case 'D', 'd':
 677                                                         if !_rules[ruledate]() {
 678                                                                 goto l29
 679                                                         }
 680                                                         break
 681                                                 case 'T', 't':
 682                                                         if !_rules[ruletime]() {
 683                                                                 goto l29
 684                                                         }
 685                                                         break
 686                                                 default:
 687                                                         if !_rules[rulenumber]() {
 688                                                                 goto l29
 689                                                         }
 690                                                         break
 691                                                 }
 692                                         }
 693
 694                                         goto l28
 695                                 l29:
 696                                         position, tokenIndex = position28, tokenIndex28
 697                                         {
 698                                                 position35 := position
 699                                                 if buffer[position] != rune('>') {
 700                                                         goto l34
 701                                                 }
 702                                                 position++
 703                                                 if buffer[position] != rune('=') {
 704                                                         goto l34
 705                                                 }
 706                                                 position++
 707                                                 add(rulege, position35)
 708                                         }
 709                                 l36:
 710                                         {
 711                                                 position37, tokenIndex37 := position, tokenIndex
 712                                                 if buffer[position] != rune(' ') {
 713                                                         goto l37
 714                                                 }
 715                                                 position++
 716                                                 goto l36
 717                                         l37:
 718                                                 position, tokenIndex = position37, tokenIndex37
 719                                         }
 720                                         {
 721                                                 switch buffer[position] {
 722                                                 case 'D', 'd':
 723                                                         if !_rules[ruledate]() {
 724                                                                 goto l34
 725                                                         }
 726                                                         break
 727                                                 case 'T', 't':
 728                                                         if !_rules[ruletime]() {
 729                                                                 goto l34
 730                                                         }
 731                                                         break
 732                                                 default:
 733                                                         if !_rules[rulenumber]() {
 734                                                                 goto l34
 735                                                         }
 736                                                         break
 737                                                 }
 738                                         }
 739
 740                                         goto l28
 741                                 l34:
 742                                         position, tokenIndex = position28, tokenIndex28
 743                                         {
 744                                                 switch buffer[position] {
 745                                                 case '=':
 746                                                         {
 747                                                                 position40 := position
 748                                                                 if buffer[position] != rune('=') {
 749                                                                         goto l16
 750                                                                 }
 751                                                                 position++
 752                                                                 add(ruleequal, position40)
 753                                                         }
 754                                                 l41:
 755                                                         {
 756                                                                 position42, tokenIndex42 := position, tokenIndex
 757                                                                 if buffer[position] != rune(' ') {
 758                                                                         goto l42
 759                                                                 }
 760                                                                 position++
 761                                                                 goto l41
 762                                                         l42:
 763                                                                 position, tokenIndex = position42, tokenIndex42
 764                                                         }
 765                                                         {
 766                                                                 switch buffer[position] {
 767                                                                 case '\'':
 768                                                                         if !_rules[rulevalue]() {
 769                                                                                 goto l16
 770                                                                         }
 771                                                                         break
 772                                                                 case 'D', 'd':
 773                                                                         if !_rules[ruledate]() {
 774                                                                                 goto l16
 775                                                                         }
 776                                                                         break
 777                                                                 case 'T', 't':
 778                                                                         if !_rules[ruletime]() {
 779                                                                                 goto l16
 780                                                                         }
 781                                                                         break
 782                                                                 default:
 783                                                                         if !_rules[rulenumber]() {
 784                                                                                 goto l16
 785                                                                         }
 786                                                                         break
 787                                                                 }
 788                                                         }
 789
 790                                                         break
 791                                                 case '>':
 792                                                         {
 793                                                                 position44 := position
 794                                                                 if buffer[position] != rune('>') {
 795                                                                         goto l16
 796                                                                 }
 797                                                                 position++
 798                                                                 add(ruleg, position44)
 799                                                         }
 800                                                 l45:
 801                                                         {
 802                                                                 position46, tokenIndex46 := position, tokenIndex
 803                                                                 if buffer[position] != rune(' ') {
 804                                                                         goto l46
 805                                                                 }
 806                                                                 position++
 807                                                                 goto l45
 808                                                         l46:
 809                                                                 position, tokenIndex = position46, tokenIndex46
 810                                                         }
 811                                                         {
 812                                                                 switch buffer[position] {
 813                                                                 case 'D', 'd':
 814                                                                         if !_rules[ruledate]() {
 815                                                                                 goto l16
 816                                                                         }
 817                                                                         break
 818                                                                 case 'T', 't':
 819                                                                         if !_rules[ruletime]() {
 820                                                                                 goto l16
 821                                                                         }
 822                                                                         break
 823                                                                 default:
 824                                                                         if !_rules[rulenumber]() {
 825                                                                                 goto l16
 826                                                                         }
 827                                                                         break
 828                                                                 }
 829                                                         }
 830
 831                                                         break
 832                                                 case '<':
 833                                                         {
 834                                                                 position48 := position
 835                                                                 if buffer[position] != rune('<') {
 836                                                                         goto l16
 837                                                                 }
 838                                                                 position++
 839                                                                 add(rulel, position48)
 840                                                         }
 841                                                 l49:
 842                                                         {
 843                                                                 position50, tokenIndex50 := position, tokenIndex
 844                                                                 if buffer[position] != rune(' ') {
 845                                                                         goto l50
 846                                                                 }
 847                                                                 position++
 848                                                                 goto l49
 849                                                         l50:
 850                                                                 position, tokenIndex = position50, tokenIndex50
 851                                                         }
 852                                                         {
 853                                                                 switch buffer[position] {
 854                                                                 case 'D', 'd':
 855                                                                         if !_rules[ruledate]() {
 856                                                                                 goto l16
 857                                                                         }
 858                                                                         break
 859                                                                 case 'T', 't':
 860                                                                         if !_rules[ruletime]() {
 861                                                                                 goto l16
 862                                                                         }
 863                                                                         break
 864                                                                 default:
 865                                                                         if !_rules[rulenumber]() {
 866                                                                                 goto l16
 867                                                                         }
 868                                                                         break
 869                                                                 }
 870                                                         }
 871
 872                                                         break
 873                                                 default:
 874                                                         {
 875                                                                 position52 := position
 876                                                                 {
 877                                                                         position53, tokenIndex53 := position, tokenIndex
 878                                                                         if buffer[position] != rune('c') {
 879                                                                                 goto l54
 880                                                                         }
 881                                                                         position++
 882                                                                         goto l53
 883                                                                 l54:
 884                                                                         position, tokenIndex = position53, tokenIndex53
 885                                                                         if buffer[position] != rune('C') {
 886                                                                                 goto l16
 887                                                                         }
 888                                                                         position++
 889                                                                 }
 890                                                         l53:
 891                                                                 {
 892                                                                         position55, tokenIndex55 := position, tokenIndex
 893                                                                         if buffer[position] != rune('o') {
 894                                                                                 goto l56
 895                                                                         }
 896                                                                         position++
 897                                                                         goto l55
 898                                                                 l56:
 899                                                                         position, tokenIndex = position55, tokenIndex55
 900                                                                         if buffer[position] != rune('O') {
 901                                                                                 goto l16
 902                                                                         }
 903                                                                         position++
 904                                                                 }
 905                                                         l55:
 906                                                                 {
 907                                                                         position57, tokenIndex57 := position, tokenIndex
 908                                                                         if buffer[position] != rune('n') {
 909                                                                                 goto l58
 910                                                                         }
 911                                                                         position++
 912                                                                         goto l57
 913                                                                 l58:
 914                                                                         position, tokenIndex = position57, tokenIndex57
 915                                                                         if buffer[position] != rune('N') {
 916                                                                                 goto l16
 917                                                                         }
 918                                                                         position++
 919                                                                 }
 920                                                         l57:
 921                                                                 {
 922                                                                         position59, tokenIndex59 := position, tokenIndex
 923                                                                         if buffer[position] != rune('t') {
 924                                                                                 goto l60
 925                                                                         }
 926                                                                         position++
 927                                                                         goto l59
 928                                                                 l60:
 929                                                                         position, tokenIndex = position59, tokenIndex59
 930                                                                         if buffer[position] != rune('T') {
 931                                                                                 goto l16
 932                                                                         }
 933                                                                         position++
 934                                                                 }
 935                                                         l59:
 936                                                                 {
 937                                                                         position61, tokenIndex61 := position, tokenIndex
 938                                                                         if buffer[position] != rune('a') {
 939                                                                                 goto l62
 940                                                                         }
 941                                                                         position++
 942                                                                         goto l61
 943                                                                 l62:
 944                                                                         position, tokenIndex = position61, tokenIndex61
 945                                                                         if buffer[position] != rune('A') {
 946                                                                                 goto l16
 947                                                                         }
 948                                                                         position++
 949                                                                 }
 950                                                         l61:
 951                                                                 {
 952                                                                         position63, tokenIndex63 := position, tokenIndex
 953                                                                         if buffer[position] != rune('i') {
 954                                                                                 goto l64
 955                                                                         }
 956                                                                         position++
 957                                                                         goto l63
 958                                                                 l64:
 959                                                                         position, tokenIndex = position63, tokenIndex63
 960                                                                         if buffer[position] != rune('I') {
 961                                                                                 goto l16
 962                                                                         }
 963                                                                         position++
 964                                                                 }
 965                                                         l63:
 966                                                                 {
 967                                                                         position65, tokenIndex65 := position, tokenIndex
 968                                                                         if buffer[position] != rune('n') {
 969                                                                                 goto l66
 970                                                                         }
 971                                                                         position++
 972                                                                         goto l65
 973                                                                 l66:
 974                                                                         position, tokenIndex = position65, tokenIndex65
 975                                                                         if buffer[position] != rune('N') {
 976                                                                                 goto l16
 977                                                                         }
 978                                                                         position++
 979                                                                 }
 980                                                         l65:
 981                                                                 {
 982                                                                         position67, tokenIndex67 := position, tokenIndex
 983                                                                         if buffer[position] != rune('s') {
 984                                                                                 goto l68
 985                                                                         }
 986                                                                         position++
 987                                                                         goto l67
 988                                                                 l68:
 989                                                                         position, tokenIndex = position67, tokenIndex67
 990                                                                         if buffer[position] != rune('S') {
 991                                                                                 goto l16
 992                                                                         }
 993                                                                         position++
 994                                                                 }
 995                                                         l67:
 996                                                                 add(rulecontains, position52)
 997                                                         }
 998                                                 l69:
 999                                                         {
1000                                                                 position70, tokenIndex70 := position, tokenIndex
1001                                                                 if buffer[position] != rune(' ') {
1002                                                                         goto l70
1003                                                                 }
1004                                                                 position++
1005                                                                 goto l69
1006                                                         l70:
1007                                                                 position, tokenIndex = position70, tokenIndex70
1008                                                         }
1009                                                         if !_rules[rulevalue]() {
1010                                                                 goto l16
1011                                                         }
1012                                                         break
1013                                                 }
1014                                         }
1015
1016                                 }
1017                         l28:
1018                                 add(rulecondition, position17)
1019                         }
1020                         return true
1021                 l16:
1022                         position, tokenIndex = position16, tokenIndex16
1023                         return false
1024                 },
1025                 /* 2 tag <- <<(!((&('<') '<') | (&('>') '>') | (&('=') '=') | (&('\'') '\'') | (&('"') '"') | (&(')') ')') | (&('(') '(') | (&('\\') '\\') | (&('\r') '\r') | (&('\n') '\n') | (&('\t') '\t') | (&(' ') ' ')) .)+>> */
1026                 nil,
1027                 /* 3 value <- <<('\'' (!('"' / '\'') .)* '\'')>> */
1028                 func() bool {
1029                         position72, tokenIndex72 := position, tokenIndex
1030                         {
1031                                 position73 := position
1032                                 {
1033                                         position74 := position
1034                                         if buffer[position] != rune('\'') {
1035                                                 goto l72
1036                                         }
1037                                         position++
1038                                 l75:
1039                                         {
1040                                                 position76, tokenIndex76 := position, tokenIndex
1041                                                 {
1042                                                         position77, tokenIndex77 := position, tokenIndex
1043                                                         {
1044                                                                 position78, tokenIndex78 := position, tokenIndex
1045                                                                 if buffer[position] != rune('"') {
1046                                                                         goto l79
1047                                                                 }
1048                                                                 position++
1049                                                                 goto l78
1050                                                         l79:
1051                                                                 position, tokenIndex = position78, tokenIndex78
1052                                                                 if buffer[position] != rune('\'') {
1053                                                                         goto l77
1054                                                                 }
1055                                                                 position++
1056                                                         }
1057                                                 l78:
1058                                                         goto l76
1059                                                 l77:
1060                                                         position, tokenIndex = position77, tokenIndex77
1061                                                 }
1062                                                 if !matchDot() {
1063                                                         goto l76
1064                                                 }
1065                                                 goto l75
1066                                         l76:
1067                                                 position, tokenIndex = position76, tokenIndex76
1068                                         }
1069                                         if buffer[position] != rune('\'') {
1070                                                 goto l72
1071                                         }
1072                                         position++
1073                                         add(rulePegText, position74)
1074                                 }
1075                                 add(rulevalue, position73)
1076                         }
1077                         return true
1078                 l72:
1079                         position, tokenIndex = position72, tokenIndex72
1080                         return false
1081                 },
1082                 /* 4 number <- <<('0' / ([1-9] digit* ('.' digit*)?))>> */
1083                 func() bool {
1084                         position80, tokenIndex80 := position, tokenIndex
1085                         {
1086                                 position81 := position
1087                                 {
1088                                         position82 := position
1089                                         {
1090                                                 position83, tokenIndex83 := position, tokenIndex
1091                                                 if buffer[position] != rune('0') {
1092                                                         goto l84
1093                                                 }
1094                                                 position++
1095                                                 goto l83
1096                                         l84:
1097                                                 position, tokenIndex = position83, tokenIndex83
1098                                                 if c := buffer[position]; c < rune('1') || c > rune('9') {
1099                                                         goto l80
1100                                                 }
1101                                                 position++
1102                                         l85:
1103                                                 {
1104                                                         position86, tokenIndex86 := position, tokenIndex
1105                                                         if !_rules[ruledigit]() {
1106                                                                 goto l86
1107                                                         }
1108                                                         goto l85
1109                                                 l86:
1110                                                         position, tokenIndex = position86, tokenIndex86
1111                                                 }
1112                                                 {
1113                                                         position87, tokenIndex87 := position, tokenIndex
1114                                                         if buffer[position] != rune('.') {
1115                                                                 goto l87
1116                                                         }
1117                                                         position++
1118                                                 l89:
1119                                                         {
1120                                                                 position90, tokenIndex90 := position, tokenIndex
1121                                                                 if !_rules[ruledigit]() {
1122                                                                         goto l90
1123                                                                 }
1124                                                                 goto l89
1125                                                         l90:
1126                                                                 position, tokenIndex = position90, tokenIndex90
1127                                                         }
1128                                                         goto l88
1129                                                 l87:
1130                                                         position, tokenIndex = position87, tokenIndex87
1131                                                 }
1132                                         l88:
1133                                         }
1134                                 l83:
1135                                         add(rulePegText, position82)
1136                                 }
1137                                 add(rulenumber, position81)
1138                         }
1139                         return true
1140                 l80:
1141                         position, tokenIndex = position80, tokenIndex80
1142                         return false
1143                 },
1144                 /* 5 digit <- <[0-9]> */
1145                 func() bool {
1146                         position91, tokenIndex91 := position, tokenIndex
1147                         {
1148                                 position92 := position
1149                                 if c := buffer[position]; c < rune('0') || c > rune('9') {
1150                                         goto l91
1151                                 }
1152                                 position++
1153                                 add(ruledigit, position92)
1154                         }
1155                         return true
1156                 l91:
1157                         position, tokenIndex = position91, tokenIndex91
1158                         return false
1159                 },
1160                 /* 6 time <- <(('t' / 'T') ('i' / 'I') ('m' / 'M') ('e' / 'E') ' ' <(year '-' month '-' day 'T' digit digit ':' digit digit ':' digit digit ((('-' / '+') digit digit ':' digit digit) / 'Z'))>)> */
1161                 func() bool {
1162                         position93, tokenIndex93 := position, tokenIndex
1163                         {
1164                                 position94 := position
1165                                 {
1166                                         position95, tokenIndex95 := position, tokenIndex
1167                                         if buffer[position] != rune('t') {
1168                                                 goto l96
1169                                         }
1170                                         position++
1171                                         goto l95
1172                                 l96:
1173                                         position, tokenIndex = position95, tokenIndex95
1174                                         if buffer[position] != rune('T') {
1175                                                 goto l93
1176                                         }
1177                                         position++
1178                                 }
1179                         l95:
1180                                 {
1181                                         position97, tokenIndex97 := position, tokenIndex
1182                                         if buffer[position] != rune('i') {
1183                                                 goto l98
1184                                         }
1185                                         position++
1186                                         goto l97
1187                                 l98:
1188                                         position, tokenIndex = position97, tokenIndex97
1189                                         if buffer[position] != rune('I') {
1190                                                 goto l93
1191                                         }
1192                                         position++
1193                                 }
1194                         l97:
1195                                 {
1196                                         position99, tokenIndex99 := position, tokenIndex
1197                                         if buffer[position] != rune('m') {
1198                                                 goto l100
1199                                         }
1200                                         position++
1201                                         goto l99
1202                                 l100:
1203                                         position, tokenIndex = position99, tokenIndex99
1204                                         if buffer[position] != rune('M') {
1205                                                 goto l93
1206                                         }
1207                                         position++
1208                                 }
1209                         l99:
1210                                 {
1211                                         position101, tokenIndex101 := position, tokenIndex
1212                                         if buffer[position] != rune('e') {
1213                                                 goto l102
1214                                         }
1215                                         position++
1216                                         goto l101
1217                                 l102:
1218                                         position, tokenIndex = position101, tokenIndex101
1219                                         if buffer[position] != rune('E') {
1220                                                 goto l93
1221                                         }
1222                                         position++
1223                                 }
1224                         l101:
1225                                 if buffer[position] != rune(' ') {
1226                                         goto l93
1227                                 }
1228                                 position++
1229                                 {
1230                                         position103 := position
1231                                         if !_rules[ruleyear]() {
1232                                                 goto l93
1233                                         }
1234                                         if buffer[position] != rune('-') {
1235                                                 goto l93
1236                                         }
1237                                         position++
1238                                         if !_rules[rulemonth]() {
1239                                                 goto l93
1240                                         }
1241                                         if buffer[position] != rune('-') {
1242                                                 goto l93
1243                                         }
1244                                         position++
1245                                         if !_rules[ruleday]() {
1246                                                 goto l93
1247                                         }
1248                                         if buffer[position] != rune('T') {
1249                                                 goto l93
1250                                         }
1251                                         position++
1252                                         if !_rules[ruledigit]() {
1253                                                 goto l93
1254                                         }
1255                                         if !_rules[ruledigit]() {
1256                                                 goto l93
1257                                         }
1258                                         if buffer[position] != rune(':') {
1259                                                 goto l93
1260                                         }
1261                                         position++
1262                                         if !_rules[ruledigit]() {
1263                                                 goto l93
1264                                         }
1265                                         if !_rules[ruledigit]() {
1266                                                 goto l93
1267                                         }
1268                                         if buffer[position] != rune(':') {
1269                                                 goto l93
1270                                         }
1271                                         position++
1272                                         if !_rules[ruledigit]() {
1273                                                 goto l93
1274                                         }
1275                                         if !_rules[ruledigit]() {
1276                                                 goto l93
1277                                         }
1278                                         {
1279                                                 position104, tokenIndex104 := position, tokenIndex
1280                                                 {
1281                                                         position106, tokenIndex106 := position, tokenIndex
1282                                                         if buffer[position] != rune('-') {
1283                                                                 goto l107
1284                                                         }
1285                                                         position++
1286                                                         goto l106
1287                                                 l107:
1288                                                         position, tokenIndex = position106, tokenIndex106
1289                                                         if buffer[position] != rune('+') {
1290                                                                 goto l105
1291                                                         }
1292                                                         position++
1293                                                 }
1294                                         l106:
1295                                                 if !_rules[ruledigit]() {
1296                                                         goto l105
1297                                                 }
1298                                                 if !_rules[ruledigit]() {
1299                                                         goto l105
1300                                                 }
1301                                                 if buffer[position] != rune(':') {
1302                                                         goto l105
1303                                                 }
1304                                                 position++
1305                                                 if !_rules[ruledigit]() {
1306                                                         goto l105
1307                                                 }
1308                                                 if !_rules[ruledigit]() {
1309                                                         goto l105
1310                                                 }
1311                                                 goto l104
1312                                         l105:
1313                                                 position, tokenIndex = position104, tokenIndex104
1314                                                 if buffer[position] != rune('Z') {
1315                                                         goto l93
1316                                                 }
1317                                                 position++
1318                                         }
1319                                 l104:
1320                                         add(rulePegText, position103)
1321                                 }
1322                                 add(ruletime, position94)
1323                         }
1324                         return true
1325                 l93:
1326                         position, tokenIndex = position93, tokenIndex93
1327                         return false
1328                 },
1329                 /* 7 date <- <(('d' / 'D') ('a' / 'A') ('t' / 'T') ('e' / 'E') ' ' <(year '-' month '-' day)>)> */
1330                 func() bool {
1331                         position108, tokenIndex108 := position, tokenIndex
1332                         {
1333                                 position109 := position
1334                                 {
1335                                         position110, tokenIndex110 := position, tokenIndex
1336                                         if buffer[position] != rune('d') {
1337                                                 goto l111
1338                                         }
1339                                         position++
1340                                         goto l110
1341                                 l111:
1342                                         position, tokenIndex = position110, tokenIndex110
1343                                         if buffer[position] != rune('D') {
1344                                                 goto l108
1345                                         }
1346                                         position++
1347                                 }
1348                         l110:
1349                                 {
1350                                         position112, tokenIndex112 := position, tokenIndex
1351                                         if buffer[position] != rune('a') {
1352                                                 goto l113
1353                                         }
1354                                         position++
1355                                         goto l112
1356                                 l113:
1357                                         position, tokenIndex = position112, tokenIndex112
1358                                         if buffer[position] != rune('A') {
1359                                                 goto l108
1360                                         }
1361                                         position++
1362                                 }
1363                         l112:
1364                                 {
1365                                         position114, tokenIndex114 := position, tokenIndex
1366                                         if buffer[position] != rune('t') {
1367                                                 goto l115
1368                                         }
1369                                         position++
1370                                         goto l114
1371                                 l115:
1372                                         position, tokenIndex = position114, tokenIndex114
1373                                         if buffer[position] != rune('T') {
1374                                                 goto l108
1375                                         }
1376                                         position++
1377                                 }
1378                         l114:
1379                                 {
1380                                         position116, tokenIndex116 := position, tokenIndex
1381                                         if buffer[position] != rune('e') {
1382                                                 goto l117
1383                                         }
1384                                         position++
1385                                         goto l116
1386                                 l117:
1387                                         position, tokenIndex = position116, tokenIndex116
1388                                         if buffer[position] != rune('E') {
1389                                                 goto l108
1390                                         }
1391                                         position++
1392                                 }
1393                         l116:
1394                                 if buffer[position] != rune(' ') {
1395                                         goto l108
1396                                 }
1397                                 position++
1398                                 {
1399                                         position118 := position
1400                                         if !_rules[ruleyear]() {
1401                                                 goto l108
1402                                         }
1403                                         if buffer[position] != rune('-') {
1404                                                 goto l108
1405                                         }
1406                                         position++
1407                                         if !_rules[rulemonth]() {
1408                                                 goto l108
1409                                         }
1410                                         if buffer[position] != rune('-') {
1411                                                 goto l108
1412                                         }
1413                                         position++
1414                                         if !_rules[ruleday]() {
1415                                                 goto l108
1416                                         }
1417                                         add(rulePegText, position118)
1418                                 }
1419                                 add(ruledate, position109)
1420                         }
1421                         return true
1422                 l108:
1423                         position, tokenIndex = position108, tokenIndex108
1424                         return false
1425                 },
1426                 /* 8 year <- <(('1' / '2') digit digit digit)> */
1427                 func() bool {
1428                         position119, tokenIndex119 := position, tokenIndex
1429                         {
1430                                 position120 := position
1431                                 {
1432                                         position121, tokenIndex121 := position, tokenIndex
1433                                         if buffer[position] != rune('1') {
1434                                                 goto l122
1435                                         }
1436                                         position++
1437                                         goto l121
1438                                 l122:
1439                                         position, tokenIndex = position121, tokenIndex121
1440                                         if buffer[position] != rune('2') {
1441                                                 goto l119
1442                                         }
1443                                         position++
1444                                 }
1445                         l121:
1446                                 if !_rules[ruledigit]() {
1447                                         goto l119
1448                                 }
1449                                 if !_rules[ruledigit]() {
1450                                         goto l119
1451                                 }
1452                                 if !_rules[ruledigit]() {
1453                                         goto l119
1454                                 }
1455                                 add(ruleyear, position120)
1456                         }
1457                         return true
1458                 l119:
1459                         position, tokenIndex = position119, tokenIndex119
1460                         return false
1461                 },
1462                 /* 9 month <- <(('0' / '1') digit)> */
1463                 func() bool {
1464                         position123, tokenIndex123 := position, tokenIndex
1465                         {
1466                                 position124 := position
1467                                 {
1468                                         position125, tokenIndex125 := position, tokenIndex
1469                                         if buffer[position] != rune('0') {
1470                                                 goto l126
1471                                         }
1472                                         position++
1473                                         goto l125
1474                                 l126:
1475                                         position, tokenIndex = position125, tokenIndex125
1476                                         if buffer[position] != rune('1') {
1477                                                 goto l123
1478                                         }
1479                                         position++
1480                                 }
1481                         l125:
1482                                 if !_rules[ruledigit]() {
1483                                         goto l123
1484                                 }
1485                                 add(rulemonth, position124)
1486                         }
1487                         return true
1488                 l123:
1489                         position, tokenIndex = position123, tokenIndex123
1490                         return false
1491                 },
1492                 /* 10 day <- <(((&('3') '3') | (&('2') '2') | (&('1') '1') | (&('0') '0')) digit)> */
1493                 func() bool {
1494                         position127, tokenIndex127 := position, tokenIndex
1495                         {
1496                                 position128 := position
1497                                 {
1498                                         switch buffer[position] {
1499                                         case '3':
1500                                                 if buffer[position] != rune('3') {
1501                                                         goto l127
1502                                                 }
1503                                                 position++
1504                                                 break
1505                                         case '2':
1506                                                 if buffer[position] != rune('2') {
1507                                                         goto l127
1508                                                 }
1509                                                 position++
1510                                                 break
1511                                         case '1':
1512                                                 if buffer[position] != rune('1') {
1513                                                         goto l127
1514                                                 }
1515                                                 position++
1516                                                 break
1517                                         default:
1518                                                 if buffer[position] != rune('0') {
1519                                                         goto l127
1520                                                 }
1521                                                 position++
1522                                                 break
1523                                         }
1524                                 }
1525
1526                                 if !_rules[ruledigit]() {
1527                                         goto l127
1528                                 }
1529                                 add(ruleday, position128)
1530                         }
1531                         return true
1532                 l127:
1533                         position, tokenIndex = position127, tokenIndex127
1534                         return false
1535                 },
1536                 /* 11 and <- <(('a' / 'A') ('n' / 'N') ('d' / 'D'))> */
1537                 nil,
1538                 /* 12 equal <- <'='> */
1539                 nil,
1540                 /* 13 contains <- <(('c' / 'C') ('o' / 'O') ('n' / 'N') ('t' / 'T') ('a' / 'A') ('i' / 'I') ('n' / 'N') ('s' / 'S'))> */
1541                 nil,
1542                 /* 14 le <- <('<' '=')> */
1543                 nil,
1544                 /* 15 ge <- <('>' '=')> */
1545                 nil,
1546                 /* 16 l <- <'<'> */
1547                 nil,
1548                 /* 17 g <- <'>'> */
1549                 nil,
1550                 nil,
1551         }
1552         p.rules = _rules
1553 }