1package query 2 3import __yyfmt__ "fmt" 4 5//line query_string.y:2 6import ( 7 "fmt" 8 "strconv" 9 "strings" 10 "time" 11) 12 13func logDebugGrammar(format string, v ...interface{}) { 14 if debugParser { 15 logger.Printf(format, v...) 16 } 17} 18 19//line query_string.y:17 20type yySymType struct { 21 yys int 22 s string 23 n int 24 f float64 25 q Query 26 pf *float64 27} 28 29const tSTRING = 57346 30const tPHRASE = 57347 31const tPLUS = 57348 32const tMINUS = 57349 33const tCOLON = 57350 34const tBOOST = 57351 35const tNUMBER = 57352 36const tGREATER = 57353 37const tLESS = 57354 38const tEQUAL = 57355 39const tTILDE = 57356 40 41var yyToknames = [...]string{ 42 "$end", 43 "error", 44 "$unk", 45 "tSTRING", 46 "tPHRASE", 47 "tPLUS", 48 "tMINUS", 49 "tCOLON", 50 "tBOOST", 51 "tNUMBER", 52 "tGREATER", 53 "tLESS", 54 "tEQUAL", 55 "tTILDE", 56} 57var yyStatenames = [...]string{} 58 59const yyEofCode = 1 60const yyErrCode = 2 61const yyInitialStackSize = 16 62 63//line yacctab:1 64var yyExca = [...]int{ 65 -1, 1, 66 1, -1, 67 -2, 0, 68 -1, 3, 69 1, 3, 70 -2, 5, 71} 72 73const yyNprod = 28 74const yyPrivate = 57344 75 76var yyTokenNames []string 77var yyStates []string 78 79const yyLast = 42 80 81var yyAct = [...]int{ 82 83 17, 16, 18, 23, 22, 30, 3, 21, 19, 20, 84 29, 26, 22, 22, 1, 21, 21, 15, 28, 25, 85 24, 27, 34, 14, 22, 13, 31, 21, 32, 33, 86 22, 9, 11, 21, 5, 6, 2, 10, 4, 12, 87 7, 8, 88} 89var yyPact = [...]int{ 90 91 28, -1000, -1000, 28, 27, -1000, -1000, -1000, 16, 9, 92 -1000, -1000, -1000, -1000, -1000, -3, -11, -1000, -1000, 6, 93 5, -1000, -5, -1000, -1000, 23, -1000, -1000, 17, -1000, 94 -1000, -1000, -1000, -1000, -1000, 95} 96var yyPgo = [...]int{ 97 98 0, 0, 41, 39, 38, 14, 36, 6, 99} 100var yyR1 = [...]int{ 101 102 0, 5, 6, 6, 7, 4, 4, 4, 2, 2, 103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 104 2, 2, 2, 2, 3, 3, 1, 1, 105} 106var yyR2 = [...]int{ 107 108 0, 1, 2, 1, 3, 0, 1, 1, 1, 2, 109 4, 1, 1, 3, 3, 3, 4, 5, 4, 5, 110 4, 5, 4, 5, 0, 1, 1, 2, 111} 112var yyChk = [...]int{ 113 114 -1000, -5, -6, -7, -4, 6, 7, -6, -2, 4, 115 10, 5, -3, 9, 14, 8, 4, -1, 5, 11, 116 12, 10, 7, 14, -1, 13, 5, -1, 13, 5, 117 10, -1, 5, -1, 5, 118} 119var yyDef = [...]int{ 120 121 5, -2, 1, -2, 0, 6, 7, 2, 24, 8, 122 11, 12, 4, 25, 9, 0, 13, 14, 15, 0, 123 0, 26, 0, 10, 16, 0, 20, 18, 0, 22, 124 27, 17, 21, 19, 23, 125} 126var yyTok1 = [...]int{ 127 128 1, 129} 130var yyTok2 = [...]int{ 131 132 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 133 12, 13, 14, 134} 135var yyTok3 = [...]int{ 136 0, 137} 138 139var yyErrorMessages = [...]struct { 140 state int 141 token int 142 msg string 143}{} 144 145//line yaccpar:1 146 147/* parser for yacc output */ 148 149var ( 150 yyDebug = 0 151 yyErrorVerbose = false 152) 153 154type yyLexer interface { 155 Lex(lval *yySymType) int 156 Error(s string) 157} 158 159type yyParser interface { 160 Parse(yyLexer) int 161 Lookahead() int 162} 163 164type yyParserImpl struct { 165 lval yySymType 166 stack [yyInitialStackSize]yySymType 167 char int 168} 169 170func (p *yyParserImpl) Lookahead() int { 171 return p.char 172} 173 174func yyNewParser() yyParser { 175 return &yyParserImpl{} 176} 177 178const yyFlag = -1000 179 180func yyTokname(c int) string { 181 if c >= 1 && c-1 < len(yyToknames) { 182 if yyToknames[c-1] != "" { 183 return yyToknames[c-1] 184 } 185 } 186 return __yyfmt__.Sprintf("tok-%v", c) 187} 188 189func yyStatname(s int) string { 190 if s >= 0 && s < len(yyStatenames) { 191 if yyStatenames[s] != "" { 192 return yyStatenames[s] 193 } 194 } 195 return __yyfmt__.Sprintf("state-%v", s) 196} 197 198func yyErrorMessage(state, lookAhead int) string { 199 const TOKSTART = 4 200 201 if !yyErrorVerbose { 202 return "syntax error" 203 } 204 205 for _, e := range yyErrorMessages { 206 if e.state == state && e.token == lookAhead { 207 return "syntax error: " + e.msg 208 } 209 } 210 211 res := "syntax error: unexpected " + yyTokname(lookAhead) 212 213 // To match Bison, suggest at most four expected tokens. 214 expected := make([]int, 0, 4) 215 216 // Look for shiftable tokens. 217 base := yyPact[state] 218 for tok := TOKSTART; tok-1 < len(yyToknames); tok++ { 219 if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok { 220 if len(expected) == cap(expected) { 221 return res 222 } 223 expected = append(expected, tok) 224 } 225 } 226 227 if yyDef[state] == -2 { 228 i := 0 229 for yyExca[i] != -1 || yyExca[i+1] != state { 230 i += 2 231 } 232 233 // Look for tokens that we accept or reduce. 234 for i += 2; yyExca[i] >= 0; i += 2 { 235 tok := yyExca[i] 236 if tok < TOKSTART || yyExca[i+1] == 0 { 237 continue 238 } 239 if len(expected) == cap(expected) { 240 return res 241 } 242 expected = append(expected, tok) 243 } 244 245 // If the default action is to accept or reduce, give up. 246 if yyExca[i+1] != 0 { 247 return res 248 } 249 } 250 251 for i, tok := range expected { 252 if i == 0 { 253 res += ", expecting " 254 } else { 255 res += " or " 256 } 257 res += yyTokname(tok) 258 } 259 return res 260} 261 262func yylex1(lex yyLexer, lval *yySymType) (char, token int) { 263 token = 0 264 char = lex.Lex(lval) 265 if char <= 0 { 266 token = yyTok1[0] 267 goto out 268 } 269 if char < len(yyTok1) { 270 token = yyTok1[char] 271 goto out 272 } 273 if char >= yyPrivate { 274 if char < yyPrivate+len(yyTok2) { 275 token = yyTok2[char-yyPrivate] 276 goto out 277 } 278 } 279 for i := 0; i < len(yyTok3); i += 2 { 280 token = yyTok3[i+0] 281 if token == char { 282 token = yyTok3[i+1] 283 goto out 284 } 285 } 286 287out: 288 if token == 0 { 289 token = yyTok2[1] /* unknown char */ 290 } 291 if yyDebug >= 3 { 292 __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char)) 293 } 294 return char, token 295} 296 297func yyParse(yylex yyLexer) int { 298 return yyNewParser().Parse(yylex) 299} 300 301func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int { 302 var yyn int 303 var yyVAL yySymType 304 var yyDollar []yySymType 305 _ = yyDollar // silence set and not used 306 yyS := yyrcvr.stack[:] 307 308 Nerrs := 0 /* number of errors */ 309 Errflag := 0 /* error recovery flag */ 310 yystate := 0 311 yyrcvr.char = -1 312 yytoken := -1 // yyrcvr.char translated into internal numbering 313 defer func() { 314 // Make sure we report no lookahead when not parsing. 315 yystate = -1 316 yyrcvr.char = -1 317 yytoken = -1 318 }() 319 yyp := -1 320 goto yystack 321 322ret0: 323 return 0 324 325ret1: 326 return 1 327 328yystack: 329 /* put a state and value onto the stack */ 330 if yyDebug >= 4 { 331 __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate)) 332 } 333 334 yyp++ 335 if yyp >= len(yyS) { 336 nyys := make([]yySymType, len(yyS)*2) 337 copy(nyys, yyS) 338 yyS = nyys 339 } 340 yyS[yyp] = yyVAL 341 yyS[yyp].yys = yystate 342 343yynewstate: 344 yyn = yyPact[yystate] 345 if yyn <= yyFlag { 346 goto yydefault /* simple state */ 347 } 348 if yyrcvr.char < 0 { 349 yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) 350 } 351 yyn += yytoken 352 if yyn < 0 || yyn >= yyLast { 353 goto yydefault 354 } 355 yyn = yyAct[yyn] 356 if yyChk[yyn] == yytoken { /* valid shift */ 357 yyrcvr.char = -1 358 yytoken = -1 359 yyVAL = yyrcvr.lval 360 yystate = yyn 361 if Errflag > 0 { 362 Errflag-- 363 } 364 goto yystack 365 } 366 367yydefault: 368 /* default state action */ 369 yyn = yyDef[yystate] 370 if yyn == -2 { 371 if yyrcvr.char < 0 { 372 yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) 373 } 374 375 /* look through exception table */ 376 xi := 0 377 for { 378 if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate { 379 break 380 } 381 xi += 2 382 } 383 for xi += 2; ; xi += 2 { 384 yyn = yyExca[xi+0] 385 if yyn < 0 || yyn == yytoken { 386 break 387 } 388 } 389 yyn = yyExca[xi+1] 390 if yyn < 0 { 391 goto ret0 392 } 393 } 394 if yyn == 0 { 395 /* error ... attempt to resume parsing */ 396 switch Errflag { 397 case 0: /* brand new error */ 398 yylex.Error(yyErrorMessage(yystate, yytoken)) 399 Nerrs++ 400 if yyDebug >= 1 { 401 __yyfmt__.Printf("%s", yyStatname(yystate)) 402 __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken)) 403 } 404 fallthrough 405 406 case 1, 2: /* incompletely recovered error ... try again */ 407 Errflag = 3 408 409 /* find a state where "error" is a legal shift action */ 410 for yyp >= 0 { 411 yyn = yyPact[yyS[yyp].yys] + yyErrCode 412 if yyn >= 0 && yyn < yyLast { 413 yystate = yyAct[yyn] /* simulate a shift of "error" */ 414 if yyChk[yystate] == yyErrCode { 415 goto yystack 416 } 417 } 418 419 /* the current p has no shift on "error", pop stack */ 420 if yyDebug >= 2 { 421 __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys) 422 } 423 yyp-- 424 } 425 /* there is no state on the stack with an error shift ... abort */ 426 goto ret1 427 428 case 3: /* no shift yet; clobber input char */ 429 if yyDebug >= 2 { 430 __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken)) 431 } 432 if yytoken == yyEofCode { 433 goto ret1 434 } 435 yyrcvr.char = -1 436 yytoken = -1 437 goto yynewstate /* try again in the same state */ 438 } 439 } 440 441 /* reduction by production yyn */ 442 if yyDebug >= 2 { 443 __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate)) 444 } 445 446 yynt := yyn 447 yypt := yyp 448 _ = yypt // guard against "declared and not used" 449 450 yyp -= yyR2[yyn] 451 // yyp is now the index of $0. Perform the default action. Iff the 452 // reduced production is ε, $1 is possibly out of range. 453 if yyp+1 >= len(yyS) { 454 nyys := make([]yySymType, len(yyS)*2) 455 copy(nyys, yyS) 456 yyS = nyys 457 } 458 yyVAL = yyS[yyp+1] 459 460 /* consult goto table to find next state */ 461 yyn = yyR1[yyn] 462 yyg := yyPgo[yyn] 463 yyj := yyg + yyS[yyp].yys + 1 464 465 if yyj >= yyLast { 466 yystate = yyAct[yyg] 467 } else { 468 yystate = yyAct[yyj] 469 if yyChk[yystate] != -yyn { 470 yystate = yyAct[yyg] 471 } 472 } 473 // dummy call; replaced with literal code 474 switch yynt { 475 476 case 1: 477 yyDollar = yyS[yypt-1 : yypt+1] 478 //line query_string.y:40 479 { 480 logDebugGrammar("INPUT") 481 } 482 case 2: 483 yyDollar = yyS[yypt-2 : yypt+1] 484 //line query_string.y:45 485 { 486 logDebugGrammar("SEARCH PARTS") 487 } 488 case 3: 489 yyDollar = yyS[yypt-1 : yypt+1] 490 //line query_string.y:49 491 { 492 logDebugGrammar("SEARCH PART") 493 } 494 case 4: 495 yyDollar = yyS[yypt-3 : yypt+1] 496 //line query_string.y:54 497 { 498 query := yyDollar[2].q 499 if yyDollar[3].pf != nil { 500 if query, ok := query.(BoostableQuery); ok { 501 query.SetBoost(*yyDollar[3].pf) 502 } 503 } 504 switch yyDollar[1].n { 505 case queryShould: 506 yylex.(*lexerWrapper).query.AddShould(query) 507 case queryMust: 508 yylex.(*lexerWrapper).query.AddMust(query) 509 case queryMustNot: 510 yylex.(*lexerWrapper).query.AddMustNot(query) 511 } 512 } 513 case 5: 514 yyDollar = yyS[yypt-0 : yypt+1] 515 //line query_string.y:73 516 { 517 yyVAL.n = queryShould 518 } 519 case 6: 520 yyDollar = yyS[yypt-1 : yypt+1] 521 //line query_string.y:77 522 { 523 logDebugGrammar("PLUS") 524 yyVAL.n = queryMust 525 } 526 case 7: 527 yyDollar = yyS[yypt-1 : yypt+1] 528 //line query_string.y:82 529 { 530 logDebugGrammar("MINUS") 531 yyVAL.n = queryMustNot 532 } 533 case 8: 534 yyDollar = yyS[yypt-1 : yypt+1] 535 //line query_string.y:88 536 { 537 str := yyDollar[1].s 538 logDebugGrammar("STRING - %s", str) 539 var q FieldableQuery 540 if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") { 541 q = NewRegexpQuery(str[1 : len(str)-1]) 542 } else if strings.ContainsAny(str, "*?") { 543 q = NewWildcardQuery(str) 544 } else { 545 q = NewMatchQuery(str) 546 } 547 yyVAL.q = q 548 } 549 case 9: 550 yyDollar = yyS[yypt-2 : yypt+1] 551 //line query_string.y:102 552 { 553 str := yyDollar[1].s 554 fuzziness, err := strconv.ParseFloat(yyDollar[2].s, 64) 555 if err != nil { 556 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err)) 557 } 558 logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness) 559 q := NewMatchQuery(str) 560 q.SetFuzziness(int(fuzziness)) 561 yyVAL.q = q 562 } 563 case 10: 564 yyDollar = yyS[yypt-4 : yypt+1] 565 //line query_string.y:114 566 { 567 field := yyDollar[1].s 568 str := yyDollar[3].s 569 fuzziness, err := strconv.ParseFloat(yyDollar[4].s, 64) 570 if err != nil { 571 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err)) 572 } 573 logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness) 574 q := NewMatchQuery(str) 575 q.SetFuzziness(int(fuzziness)) 576 q.SetField(field) 577 yyVAL.q = q 578 } 579 case 11: 580 yyDollar = yyS[yypt-1 : yypt+1] 581 //line query_string.y:128 582 { 583 str := yyDollar[1].s 584 logDebugGrammar("STRING - %s", str) 585 q1 := NewMatchQuery(str) 586 val, err := strconv.ParseFloat(yyDollar[1].s, 64) 587 if err != nil { 588 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 589 } 590 inclusive := true 591 q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive) 592 q := NewDisjunctionQuery([]Query{q1, q2}) 593 q.queryStringMode = true 594 yyVAL.q = q 595 } 596 case 12: 597 yyDollar = yyS[yypt-1 : yypt+1] 598 //line query_string.y:143 599 { 600 phrase := yyDollar[1].s 601 logDebugGrammar("PHRASE - %s", phrase) 602 q := NewMatchPhraseQuery(phrase) 603 yyVAL.q = q 604 } 605 case 13: 606 yyDollar = yyS[yypt-3 : yypt+1] 607 //line query_string.y:150 608 { 609 field := yyDollar[1].s 610 str := yyDollar[3].s 611 logDebugGrammar("FIELD - %s STRING - %s", field, str) 612 var q FieldableQuery 613 if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") { 614 q = NewRegexpQuery(str[1 : len(str)-1]) 615 } else if strings.ContainsAny(str, "*?") { 616 q = NewWildcardQuery(str) 617 } else { 618 q = NewMatchQuery(str) 619 } 620 q.SetField(field) 621 yyVAL.q = q 622 } 623 case 14: 624 yyDollar = yyS[yypt-3 : yypt+1] 625 //line query_string.y:166 626 { 627 field := yyDollar[1].s 628 str := yyDollar[3].s 629 logDebugGrammar("FIELD - %s STRING - %s", field, str) 630 q1 := NewMatchQuery(str) 631 q1.SetField(field) 632 val, err := strconv.ParseFloat(yyDollar[3].s, 64) 633 if err != nil { 634 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 635 } 636 inclusive := true 637 q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive) 638 q2.SetField(field) 639 q := NewDisjunctionQuery([]Query{q1, q2}) 640 q.queryStringMode = true 641 yyVAL.q = q 642 } 643 case 15: 644 yyDollar = yyS[yypt-3 : yypt+1] 645 //line query_string.y:184 646 { 647 field := yyDollar[1].s 648 phrase := yyDollar[3].s 649 logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase) 650 q := NewMatchPhraseQuery(phrase) 651 q.SetField(field) 652 yyVAL.q = q 653 } 654 case 16: 655 yyDollar = yyS[yypt-4 : yypt+1] 656 //line query_string.y:193 657 { 658 field := yyDollar[1].s 659 min, err := strconv.ParseFloat(yyDollar[4].s, 64) 660 if err != nil { 661 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 662 } 663 minInclusive := false 664 logDebugGrammar("FIELD - GREATER THAN %f", min) 665 q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil) 666 q.SetField(field) 667 yyVAL.q = q 668 } 669 case 17: 670 yyDollar = yyS[yypt-5 : yypt+1] 671 //line query_string.y:206 672 { 673 field := yyDollar[1].s 674 min, err := strconv.ParseFloat(yyDollar[5].s, 64) 675 if err != nil { 676 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 677 } 678 minInclusive := true 679 logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min) 680 q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil) 681 q.SetField(field) 682 yyVAL.q = q 683 } 684 case 18: 685 yyDollar = yyS[yypt-4 : yypt+1] 686 //line query_string.y:219 687 { 688 field := yyDollar[1].s 689 max, err := strconv.ParseFloat(yyDollar[4].s, 64) 690 if err != nil { 691 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 692 } 693 maxInclusive := false 694 logDebugGrammar("FIELD - LESS THAN %f", max) 695 q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive) 696 q.SetField(field) 697 yyVAL.q = q 698 } 699 case 19: 700 yyDollar = yyS[yypt-5 : yypt+1] 701 //line query_string.y:232 702 { 703 field := yyDollar[1].s 704 max, err := strconv.ParseFloat(yyDollar[5].s, 64) 705 if err != nil { 706 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err)) 707 } 708 maxInclusive := true 709 logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max) 710 q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive) 711 q.SetField(field) 712 yyVAL.q = q 713 } 714 case 20: 715 yyDollar = yyS[yypt-4 : yypt+1] 716 //line query_string.y:245 717 { 718 field := yyDollar[1].s 719 minInclusive := false 720 phrase := yyDollar[4].s 721 722 logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase) 723 minTime, err := queryTimeFromString(phrase) 724 if err != nil { 725 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err)) 726 } 727 q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil) 728 q.SetField(field) 729 yyVAL.q = q 730 } 731 case 21: 732 yyDollar = yyS[yypt-5 : yypt+1] 733 //line query_string.y:260 734 { 735 field := yyDollar[1].s 736 minInclusive := true 737 phrase := yyDollar[5].s 738 739 logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase) 740 minTime, err := queryTimeFromString(phrase) 741 if err != nil { 742 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err)) 743 } 744 q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil) 745 q.SetField(field) 746 yyVAL.q = q 747 } 748 case 22: 749 yyDollar = yyS[yypt-4 : yypt+1] 750 //line query_string.y:275 751 { 752 field := yyDollar[1].s 753 maxInclusive := false 754 phrase := yyDollar[4].s 755 756 logDebugGrammar("FIELD - LESS THAN DATE %s", phrase) 757 maxTime, err := queryTimeFromString(phrase) 758 if err != nil { 759 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err)) 760 } 761 q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive) 762 q.SetField(field) 763 yyVAL.q = q 764 } 765 case 23: 766 yyDollar = yyS[yypt-5 : yypt+1] 767 //line query_string.y:290 768 { 769 field := yyDollar[1].s 770 maxInclusive := true 771 phrase := yyDollar[5].s 772 773 logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase) 774 maxTime, err := queryTimeFromString(phrase) 775 if err != nil { 776 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err)) 777 } 778 q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive) 779 q.SetField(field) 780 yyVAL.q = q 781 } 782 case 24: 783 yyDollar = yyS[yypt-0 : yypt+1] 784 //line query_string.y:306 785 { 786 yyVAL.pf = nil 787 } 788 case 25: 789 yyDollar = yyS[yypt-1 : yypt+1] 790 //line query_string.y:310 791 { 792 yyVAL.pf = nil 793 boost, err := strconv.ParseFloat(yyDollar[1].s, 64) 794 if err != nil { 795 yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err)) 796 } else { 797 yyVAL.pf = &boost 798 } 799 logDebugGrammar("BOOST %f", boost) 800 } 801 case 26: 802 yyDollar = yyS[yypt-1 : yypt+1] 803 //line query_string.y:322 804 { 805 yyVAL.s = yyDollar[1].s 806 } 807 case 27: 808 yyDollar = yyS[yypt-2 : yypt+1] 809 //line query_string.y:326 810 { 811 yyVAL.s = "-" + yyDollar[2].s 812 } 813 } 814 goto yystack /* stack new state and value */ 815} 816