LCOV - code coverage report
Current view: top level - queryparser - queryparser.lemony (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 1079 1130 95.5 %
Date: 2019-06-30 05:20:33 Functions: 91 91 100.0 %
Branches: 1329 1988 66.9 %

           Branch data     Line data    Source code
       1                 :            : %include {
       2                 :            : /* queryparser.lemony: build a Xapian::Query object from a user query string.
       3                 :            :  *
       4                 :            :  * Copyright (C) 2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2015,2016,2018,2019 Olly Betts
       5                 :            :  * Copyright (C) 2007,2008,2009 Lemur Consulting Ltd
       6                 :            :  * Copyright (C) 2010 Adam Sj√łgren
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or
       9                 :            :  * modify it under the terms of the GNU General Public License as
      10                 :            :  * published by the Free Software Foundation; either version 2 of the
      11                 :            :  * License, or (at your option) any later version.
      12                 :            :  *
      13                 :            :  * This program is distributed in the hope that it will be useful,
      14                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            :  * GNU General Public License for more details.
      17                 :            :  *
      18                 :            :  * You should have received a copy of the GNU General Public License
      19                 :            :  * along with this program; if not, write to the Free Software
      20                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
      21                 :            :  * USA
      22                 :            :  */
      23                 :            : 
      24                 :            : #include <config.h>
      25                 :            : 
      26                 :            : #include "queryparser_internal.h"
      27                 :            : 
      28                 :            : #include "api/queryinternal.h"
      29                 :            : #include "omassert.h"
      30                 :            : #include "str.h"
      31                 :            : #include "stringutils.h"
      32                 :            : #include "xapian/error.h"
      33                 :            : #include "xapian/unicode.h"
      34                 :            : 
      35                 :            : // Include the list of token values lemon generates.
      36                 :            : #include "queryparser_token.h"
      37                 :            : 
      38                 :            : #include "cjk-tokenizer.h"
      39                 :            : 
      40                 :            : #include <algorithm>
      41                 :            : #include <cstring>
      42                 :            : #include <limits>
      43                 :            : #include <list>
      44                 :            : #include <string>
      45                 :            : #include <vector>
      46                 :            : 
      47                 :            : // We create the yyParser on the stack.
      48                 :            : #define Parse_ENGINEALWAYSONSTACK
      49                 :            : 
      50                 :            : using namespace std;
      51                 :            : 
      52                 :            : using namespace Xapian;
      53                 :            : 
      54                 :            : static constexpr unsigned NO_EDIT_DISTANCE = unsigned(-1);
      55                 :            : static constexpr unsigned DEFAULT_EDIT_DISTANCE = 2;
      56                 :            : 
      57                 :            : inline bool
      58                 :      89644 : U_isupper(unsigned ch) {
      59 [ +  + ][ +  + ]:      89644 :     return (ch < 128 && C_isupper(static_cast<unsigned char>(ch)));
      60                 :            : }
      61                 :            : 
      62                 :            : inline bool
      63                 :         48 : U_isdigit(unsigned ch) {
      64 [ +  + ][ +  + ]:         48 :     return (ch < 128 && C_isdigit(static_cast<unsigned char>(ch)));
      65                 :            : }
      66                 :            : 
      67                 :            : inline bool
      68                 :      81257 : U_isalpha(unsigned ch) {
      69 [ +  + ][ +  + ]:      81257 :     return (ch < 128 && C_isalpha(static_cast<unsigned char>(ch)));
      70                 :            : }
      71                 :            : 
      72                 :            : using Xapian::Unicode::is_whitespace;
      73                 :            : 
      74                 :            : inline bool
      75                 :       1942 : is_not_whitespace(unsigned ch) {
      76                 :       1942 :     return !is_whitespace(ch);
      77                 :            : }
      78                 :            : 
      79                 :            : using Xapian::Unicode::is_wordchar;
      80                 :            : 
      81                 :            : inline bool
      82                 :      18813 : is_not_wordchar(unsigned ch) {
      83                 :      18813 :     return !is_wordchar(ch);
      84                 :            : }
      85                 :            : 
      86                 :            : inline bool
      87                 :      42837 : is_digit(unsigned ch) {
      88                 :      42837 :     return (Unicode::get_category(ch) == Unicode::DECIMAL_DIGIT_NUMBER);
      89                 :            : }
      90                 :            : 
      91                 :            : // FIXME: we used to keep trailing "-" (e.g. Cl-) but it's of dubious utility
      92                 :            : // and there's the risk of hyphens getting stuck onto the end of terms...
      93                 :            : //
      94                 :            : // There are currently assumptions below that this only matches ASCII
      95                 :            : // characters.
      96                 :            : inline bool
      97                 :      84583 : is_suffix(unsigned ch) {
      98 [ +  + ][ +  + ]:      84583 :     return ch == '+' || ch == '#';
      99                 :            : }
     100                 :            : 
     101                 :            : inline bool
     102                 :        531 : is_double_quote(unsigned ch) {
     103                 :            :     // We simply treat all double quotes as equivalent, which is a bit crude,
     104                 :            :     // but it isn't clear that it would actually better to require them to
     105                 :            :     // match up exactly.
     106                 :            :     //
     107                 :            :     // 0x201c is Unicode opening double quote.
     108                 :            :     // 0x201d is Unicode closing double quote.
     109 [ +  + ][ +  + ]:        531 :     return ch == '"' || ch == 0x201c || ch == 0x201d;
                 [ +  + ]
     110                 :            : }
     111                 :            : 
     112                 :            : inline bool
     113                 :        278 : prefix_needs_colon(const string & prefix, unsigned ch)
     114                 :            : {
     115 [ +  + ][ +  + ]:        278 :     if (!U_isupper(ch) && ch != ':') return false;
                 [ +  + ]
     116                 :          4 :     string::size_type len = prefix.length();
     117 [ +  - ][ +  - ]:          4 :     return (len > 1 && prefix[len - 1] != ':');
     118                 :            : }
     119                 :            : 
     120                 :            : using Unicode::is_currency;
     121                 :            : 
     122                 :            : inline bool
     123                 :       1170 : is_positional(Xapian::Query::op op)
     124                 :            : {
     125 [ +  + ][ +  + ]:       1170 :     return (op == Xapian::Query::OP_PHRASE || op == Xapian::Query::OP_NEAR);
     126                 :            : }
     127                 :            : 
     128                 :            : class Terms;
     129                 :            : 
     130                 :            : /** Class used to pass information about a token from lexer to parser.
     131                 :            :  *
     132                 :            :  *  Generally an instance of this class carries term information, but it can be
     133                 :            :  *  used for a range query, and with some operators (e.g. the distance in
     134                 :            :  *  NEAR/3 or ADJ/3, etc).
     135                 :            :  */
     136                 :     215884 : class Term {
     137                 :            :     State * state;
     138                 :            : 
     139                 :            :   public:
     140                 :            :     string name;
     141                 :            :     const FieldInfo * field_info;
     142                 :            :     string unstemmed;
     143                 :            :     QueryParser::stem_strategy stem;
     144                 :            :     termpos pos;
     145                 :            :     Query query;
     146                 :            :     unsigned edit_distance;
     147                 :            : 
     148                 :            :     Term(const string &name_, termpos pos_)
     149                 :            :         : name(name_), stem(QueryParser::STEM_NONE), pos(pos_) { }
     150                 :            :     explicit Term(const string &name_)
     151                 :            :         : name(name_), stem(QueryParser::STEM_NONE), pos(0) { }
     152                 :            :     Term(const string &name_, const FieldInfo * field_info_)
     153                 :            :         : name(name_), field_info(field_info_),
     154                 :            :           stem(QueryParser::STEM_NONE), pos(0) { }
     155         [ +  - ]:          4 :     explicit Term(termpos pos_) : stem(QueryParser::STEM_NONE), pos(pos_) { }
     156                 :      89267 :     Term(State * state_, const string &name_, const FieldInfo * field_info_,
     157                 :            :          const string &unstemmed_,
     158                 :            :          QueryParser::stem_strategy stem_ = QueryParser::STEM_NONE,
     159                 :            :          termpos pos_ = 0,
     160                 :            :          unsigned edit_distance_ = NO_EDIT_DISTANCE)
     161                 :            :         : state(state_), name(name_), field_info(field_info_),
     162                 :            :           unstemmed(unstemmed_), stem(stem_), pos(pos_),
     163         [ +  - ]:      89267 :           edit_distance(edit_distance_) { }
     164                 :            :     // For RANGE tokens.
     165                 :      18671 :     Term(const Xapian::Query & q, const string & grouping)
     166 [ +  - ][ +  - ]:      18671 :         : name(grouping), query(q) { }
     167                 :            : 
     168                 :            :     string make_term(const string & prefix) const;
     169                 :            : 
     170                 :       1235 :     void need_positions() {
     171         [ +  + ]:       1235 :         if (stem == QueryParser::STEM_SOME) stem = QueryParser::STEM_NONE;
     172                 :       1235 :     }
     173                 :            : 
     174                 :          8 :     termpos get_termpos() const { return pos; }
     175                 :            : 
     176                 :         98 :     string get_grouping() const {
     177                 :         98 :         return field_info->grouping;
     178                 :            :     }
     179                 :            : 
     180                 :            :     Query * as_fuzzy_query(State * state) const;
     181                 :            : 
     182                 :            :     Query * as_wildcarded_query(State * state) const;
     183                 :            : 
     184                 :            :     /** Build a query for a term at the very end of the query string when
     185                 :            :      *  FLAG_PARTIAL is in use.
     186                 :            :      *
     187                 :            :      *  This query should match documents containing any terms which start with
     188                 :            :      *  the characters specified, but should give a higher score to exact
     189                 :            :      *  matches (since the user might have finished typing - we simply don't
     190                 :            :      *  know).
     191                 :            :      */
     192                 :            :     Query * as_partial_query(State * state_) const;
     193                 :            : 
     194                 :            :     /** Build a query for a string of CJK characters. */
     195                 :            :     Query * as_cjk_query() const;
     196                 :            : 
     197                 :            :     /** Handle a CJK character string in a positional context. */
     198                 :            :     void as_positional_cjk_term(Terms * terms) const;
     199                 :            : 
     200                 :            :     /// Range query.
     201                 :            :     Query as_range_query() const;
     202                 :            : 
     203                 :            :     Query get_query() const;
     204                 :            : 
     205                 :            :     Query get_query_with_synonyms() const;
     206                 :            : 
     207                 :            :     Query get_query_with_auto_synonyms() const;
     208                 :            : };
     209                 :            : 
     210                 :            : /// Parser State shared between the lexer and the parser.
     211                 :     128918 : class State {
     212                 :            :     QueryParser::Internal * qpi;
     213                 :            : 
     214                 :            :   public:
     215                 :            :     Query query;
     216                 :            :     const char * error;
     217                 :            :     unsigned flags;
     218                 :            : 
     219                 :      64459 :     State(QueryParser::Internal * qpi_, unsigned flags_)
     220                 :      64459 :         : qpi(qpi_), error(NULL), flags(flags_) { }
     221                 :            : 
     222                 :       1810 :     string stem_term(const string &term) {
     223                 :       1810 :         return qpi->stemmer(term);
     224                 :            :     }
     225                 :            : 
     226                 :        158 :     void add_to_stoplist(const Term * term) {
     227                 :        158 :         qpi->stoplist.push_back(term->name);
     228                 :        158 :     }
     229                 :            : 
     230                 :      88609 :     void add_to_unstem(const string & term, const string & unstemmed) {
     231         [ +  - ]:      88609 :         qpi->unstem.insert(make_pair(term, unstemmed));
     232                 :      88609 :     }
     233                 :            : 
     234                 :      18684 :     Term * range(const string &a, const string &b) {
     235 [ +  - ][ +  + ]:      37451 :         for (auto i : qpi->rangeprocs) {
     236 [ +  - ][ +  + ]:      37534 :             Xapian::Query range_query = (i.proc)->check_range(a, b);
     237                 :      18767 :             Xapian::Query::op op = range_query.get_type();
     238   [ +  +  -  + ]:      18767 :             switch (op) {
     239                 :            :                 case Xapian::Query::OP_INVALID:
     240                 :         96 :                     break;
     241                 :            :                 case Xapian::Query::OP_VALUE_RANGE:
     242                 :            :                 case Xapian::Query::OP_VALUE_GE:
     243                 :            :                 case Xapian::Query::OP_VALUE_LE:
     244         [ +  - ]:       9519 :                     if (i.default_grouping) {
     245                 :            :                         Xapian::Internal::QueryValueBase * base =
     246                 :            :                             static_cast<Xapian::Internal::QueryValueBase*>(
     247                 :       9519 :                                 range_query.internal.get());
     248                 :       9519 :                         Xapian::valueno slot = base->get_slot();
     249 [ +  - ][ +  - ]:       9519 :                         return new Term(range_query, str(slot));
                 [ +  - ]
     250                 :            :                     }
     251                 :            :                     // FALLTHRU
     252                 :            :                 case Xapian::Query::LEAF_TERM:
     253 [ #  # ][ #  # ]:          0 :                     return new Term(range_query, i.grouping);
     254                 :            :                 default:
     255 [ +  - ][ +  - ]:      18767 :                     return new Term(range_query, string());
         [ +  - ][ +  + ]
     256                 :            :             }
     257                 :         96 :         }
     258                 :      18684 :         return NULL;
     259                 :            :     }
     260                 :            : 
     261                 :       4802 :     Query::op default_op() const { return qpi->default_op; }
     262                 :            : 
     263                 :        804 :     bool is_stopword(const Term *term) const {
     264 [ +  + ][ +  - ]:        804 :         return qpi->stopper.get() && (*qpi->stopper)(term->name);
     265                 :            :     }
     266                 :            : 
     267                 :      40122 :     Database get_database() const {
     268                 :      40122 :         return qpi->db;
     269                 :            :     }
     270                 :            : 
     271                 :        600 :     const Stopper * get_stopper() const {
     272                 :        600 :         return qpi->stopper.get();
     273                 :            :     }
     274                 :            : 
     275                 :        602 :     size_t stoplist_size() const {
     276                 :        602 :         return qpi->stoplist.size();
     277                 :            :     }
     278                 :            : 
     279                 :          2 :     void stoplist_resize(size_t s) {
     280                 :          2 :         qpi->stoplist.resize(s);
     281                 :          2 :     }
     282                 :            : 
     283                 :        376 :     Xapian::termcount get_max_wildcard_expansion() const {
     284                 :        376 :         return qpi->max_wildcard_expansion;
     285                 :            :     }
     286                 :            : 
     287                 :        376 :     int get_max_wildcard_type() const {
     288                 :        376 :         return qpi->max_wildcard_type;
     289                 :            :     }
     290                 :            : 
     291                 :        389 :     unsigned get_min_wildcard_prefix_len() const {
     292                 :        389 :         return qpi->min_wildcard_prefix_len;
     293                 :            :     }
     294                 :            : 
     295                 :        202 :     Xapian::termcount get_max_partial_expansion() const {
     296                 :        202 :         return qpi->max_partial_expansion;
     297                 :            :     }
     298                 :            : 
     299                 :        202 :     int get_max_partial_type() const {
     300                 :        202 :         return qpi->max_partial_type;
     301                 :            :     }
     302                 :            : 
     303                 :       4218 :     unsigned get_min_partial_prefix_len() const {
     304                 :       4218 :         return qpi->min_partial_prefix_len;
     305                 :            :     }
     306                 :            : 
     307                 :        103 :     Xapian::termcount get_max_fuzzy_expansion() const {
     308                 :        103 :         return qpi->max_fuzzy_expansion;
     309                 :            :     }
     310                 :            : 
     311                 :        103 :     int get_max_fuzzy_type() const {
     312                 :        103 :         return qpi->max_fuzzy_type;
     313                 :            :     }
     314                 :            : };
     315                 :            : 
     316                 :            : string
     317                 :      88609 : Term::make_term(const string & prefix) const
     318                 :            : {
     319                 :      88609 :     string term;
     320 [ +  + ][ +  + ]:      88609 :     if (stem != QueryParser::STEM_NONE && stem != QueryParser::STEM_ALL)
     321         [ +  - ]:       1741 :         term += 'Z';
     322         [ +  + ]:      88609 :     if (!prefix.empty()) {
     323         [ +  - ]:        274 :         term += prefix;
     324 [ +  + ][ +  - ]:        274 :         if (prefix_needs_colon(prefix, name[0])) term += ':';
     325                 :            :     }
     326         [ +  + ]:      88609 :     if (stem != QueryParser::STEM_NONE) {
     327 [ +  - ][ +  - ]:       1783 :         term += state->stem_term(name);
     328                 :            :     } else {
     329         [ +  - ]:      86826 :         term += name;
     330                 :            :     }
     331                 :            : 
     332         [ +  - ]:      88609 :     if (!unstemmed.empty())
     333         [ +  - ]:      88609 :         state->add_to_unstem(term, unstemmed);
     334                 :      88609 :     return term;
     335                 :            : }
     336                 :            : 
     337                 :            : // Iterator shim to allow building a synonym query from a TermIterator pair.
     338                 :     405232 : class SynonymIterator {
     339                 :            :     Xapian::TermIterator i;
     340                 :            : 
     341                 :            :     Xapian::termpos pos;
     342                 :            : 
     343                 :            :     const Xapian::Query * first;
     344                 :            : 
     345                 :            :   public:
     346                 :     101308 :     SynonymIterator(const Xapian::TermIterator & i_,
     347                 :            :                     Xapian::termpos pos_ = 0,
     348                 :            :                     const Xapian::Query * first_ = NULL)
     349                 :     101308 :         : i(i_), pos(pos_), first(first_) { }
     350                 :            : 
     351                 :      81304 :     SynonymIterator & operator++() {
     352         [ +  + ]:      81304 :         if (first)
     353                 :      50654 :             first = NULL;
     354                 :            :         else
     355                 :      30650 :             ++i;
     356                 :      81304 :         return *this;
     357                 :            :     }
     358                 :            : 
     359                 :      81304 :     const Xapian::Query operator*() const {
     360         [ +  + ]:      81304 :         if (first) return *first;
     361         [ +  - ]:      81304 :         return Xapian::Query(*i, 1, pos);
     362                 :            :     }
     363                 :            : 
     364                 :     182612 :     bool operator==(const SynonymIterator & o) const {
     365 [ +  + ][ +  + ]:     182612 :         return i == o.i && first == o.first;
     366                 :            :     }
     367                 :            : 
     368                 :     182612 :     bool operator!=(const SynonymIterator & o) const {
     369                 :     182612 :         return !(*this == o);
     370                 :            :     }
     371                 :            : 
     372                 :            :     typedef std::input_iterator_tag iterator_category;
     373                 :            :     typedef Xapian::Query value_type;
     374                 :            :     typedef Xapian::termcount_diff difference_type;
     375                 :            :     typedef Xapian::Query * pointer;
     376                 :            :     typedef Xapian::Query & reference;
     377                 :            : };
     378                 :            : 
     379                 :            : Query
     380                 :      40084 : Term::get_query_with_synonyms() const
     381                 :            : {
     382                 :            :     // Handle single-word synonyms with each prefix.
     383                 :      40084 :     const list<string> & prefixes = field_info->prefixes;
     384         [ -  + ]:      40084 :     if (prefixes.empty()) {
     385                 :            :         // FIXME: handle multiple here
     386                 :            :         Assert(!field_info->procs.empty());
     387         [ #  # ]:          0 :         return (**field_info->procs.begin())(name);
     388                 :            :     }
     389                 :            : 
     390         [ +  - ]:      40084 :     Query q = get_query();
     391                 :            : 
     392                 :      40084 :     list<string>::const_iterator piter;
     393         [ +  + ]:      80168 :     for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
     394                 :            :         // First try the unstemmed term:
     395         [ +  - ]:      40084 :         string term;
     396         [ +  + ]:      40084 :         if (!piter->empty()) {
     397         [ +  - ]:          2 :             term += *piter;
     398 [ -  + ][ #  # ]:          2 :             if (prefix_needs_colon(*piter, name[0])) term += ':';
     399                 :            :         }
     400         [ +  - ]:      40084 :         term += name;
     401                 :            : 
     402         [ +  - ]:      80168 :         Xapian::Database db = state->get_database();
     403         [ +  - ]:      80168 :         Xapian::TermIterator syn = db.synonyms_begin(term);
     404                 :      80168 :         Xapian::TermIterator end = db.synonyms_end(term);
     405 [ +  + ][ +  + ]:      40084 :         if (syn == end && stem != QueryParser::STEM_NONE) {
                 [ +  + ]
     406                 :            :             // If that has no synonyms, try the stemmed form:
     407         [ +  - ]:         27 :             term = 'Z';
     408         [ +  + ]:         27 :             if (!piter->empty()) {
     409         [ +  - ]:          2 :                 term += *piter;
     410 [ -  + ][ #  # ]:          2 :                 if (prefix_needs_colon(*piter, name[0])) term += ':';
     411                 :            :             }
     412 [ +  - ][ +  - ]:         27 :             term += state->stem_term(name);
     413 [ +  - ][ +  - ]:         27 :             syn = db.synonyms_begin(term);
     414         [ +  - ]:         27 :             end = db.synonyms_end(term);
     415                 :            :         }
     416 [ +  - ][ +  - ]:      80168 :         q = Query(q.OP_SYNONYM,
                 [ +  - ]
     417                 :            :                   SynonymIterator(syn, pos, &q),
     418         [ +  - ]:      40084 :                   SynonymIterator(end));
     419                 :      40084 :     }
     420         [ +  - ]:      40084 :     return q;
     421                 :            : }
     422                 :            : 
     423                 :            : Query
     424                 :      67029 : Term::get_query_with_auto_synonyms() const
     425                 :            : {
     426                 :            :     const unsigned MASK_ENABLE_AUTO_SYNONYMS =
     427                 :            :         QueryParser::FLAG_AUTO_SYNONYMS |
     428                 :      67029 :         QueryParser::FLAG_AUTO_MULTIWORD_SYNONYMS;
     429         [ +  + ]:      67029 :     if (state->flags & MASK_ENABLE_AUTO_SYNONYMS)
     430                 :      40054 :         return get_query_with_synonyms();
     431                 :            : 
     432                 :      26975 :     return get_query();
     433                 :            : }
     434                 :            : 
     435                 :            : static void
     436                 :       1266 : add_to_query(Query *& q, Query::op op, Query * term)
     437                 :            : {
     438                 :            :     Assert(term);
     439         [ +  + ]:       1266 :     if (q) {
     440         [ +  + ]:       1073 :         if (op == Query::OP_OR) {
     441                 :        916 :             *q |= *term;
     442         [ +  + ]:        157 :         } else if (op == Query::OP_AND) {
     443                 :         82 :             *q &= *term;
     444                 :            :         } else {
     445         [ +  - ]:         75 :             *q = Query(op, *q, *term);
     446                 :            :         }
     447         [ +  - ]:       1073 :         delete term;
     448                 :            :     } else {
     449                 :        193 :         q = term;
     450                 :            :     }
     451                 :       1266 : }
     452                 :            : 
     453                 :            : static void
     454                 :        480 : add_to_query(Query *& q, Query::op op, const Query & term)
     455                 :            : {
     456         [ +  + ]:        480 :     if (q) {
     457         [ +  + ]:         34 :         if (op == Query::OP_OR) {
     458                 :          4 :             *q |= term;
     459         [ -  + ]:         30 :         } else if (op == Query::OP_AND) {
     460                 :          0 :             *q &= term;
     461                 :            :         } else {
     462         [ +  - ]:         34 :             *q = Query(op, *q, term);
     463                 :            :         }
     464                 :            :     } else {
     465         [ +  - ]:        446 :         q = new Query(term);
     466                 :            :     }
     467                 :        480 : }
     468                 :            : 
     469                 :            : Query
     470                 :      87188 : Term::get_query() const
     471                 :            : {
     472                 :      87188 :     const list<string> & prefixes = field_info->prefixes;
     473         [ +  + ]:      87188 :     if (prefixes.empty()) {
     474                 :            :         // FIXME: handle multiple here
     475                 :            :         Assert(!field_info->procs.empty());
     476         [ +  - ]:          6 :         return (**field_info->procs.begin())(name);
     477                 :            :     }
     478                 :      87182 :     list<string>::const_iterator piter = prefixes.begin();
     479 [ +  - ][ +  - ]:      87182 :     Query q(make_term(*piter), 1, pos);
     480         [ +  + ]:      87187 :     while (++piter != prefixes.end()) {
     481 [ +  - ][ +  - ]:          5 :         q |= Query(make_term(*piter), 1, pos);
                 [ +  - ]
     482                 :            :     }
     483         [ +  - ]:      87188 :     return q;
     484                 :            : }
     485                 :            : 
     486                 :            : Query *
     487                 :        103 : Term::as_fuzzy_query(State* state_) const
     488                 :            : {
     489                 :        103 :     const list<string>& prefixes = field_info->prefixes;
     490                 :        103 :     Xapian::termcount max = state_->get_max_fuzzy_expansion();
     491                 :        103 :     int query_flags = state_->get_max_fuzzy_type();
     492                 :        103 :     vector<Query> subqs;
     493         [ +  - ]:        103 :     subqs.reserve(prefixes.size());
     494         [ +  + ]:        206 :     for (auto&& prefix : prefixes) {
     495                 :            :         // Combine with OP_OR, and apply OP_SYNONYM afterwards.
     496                 :            :         subqs.emplace_back(Query::OP_EDIT_DISTANCE,
     497         [ +  - ]:        206 :                            prefix + name,
     498                 :            :                            max,
     499                 :            :                            query_flags,
     500                 :            :                            Query::OP_OR,
     501                 :            :                            edit_distance,
     502         [ +  - ]:        206 :                            prefix.size());
     503                 :            :     }
     504 [ +  - ][ +  - ]:        103 :     Query* q = new Query(Query::OP_SYNONYM, subqs.begin(), subqs.end());
     505         [ +  - ]:        103 :     delete this;
     506                 :        103 :     return q;
     507                 :            : }
     508                 :            : 
     509                 :            : Query *
     510                 :        376 : Term::as_wildcarded_query(State * state_) const
     511                 :            : {
     512                 :        376 :     const list<string> & prefixes = field_info->prefixes;
     513                 :        376 :     list<string>::const_iterator piter;
     514                 :        376 :     Xapian::termcount max = state_->get_max_wildcard_expansion();
     515                 :        376 :     int query_flags = state_->get_max_wildcard_type();
     516         [ +  + ]:        376 :     if (state_->flags & QueryParser::FLAG_WILDCARD_SINGLE)
     517                 :         20 :         query_flags |= Query::WILDCARD_PATTERN_SINGLE;
     518         [ +  + ]:        376 :     if (state_->flags & QueryParser::FLAG_WILDCARD_MULTI)
     519                 :         20 :         query_flags |= Query::WILDCARD_PATTERN_MULTI;
     520                 :        376 :     vector<Query> subqs;
     521         [ +  - ]:        376 :     subqs.reserve(prefixes.size());
     522         [ +  + ]:        752 :     for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
     523         [ +  - ]:        376 :         string root = *piter;
     524         [ +  - ]:        376 :         root += name;
     525                 :            :         // Combine with OP_OR, and apply OP_SYNONYM afterwards.
     526                 :            :         subqs.push_back(Query(Query::OP_WILDCARD, root, max, query_flags,
     527 [ +  - ][ +  - ]:        376 :                               Query::OP_OR));
     528                 :        376 :     }
     529 [ +  - ][ +  - ]:        376 :     Query * q = new Query(Query::OP_SYNONYM, subqs.begin(), subqs.end());
     530         [ +  - ]:        376 :     delete this;
     531                 :        376 :     return q;
     532                 :            : }
     533                 :            : 
     534                 :            : Query *
     535                 :        202 : Term::as_partial_query(State * state_) const
     536                 :            : {
     537                 :        202 :     Xapian::termcount max = state_->get_max_partial_expansion();
     538                 :        202 :     int max_type = state_->get_max_partial_type();
     539                 :        202 :     vector<Query> subqs_partial; // A synonym of all the partial terms.
     540                 :        404 :     vector<Query> subqs_full; // A synonym of all the full terms.
     541                 :            : 
     542                 :        202 :     const list<string> & prefixes = field_info->prefixes;
     543                 :        202 :     list<string>::const_iterator piter;
     544         [ +  + ]:        424 :     for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
     545         [ +  - ]:        222 :         string root = *piter;
     546         [ +  - ]:        222 :         root += name;
     547                 :            :         // Combine with OP_OR, and apply OP_SYNONYM afterwards.
     548                 :            :         subqs_partial.push_back(Query(Query::OP_WILDCARD, root, max, max_type,
     549 [ +  - ][ +  - ]:        222 :                                       Query::OP_OR));
     550                 :            :         // Add the term, as it would normally be handled, as an alternative.
     551 [ +  - ][ +  - ]:        222 :         subqs_full.push_back(Query(make_term(*piter), 1, pos));
                 [ +  - ]
     552                 :        222 :     }
     553                 :            :     Query * q = new Query(Query::OP_OR,
     554                 :            :                           Query(Query::OP_SYNONYM,
     555                 :            :                                 subqs_partial.begin(), subqs_partial.end()),
     556                 :            :                           Query(Query::OP_SYNONYM,
     557 [ +  - ][ +  - ]:        202 :                                 subqs_full.begin(), subqs_full.end()));
         [ +  - ][ +  - ]
     558         [ +  - ]:        202 :     delete this;
     559                 :        202 :     return q;
     560                 :            : }
     561                 :            : 
     562                 :            : Query *
     563                 :         31 : Term::as_cjk_query() const
     564                 :            : {
     565                 :         31 :     const list<string> & prefixes = field_info->prefixes;
     566                 :            :     Query *q;
     567                 :            : 
     568                 :            : #ifdef USE_ICU
     569                 :            :     if (state->flags & QueryParser::FLAG_CJK_WORDS) {
     570                 :            :         vector<Query> prefix_cjk;
     571                 :            :         list<string>::const_iterator piter;
     572                 :            : 
     573                 :            :         for (CJKWordIterator tk(name); tk != CJKWordIterator(); ++tk) {
     574                 :            :             const string& token = *tk;
     575                 :            :             for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
     576                 :            :                 prefix_cjk.push_back(Query(*piter + token, 1, pos));
     577                 :            :             }
     578                 :            :         }
     579                 :            : 
     580                 :            :         q = new Query(Query::OP_AND, prefix_cjk.begin(), prefix_cjk.end());
     581                 :            : 
     582                 :            :         delete this;
     583                 :            :         return q;
     584                 :            :     }
     585                 :            : #endif
     586                 :            : 
     587                 :         31 :     vector<Query> prefix_subqs;
     588                 :         62 :     vector<Query> cjk_subqs;
     589                 :         31 :     list<string>::const_iterator piter;
     590                 :            : 
     591         [ +  + ]:         63 :     for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
     592                 :         32 :         const string& prefix = *piter;
     593                 :            : 
     594 [ +  - ][ +  - ]:        156 :         for (CJKNgramIterator tk(name); tk != CJKNgramIterator(); ++tk) {
         [ +  - ][ +  + ]
     595 [ +  - ][ +  - ]:        124 :             cjk_subqs.push_back(Query(prefix + *tk, 1, pos));
                 [ +  - ]
     596                 :         32 :         }
     597                 :            :         prefix_subqs.push_back(Query(Query::OP_AND,
     598 [ +  - ][ +  - ]:         32 :                                      cjk_subqs.begin(), cjk_subqs.end()));
     599                 :         32 :         cjk_subqs.clear();
     600                 :            :     }
     601 [ +  - ][ +  - ]:         31 :     q = new Query(Query::OP_OR, prefix_subqs.begin(), prefix_subqs.end());
     602                 :            : 
     603         [ +  - ]:         31 :     delete this;
     604                 :         31 :     return q;
     605                 :            : }
     606                 :            : 
     607                 :            : Query
     608                 :      18671 : Term::as_range_query() const
     609                 :            : {
     610                 :      18671 :     Query q = query;
     611         [ +  - ]:      18671 :     delete this;
     612                 :      18671 :     return q;
     613                 :            : }
     614                 :            : 
     615                 :            : inline bool
     616                 :     125352 : is_phrase_generator(unsigned ch)
     617                 :            : {
     618                 :            :     // These characters generate a phrase search.
     619                 :            :     // Ordered mostly by frequency of calls to this function done when
     620                 :            :     // running the testcases in api_queryparser.cc.
     621 [ +  + ][ +  + ]:     125352 :     return (ch && ch < 128 && strchr(".-/:\\@", ch) != NULL);
                 [ +  + ]
     622                 :            : }
     623                 :            : 
     624                 :            : inline bool
     625                 :       2276 : is_stem_preventer(unsigned ch)
     626                 :            : {
     627 [ +  - ][ +  + ]:       2276 :     return (ch && ch < 128 && strchr("(/\\@<>=*[{\"", ch) != NULL);
                 [ +  + ]
     628                 :            : }
     629                 :            : 
     630                 :            : inline bool
     631                 :       3851 : should_stem(const string & term)
     632                 :            : {
     633                 :            :     const unsigned int SHOULD_STEM_MASK =
     634                 :            :         (1 << Unicode::LOWERCASE_LETTER) |
     635                 :            :         (1 << Unicode::TITLECASE_LETTER) |
     636                 :            :         (1 << Unicode::MODIFIER_LETTER) |
     637                 :       3851 :         (1 << Unicode::OTHER_LETTER);
     638                 :       3851 :     Utf8Iterator u(term);
     639                 :       3851 :     return ((SHOULD_STEM_MASK >> Unicode::get_category(*u)) & 1);
     640                 :            : }
     641                 :            : 
     642                 :            : /** Value representing "ignore this" when returned by check_infix() or
     643                 :            :  *  check_infix_digit().
     644                 :            :  */
     645                 :            : const unsigned UNICODE_IGNORE = numeric_limits<unsigned>::max();
     646                 :            : 
     647                 :      42577 : inline unsigned check_infix(unsigned ch) {
     648 [ +  + ][ +  + ]:      42577 :     if (ch == '\'' || ch == '&' || ch == 0xb7 || ch == 0x5f4 || ch == 0x2027) {
         [ +  + ][ +  - ]
                 [ -  + ]
     649                 :            :         // Unicode includes all these except '&' in its word boundary rules,
     650                 :            :         // as well as 0x2019 (which we handle below) and ':' (for Swedish
     651                 :            :         // apparently, but we ignore this for now as it's problematic in
     652                 :            :         // real world cases).
     653                 :         11 :         return ch;
     654                 :            :     }
     655         [ +  + ]:      42566 :     if (ch >= 0x200b) {
     656                 :            :         // 0x2019 is Unicode apostrophe and single closing quote.
     657                 :            :         // 0x201b is Unicode single opening quote with the tail rising.
     658 [ +  - ][ -  + ]:          6 :         if (ch == 0x2019 || ch == 0x201b)
     659                 :          0 :             return '\'';
     660 [ -  + ][ #  # ]:          6 :         if (ch <= 0x200d || ch == 0x2060 || ch == 0xfeff)
                 [ #  # ]
     661                 :          6 :             return UNICODE_IGNORE;
     662                 :            :     }
     663                 :      42560 :     return 0;
     664                 :            : }
     665                 :            : 
     666                 :         92 : inline unsigned check_infix_digit(unsigned ch) {
     667                 :            :     // This list of characters comes from Unicode's word identifying algorithm.
     668         [ +  + ]:         92 :     switch (ch) {
     669                 :            :         case ',':
     670                 :            :         case '.':
     671                 :            :         case ';':
     672                 :            :         case 0x037e: // GREEK QUESTION MARK
     673                 :            :         case 0x0589: // ARMENIAN FULL STOP
     674                 :            :         case 0x060D: // ARABIC DATE SEPARATOR
     675                 :            :         case 0x07F8: // NKO COMMA
     676                 :            :         case 0x2044: // FRACTION SLASH
     677                 :            :         case 0xFE10: // PRESENTATION FORM FOR VERTICAL COMMA
     678                 :            :         case 0xFE13: // PRESENTATION FORM FOR VERTICAL COLON
     679                 :            :         case 0xFE14: // PRESENTATION FORM FOR VERTICAL SEMICOLON
     680                 :         58 :             return ch;
     681                 :            :     }
     682 [ -  + ][ #  # ]:         34 :     if (ch >= 0x200b && (ch <= 0x200d || ch == 0x2060 || ch == 0xfeff))
         [ #  # ][ #  # ]
     683                 :          0 :         return UNICODE_IGNORE;
     684                 :         34 :     return 0;
     685                 :            : }
     686                 :            : 
     687                 :            : // Prototype a function lemon generates, but which we want to call before that
     688                 :            : // in the generated source code file.
     689                 :            : struct yyParser;
     690                 :            : static void yy_parse_failed(yyParser *);
     691                 :            : 
     692                 :            : void
     693                 :         53 : QueryParser::Internal::add_prefix(const string &field, const string &prefix)
     694                 :            : {
     695         [ +  - ]:         53 :     map<string, FieldInfo>::iterator p = field_map.find(field);
     696         [ +  + ]:         53 :     if (p == field_map.end()) {
     697 [ +  - ][ +  - ]:         43 :         field_map.insert(make_pair(field, FieldInfo(NON_BOOLEAN, prefix)));
         [ +  - ][ +  - ]
     698                 :            :     } else {
     699                 :            :         // Check that this is the same type of filter as the existing one(s).
     700         [ +  + ]:         10 :         if (p->second.type != NON_BOOLEAN) {
     701 [ +  - ][ +  - ]:          1 :             throw Xapian::InvalidOperationError("Can't use add_prefix() and add_boolean_prefix() on the same field name, or add_boolean_prefix() with different values of the 'exclusive' parameter");
                 [ +  - ]
     702                 :            :         }
     703         [ -  + ]:          9 :         if (!p->second.procs.empty())
     704 [ #  # ][ #  # ]:          0 :             throw Xapian::FeatureUnavailableError("Mixing FieldProcessor objects and string prefixes currently not supported");
                 [ #  # ]
     705         [ +  - ]:          9 :         p->second.prefixes.push_back(prefix);
     706                 :            :    }
     707                 :         52 : }
     708                 :            : 
     709                 :            : void
     710                 :          6 : QueryParser::Internal::add_prefix(const string &field, FieldProcessor *proc)
     711                 :            : {
     712         [ +  - ]:          6 :     map<string, FieldInfo>::iterator p = field_map.find(field);
     713         [ +  - ]:          6 :     if (p == field_map.end()) {
     714 [ +  - ][ +  - ]:          6 :         field_map.insert(make_pair(field, FieldInfo(NON_BOOLEAN, proc)));
         [ +  - ][ +  - ]
     715                 :            :     } else {
     716                 :            :         // Check that this is the same type of filter as the existing one(s).
     717         [ #  # ]:          0 :         if (p->second.type != NON_BOOLEAN) {
     718 [ #  # ][ #  # ]:          0 :             throw Xapian::InvalidOperationError("Can't use add_prefix() and add_boolean_prefix() on the same field name, or add_boolean_prefix() with different values of the 'exclusive' parameter");
                 [ #  # ]
     719                 :            :         }
     720         [ #  # ]:          0 :         if (!p->second.prefixes.empty())
     721 [ #  # ][ #  # ]:          0 :             throw Xapian::FeatureUnavailableError("Mixing FieldProcessor objects and string prefixes currently not supported");
                 [ #  # ]
     722 [ #  # ][ #  # ]:          0 :         throw Xapian::FeatureUnavailableError("Multiple FieldProcessor objects for the same prefix currently not supported");
                 [ #  # ]
     723                 :            :         // p->second.procs.push_back(proc);
     724                 :            :    }
     725                 :          6 : }
     726                 :            : 
     727                 :            : void
     728                 :         26 : QueryParser::Internal::add_boolean_prefix(const string &field,
     729                 :            :                                           const string &prefix,
     730                 :            :                                           const string* grouping)
     731                 :            : {
     732                 :            :     // Don't allow the empty prefix to be set as boolean as it doesn't
     733                 :            :     // really make sense.
     734         [ +  + ]:         26 :     if (field.empty())
     735 [ +  - ][ +  - ]:          1 :         throw Xapian::UnimplementedError("Can't set the empty prefix to be a boolean filter");
                 [ +  - ]
     736         [ +  + ]:         25 :     if (!grouping) grouping = &field;
     737         [ +  + ]:         25 :     filter_type type = grouping->empty() ? BOOLEAN : BOOLEAN_EXCLUSIVE;
     738         [ +  - ]:         25 :     map<string, FieldInfo>::iterator p = field_map.find(field);
     739         [ +  + ]:         25 :     if (p == field_map.end()) {
     740 [ +  - ][ +  - ]:         21 :         field_map.insert(make_pair(field, FieldInfo(type, prefix, *grouping)));
                 [ +  - ]
     741                 :            :     } else {
     742                 :            :         // Check that this is the same type of filter as the existing one(s).
     743         [ +  + ]:          4 :         if (p->second.type != type) {
     744 [ +  - ][ +  - ]:          1 :             throw Xapian::InvalidOperationError("Can't use add_prefix() and add_boolean_prefix() on the same field name, or add_boolean_prefix() with different values of the 'exclusive' parameter"); // FIXME
                 [ +  - ]
     745                 :            :         }
     746         [ -  + ]:          3 :         if (!p->second.procs.empty())
     747 [ #  # ][ #  # ]:          0 :             throw Xapian::FeatureUnavailableError("Mixing FieldProcessor objects and string prefixes currently not supported");
                 [ #  # ]
     748         [ +  - ]:          3 :         p->second.prefixes.push_back(prefix); // FIXME grouping
     749                 :            :    }
     750                 :         24 : }
     751                 :            : 
     752                 :            : void
     753                 :          2 : QueryParser::Internal::add_boolean_prefix(const string &field,
     754                 :            :                                           FieldProcessor *proc,
     755                 :            :                                           const string* grouping)
     756                 :            : {
     757                 :            :     // Don't allow the empty prefix to be set as boolean as it doesn't
     758                 :            :     // really make sense.
     759         [ -  + ]:          2 :     if (field.empty())
     760 [ #  # ][ #  # ]:          0 :         throw Xapian::UnimplementedError("Can't set the empty prefix to be a boolean filter");
                 [ #  # ]
     761         [ +  - ]:          2 :     if (!grouping) grouping = &field;
     762         [ -  + ]:          2 :     filter_type type = grouping->empty() ? BOOLEAN : BOOLEAN_EXCLUSIVE;
     763         [ +  - ]:          2 :     map<string, FieldInfo>::iterator p = field_map.find(field);
     764         [ +  - ]:          2 :     if (p == field_map.end()) {
     765 [ +  - ][ +  - ]:          2 :         field_map.insert(make_pair(field, FieldInfo(type, proc, *grouping)));
                 [ +  - ]
     766                 :            :     } else {
     767                 :            :         // Check that this is the same type of filter as the existing one(s).
     768         [ #  # ]:          0 :         if (p->second.type != type) {
     769 [ #  # ][ #  # ]:          0 :             throw Xapian::InvalidOperationError("Can't use add_prefix() and add_boolean_prefix() on the same field name, or add_boolean_prefix() with different values of the 'exclusive' parameter"); // FIXME
                 [ #  # ]
     770                 :            :         }
     771         [ #  # ]:          0 :         if (!p->second.prefixes.empty())
     772 [ #  # ][ #  # ]:          0 :             throw Xapian::FeatureUnavailableError("Mixing FieldProcessor objects and string prefixes currently not supported");
                 [ #  # ]
     773 [ #  # ][ #  # ]:          0 :         throw Xapian::FeatureUnavailableError("Multiple FieldProcessor objects for the same prefix currently not supported");
                 [ #  # ]
     774                 :            :         // p->second.procs.push_back(proc);
     775                 :            :    }
     776                 :          2 : }
     777                 :            : 
     778                 :            : inline bool
     779                 :     396634 : is_extended_wildcard(unsigned ch, unsigned flags)
     780                 :            : {
     781         [ +  + ]:     396634 :     if (ch == '*') return (flags & QueryParser::FLAG_WILDCARD_MULTI);
     782         [ +  + ]:     396235 :     if (ch == '?') return (flags & QueryParser::FLAG_WILDCARD_SINGLE);
     783                 :     396211 :     return false;
     784                 :            : }
     785                 :            : 
     786                 :            : string
     787                 :      89343 : QueryParser::Internal::parse_term(Utf8Iterator &it, const Utf8Iterator &end,
     788                 :            :                                   bool cjk_enable, unsigned flags,
     789                 :            :                                   bool & is_cjk_term, bool &was_acronym,
     790                 :            :                                   size_t& first_wildcard,
     791                 :            :                                   size_t& char_count,
     792                 :            :                                   unsigned& edit_distance)
     793                 :            : {
     794                 :      89343 :     string term;
     795                 :      89343 :     char_count = 0;
     796                 :            :     // Look for initials separated by '.' (e.g. P.T.O., U.N.C.L.E).
     797                 :            :     // Don't worry if there's a trailing '.' or not.
     798         [ +  + ]:      89343 :     if (U_isupper(*it)) {
     799         [ +  - ]:       1105 :         string t;
     800                 :       1105 :         Utf8Iterator p = it;
     801         [ +  + ]:       1124 :         do {
     802         [ +  - ]:       1124 :             Unicode::append_utf8(t, *p++);
     803                 :       1124 :             ++char_count;
     804 [ +  + ][ +  + ]:       1124 :         } while (p != end && *p == '.' && ++p != end && U_isupper(*p));
         [ +  + ][ +  + ]
     805                 :            :         // One letter does not make an acronym!  If we handled a single
     806                 :            :         // uppercase letter here, we wouldn't catch M&S below.
     807         [ +  + ]:       1105 :         if (t.length() > 1) {
     808                 :            :             // Check there's not a (lower case) letter or digit
     809                 :            :             // immediately after it.
     810                 :            :             // FIXME: should I.B.M..P.T.O be a range search?
     811 [ +  + ][ +  - ]:          6 :             if (p == end || !is_wordchar(*p)) {
                 [ +  - ]
     812                 :          6 :                 it = p;
     813         [ +  - ]:          6 :                 swap(term, t);
     814                 :            :             } else {
     815                 :          6 :                 char_count = 0;
     816                 :            :             }
     817                 :       1105 :         }
     818                 :            :     }
     819                 :      89343 :     was_acronym = !term.empty();
     820                 :            : 
     821 [ +  + ][ +  - ]:      89343 :     if (cjk_enable && term.empty() && CJK::codepoint_is_cjk(*it)) {
         [ +  - ][ +  + ]
                 [ +  + ]
     822                 :         34 :         const char* cjk = it.raw();
     823         [ +  - ]:         34 :         char_count = CJK::get_cjk(it);
     824         [ +  - ]:         34 :         term.assign(cjk, it.raw() - cjk);
     825                 :         34 :         is_cjk_term = true;
     826                 :            :     }
     827                 :            : 
     828         [ +  + ]:      89343 :     if (term.empty()) {
     829                 :      89303 :         unsigned prevch = *it;
     830   [ +  -  +  + ]:     178606 :         if (first_wildcard == term.npos &&
                 [ +  + ]
     831                 :      89303 :             is_extended_wildcard(prevch, flags)) {
     832                 :            :             // Leading wildcard.
     833                 :         14 :             first_wildcard = 0;
     834                 :            :         }
     835         [ +  - ]:      89303 :         Unicode::append_utf8(term, prevch);
     836                 :      89303 :         char_count = 1;
     837         [ +  + ]:     268229 :         while (++it != end) {
     838 [ +  + ][ +  - ]:     263412 :             if (cjk_enable && CJK::codepoint_is_cjk(*it)) break;
         [ +  + ][ +  + ]
     839                 :     263407 :             unsigned ch = *it;
     840         [ +  + ]:     263407 :             if (is_extended_wildcard(ch, flags)) {
     841         [ +  + ]:         22 :                 if (first_wildcard == term.npos) {
     842                 :         13 :                     first_wildcard = char_count;
     843                 :            :                 }
     844         [ +  + ]:     263385 :             } else if (!is_wordchar(ch)) {
     845                 :            :                 // Treat a single embedded '&' or "'" or similar as a word
     846                 :            :                 // character (e.g. AT&T, Fred's).  Also, normalise
     847                 :            :                 // apostrophes to ASCII apostrophe.
     848                 :      84556 :                 Utf8Iterator p = it;
     849                 :      84556 :                 ++p;
     850         [ +  + ]:     128405 :                 if (p == end) break;
     851                 :      43924 :                 unsigned nextch = *p;
     852         [ +  + ]:      43924 :                 if (is_extended_wildcard(nextch, flags)) {
     853                 :            :                     // A wildcard follows, which could expand to a digit or a non-digit.
     854                 :          2 :                     unsigned ch_orig = ch;
     855                 :          2 :                     ch = check_infix(ch);
     856 [ +  - ][ -  + ]:          2 :                     if (!ch && is_digit(prevch))
                 [ -  + ]
     857                 :          0 :                         ch = check_infix_digit(ch_orig);
     858         [ +  - ]:          2 :                     if (!ch)
     859                 :          2 :                         break;
     860                 :            :                 } else {
     861         [ +  + ]:      43922 :                     if (!is_wordchar(nextch)) break;
     862                 :            :                 }
     863 [ +  + ][ +  + ]:      42667 :                 if (is_digit(prevch) && is_digit(nextch)) {
                 [ +  + ]
     864                 :         92 :                     ch = check_infix_digit(ch);
     865                 :            :                 } else {
     866                 :      42575 :                     ch = check_infix(ch);
     867                 :            :                 }
     868         [ +  + ]:      42667 :                 if (!ch) break;
     869         [ +  + ]:         75 :                 if (ch == UNICODE_IGNORE)
     870                 :         75 :                     continue;
     871                 :            :             }
     872         [ +  - ]:     178920 :             Unicode::append_utf8(term, ch);
     873                 :     178920 :             ++char_count;
     874                 :     178920 :             prevch = ch;
     875                 :            :         }
     876 [ +  + ][ +  + ]:      89303 :         if (it != end && is_suffix(*it)) {
                 [ +  + ]
     877         [ +  - ]:         76 :             string suff_term = term;
     878                 :         76 :             Utf8Iterator p = it;
     879                 :            :             // Keep trailing + (e.g. C++, Na+) or # (e.g. C#).
     880         [ +  + ]:         97 :             do {
     881                 :            :                 // Assumes is_suffix() only matches ASCII.
     882         [ -  + ]:         97 :                 if (suff_term.size() - term.size() == 3) {
     883         [ #  # ]:          0 :                     suff_term.resize(0);
     884                 :          0 :                     break;
     885                 :            :                 }
     886         [ +  - ]:         97 :                 suff_term += *p;
     887                 :         97 :             } while (is_suffix(*++p));
     888 [ +  - ][ +  + ]:         76 :             if (!suff_term.empty() && (p == end || !is_wordchar(*p))) {
         [ +  + ][ +  + ]
     889                 :            :                 // If the suffixed term doesn't exist, check that the
     890                 :            :                 // non-suffixed term does.  This also takes care of
     891                 :            :                 // the case when QueryParser::set_database() hasn't
     892                 :            :                 // been called.
     893                 :         44 :                 bool use_suff_term = false;
     894         [ +  - ]:         44 :                 string lc = Unicode::tolower(suff_term);
     895 [ +  - ][ -  + ]:         44 :                 if (db.term_exists(lc)) {
     896                 :          0 :                     use_suff_term = true;
     897                 :            :                 } else {
     898 [ +  - ][ +  - ]:         44 :                     lc = Unicode::tolower(term);
     899 [ +  - ][ +  + ]:         44 :                     if (!db.term_exists(lc)) use_suff_term = true;
     900                 :            :                 }
     901         [ +  + ]:         44 :                 if (use_suff_term) {
     902                 :            :                     // Assumes is_suffix() only matches ASCII.
     903                 :         39 :                     char_count += (suff_term.size() - term.size());
     904         [ +  - ]:         39 :                     term = suff_term;
     905                 :         39 :                     it = p;
     906                 :         44 :                 }
     907                 :         76 :             }
     908                 :            :         }
     909 [ +  + ][ +  + ]:      89303 :         if (first_wildcard == term.npos &&
     910                 :      89276 :             (flags & QueryParser::FLAG_WILDCARD)) {
     911                 :            :             // Check for right-truncation.
     912 [ +  + ][ +  + ]:        743 :             if (it != end && *it == '*') {
                 [ +  + ]
     913                 :        362 :                 ++it;
     914                 :        362 :                 first_wildcard = char_count;
     915                 :            :             }
     916                 :            :         }
     917 [ +  + ][ +  + ]:     262840 :         if (it != end &&
     918         [ +  - ]:        119 :             (flags & QueryParser::FLAG_FUZZY) &&
     919                 :            :             // Not a wildcard.
     920   [ +  +  +  + ]:     173537 :             first_wildcard == string::npos &&
     921                 :        119 :             *it == '~') {
     922                 :        103 :             Utf8Iterator p = it;
     923                 :        103 :             ++p;
     924                 :        103 :             unsigned ch = *p;
     925 [ +  + ][ +  + ]:        103 :             if (p == end || is_whitespace(ch) || ch == ')') {
         [ -  + ][ +  + ]
     926                 :         76 :                 it = p;
     927                 :         76 :                 edit_distance = DEFAULT_EDIT_DISTANCE;
     928         [ +  + ]:         27 :             } else if (U_isdigit(ch)) {
     929                 :         22 :                 unsigned distance = ch - '0';
     930 [ +  + ][ -  + ]:         22 :                 while (++p != end && U_isdigit(*p)) {
                 [ -  + ]
     931                 :          0 :                     distance = distance * 10 + (*p - '0');
     932                 :            :                 }
     933 [ +  + ][ +  - ]:         22 :                 if (p != end && *p == '.') {
                 [ +  + ]
     934         [ +  - ]:          1 :                     if (distance == 0) goto fractional;
     935                 :            :                     // Ignore the fractional part on e.g. foo~12.5
     936 [ #  # ][ #  # ]:          0 :                     while (++p != end && U_isdigit(*p)) { }
                 [ #  # ]
     937                 :            :                 }
     938 [ -  + ][ #  # ]:         21 :                 if (p == end || is_whitespace(ch) || ch == ')') {
         [ #  # ][ +  - ]
     939                 :         21 :                     it = p;
     940                 :         21 :                     edit_distance = distance;
     941                 :            :                 }
     942         [ +  - ]:          5 :             } else if (ch == '.') {
     943                 :            : fractional:
     944                 :          6 :                 double fraction = 0.0;
     945                 :          6 :                 double digit = 0.1;
     946 [ +  + ][ +  - ]:         12 :                 while (++p != end && U_isdigit(*p)) {
                 [ +  + ]
     947                 :          6 :                     fraction += digit * (*p - '0');
     948                 :          6 :                     digit *= 0.1;
     949                 :            :                 }
     950 [ -  + ][ #  # ]:          6 :                 if (p == end || is_whitespace(ch) || ch == ')') {
         [ #  # ][ +  - ]
     951                 :          6 :                     it = p;
     952                 :          6 :                     unsigned codepoints = 0;
     953         [ +  + ]:         27 :                     for (Utf8Iterator u8(term); u8 != Utf8Iterator(); ++u8) {
     954                 :         21 :                         ++codepoints;
     955                 :            :                     }
     956                 :      89303 :                     edit_distance = unsigned(codepoints * fraction);
     957                 :            :                 }
     958                 :            :             }
     959                 :            :         }
     960                 :            :     }
     961                 :      89343 :     return term;
     962                 :            : }
     963                 :            : 
     964                 :            : }
     965                 :            : // Switch to %code to insert at the end of the file so struct yyParser has been
     966                 :            : // defined.
     967                 :            : %code {
     968                 :            : 
     969                 :            : Query
     970                 :      64472 : QueryParser::Internal::parse_query(const string &qs, unsigned flags,
     971                 :            :                                    const string &default_prefix)
     972                 :            : {
     973                 :            : #ifndef USE_ICU
     974                 :            :     // Overall it seems best to check for this up front - otherwise we create
     975                 :            :     // the unhelpful situation where a failure to enable ICU in the build could
     976                 :            :     // be missed because non-CJK queries still work fine.
     977         [ +  + ]:      64472 :     if (flags & FLAG_CJK_WORDS) {
     978                 :            :         throw Xapian::FeatureUnavailableError("FLAG_CJK_WORDS requires "
     979 [ +  - ][ +  - ]:         13 :                                               "building Xapian to use ICU");
                 [ +  - ]
     980                 :            :     }
     981                 :            : #endif
     982                 :            :     bool cjk_enable =
     983 [ +  + ][ +  - ]:      64459 :         (flags & (FLAG_CJK_NGRAM|FLAG_CJK_WORDS)) || CJK::is_cjk_enabled();
                 [ -  + ]
     984                 :            : 
     985                 :            :     // Set ranges if we may have to handle ranges in the query.
     986 [ +  + ][ +  - ]:      64459 :     bool ranges = !rangeprocs.empty() && (qs.find("..") != string::npos);
                 [ +  + ]
     987                 :            : 
     988                 :      64459 :     termpos term_pos = 1;
     989                 :      64459 :     Utf8Iterator it(qs), end;
     990                 :            : 
     991                 :      64459 :     State state(this, flags);
     992                 :            : 
     993                 :            :     // To successfully apply more than one spelling correction to a query
     994                 :            :     // string, we must keep track of the offset due to previous corrections.
     995                 :      64459 :     int correction_offset = 0;
     996         [ +  - ]:      64459 :     corrected_query.resize(0);
     997                 :            : 
     998                 :            :     // Stack of prefixes, used for phrases and subexpressions.
     999                 :     128918 :     list<const FieldInfo *> prefix_stack;
    1000                 :            : 
    1001                 :            :     // If default_prefix is specified, use it.  Otherwise, use any list
    1002                 :            :     // that has been set for the empty prefix.
    1003 [ +  - ][ +  - ]:     128918 :     const FieldInfo def_pfx(NON_BOOLEAN, default_prefix);
    1004                 :            :     {
    1005                 :      64459 :         const FieldInfo * default_field_info = &def_pfx;
    1006         [ +  + ]:      64459 :         if (default_prefix.empty()) {
    1007 [ +  - ][ +  - ]:      64451 :             auto f = field_map.find(string());
    1008         [ +  + ]:      64451 :             if (f != field_map.end()) default_field_info = &(f->second);
    1009                 :            :         }
    1010                 :            : 
    1011                 :            :         // We always have the current prefix on the top of the stack.
    1012         [ +  - ]:      64459 :         prefix_stack.push_back(default_field_info);
    1013                 :            :     }
    1014                 :            : 
    1015         [ +  - ]:     128918 :     yyParser parser;
    1016                 :            : 
    1017                 :      64459 :     unsigned newprev = ' ';
    1018                 :            : main_lex_loop:
    1019                 :            :     enum {
    1020                 :            :         DEFAULT, IN_QUOTES, IN_PREFIXED_QUOTES, IN_PHRASED_TERM, IN_GROUP,
    1021                 :            :         IN_GROUP2, EXPLICIT_SYNONYM
    1022                 :      83130 :     } mode = DEFAULT;
    1023 [ +  + ][ +  + ]:     169692 :     while (it != end && !state.error) {
                 [ +  + ]
    1024                 :     109905 :         bool last_was_operator = false;
    1025                 :     109905 :         bool last_was_operator_needing_term = false;
    1026         [ +  + ]:     109905 :         if (mode == EXPLICIT_SYNONYM) mode = DEFAULT;
    1027                 :            :         if (false) {
    1028                 :            : just_had_operator:
    1029         [ +  + ]:       8474 :             if (it == end) break;
    1030                 :        161 :             mode = DEFAULT;
    1031                 :        161 :             last_was_operator_needing_term = false;
    1032                 :        161 :             last_was_operator = true;
    1033                 :            :         }
    1034                 :            :         if (false) {
    1035                 :            : just_had_operator_needing_term:
    1036                 :        283 :             last_was_operator_needing_term = true;
    1037                 :        283 :             last_was_operator = true;
    1038                 :            :         }
    1039         [ +  + ]:     110349 :         if (mode == IN_PHRASED_TERM) mode = DEFAULT;
    1040         [ +  + ]:     110349 :         if (is_whitespace(*it)) {
    1041                 :       1158 :             newprev = ' ';
    1042                 :       1158 :             ++it;
    1043         [ +  - ]:       1158 :             it = find_if(it, end, is_not_whitespace);
    1044         [ +  + ]:       1158 :             if (it == end) break;
    1045                 :            :         }
    1046                 :            : 
    1047 [ +  + ][ +  + ]:     110345 :         if (ranges &&
    1048 [ +  + ][ +  + ]:         12 :             (mode == DEFAULT || mode == IN_GROUP || mode == IN_GROUP2)) {
    1049                 :            :             // Scan forward to see if this could be the "start of range"
    1050                 :            :             // token.  Sadly this has O(n^2) tendencies, though at least
    1051                 :            :             // "n" is the number of words in a query which is likely to
    1052                 :            :             // remain fairly small.  FIXME: can we tokenise more elegantly?
    1053                 :      18707 :             Utf8Iterator it_initial = it;
    1054                 :      18707 :             Utf8Iterator p = it;
    1055                 :      18707 :             unsigned ch = 0;
    1056         [ +  + ]:      87715 :             while (p != end) {
    1057 [ +  + ][ +  + ]:      87686 :                 if (ch == '.' && *p == '.') {
    1058         [ +  - ]:      18684 :                     string a;
    1059         [ +  + ]:      87543 :                     while (it != p) {
    1060         [ +  - ]:      68859 :                         Unicode::append_utf8(a, *it++);
    1061                 :            :                     }
    1062                 :            :                     // Trim off the trailing ".".
    1063         [ +  - ]:      18684 :                     a.resize(a.size() - 1);
    1064                 :      18684 :                     ++p;
    1065                 :            :                     // Either end of the range can be empty (for an open-ended
    1066                 :            :                     // range) but both can't be empty.
    1067 [ +  + ][ +  - ]:      18684 :                     if (!a.empty() || (p != end && *p > ' ' && *p != ')')) {
         [ +  - ][ +  - ]
                 [ +  - ]
    1068         [ +  - ]:      18684 :                         string b;
    1069                 :            :                         // Allow any character except whitespace and ')' in the
    1070                 :            :                         // upper bound.
    1071 [ +  + ][ +  + ]:      68753 :                         while (p != end && *p > ' ' && *p != ')') {
         [ +  - ][ +  + ]
    1072         [ +  - ]:      50069 :                             Unicode::append_utf8(b, *p++);
    1073                 :            :                         }
    1074         [ +  - ]:      18684 :                         Term * range = state.range(a, b);
    1075         [ +  + ]:      18684 :                         if (!range) {
    1076                 :         13 :                             state.error = "Unknown range operation";
    1077         [ +  + ]:         13 :                             if (a.find(':', 1) == string::npos) {
    1078                 :          7 :                                 goto done;
    1079                 :            :                             }
    1080                 :            :                             // Might be a boolean filter with ".." in.  Leave
    1081                 :            :                             // state.error in case it isn't.
    1082                 :          6 :                             it = it_initial;
    1083                 :          6 :                             break;
    1084                 :            :                         }
    1085         [ +  - ]:      18684 :                         Parse(&parser, RANGE, range, &state);
              [ +  +  + ]
    1086                 :            :                     }
    1087                 :      18671 :                     it = p;
    1088      [ +  +  + ]:      18684 :                     goto main_lex_loop;
    1089                 :            :                 }
    1090                 :      69002 :                 ch = *p;
    1091                 :            :                 // Allow any character except whitespace and '(' in the lower
    1092                 :            :                 // bound.
    1093 [ +  + ][ +  + ]:      69002 :                 if (ch <= ' ' || ch == '(') break;
    1094                 :      68988 :                 ++p;
    1095                 :            :             }
    1096                 :            :         }
    1097                 :            : 
    1098         [ +  + ]:      91667 :         if (!is_wordchar(*it)) {
    1099                 :       2535 :             unsigned prev = newprev;
    1100                 :       2535 :             Utf8Iterator p = it;
    1101                 :       2535 :             unsigned ch = *it++;
    1102                 :       2535 :             newprev = ch;
    1103                 :            :             // Drop out of IN_GROUP mode.
    1104 [ +  - ][ +  + ]:       2535 :             if (mode == IN_GROUP || mode == IN_GROUP2)
    1105                 :         18 :                 mode = DEFAULT;
    1106   [ +  +  +  +  :       2535 :             switch (ch) {
             +  +  +  + ]
    1107                 :            :               case '"':
    1108                 :            :               case 0x201c: // Left curly double quote.
    1109                 :            :               case 0x201d: // Right curly double quote.
    1110                 :            :                 // Quoted phrase.
    1111         [ +  + ]:        571 :                 if (mode == DEFAULT) {
    1112                 :            :                     // Skip whitespace.
    1113         [ +  - ]:        386 :                     it = find_if(it, end, is_not_whitespace);
    1114         [ +  + ]:        386 :                     if (it == end) {
    1115                 :            :                         // Ignore an unmatched " at the end of the query to
    1116                 :            :                         // avoid generating an empty pair of QUOTEs which will
    1117                 :            :                         // cause a parse error.
    1118                 :         73 :                         goto done;
    1119                 :            :                     }
    1120         [ +  + ]:        323 :                     if (is_double_quote(*it)) {
    1121                 :            :                         // Ignore empty "" (but only if we're not already
    1122                 :            :                         // IN_QUOTES as we don't merge two adjacent quoted
    1123                 :            :                         // phrases!)
    1124                 :         12 :                         newprev = *it++;
    1125                 :         12 :                         break;
    1126                 :            :                     }
    1127                 :            :                 }
    1128         [ +  + ]:        496 :                 if (flags & QueryParser::FLAG_PHRASE) {
    1129         [ +  - ]:        388 :                     Parse(&parser, QUOTE, NULL, &state);
    1130         [ +  + ]:        388 :                     if (mode == DEFAULT) {
    1131                 :        203 :                         mode = IN_QUOTES;
    1132                 :            :                     } else {
    1133                 :            :                         // Remove the prefix we pushed for this phrase.
    1134         [ +  + ]:        185 :                         if (mode == IN_PREFIXED_QUOTES)
    1135                 :         15 :                             prefix_stack.pop_back();
    1136                 :        388 :                         mode = DEFAULT;
    1137                 :            :                     }
    1138                 :            :                 }
    1139                 :        496 :                 break;
    1140                 :            : 
    1141                 :            :               case '+': case '-': // Loved or hated term/phrase/subexpression.
    1142                 :            :                 // Ignore + or - at the end of the query string.
    1143         [ +  + ]:        431 :                 if (it == end) goto done;
    1144 [ +  + ][ +  + ]:        421 :                 if (prev > ' ' && prev != '(') {
    1145                 :            :                     // Or if not after whitespace or an open bracket.
    1146                 :        105 :                     break;
    1147                 :            :                 }
    1148 [ +  + ][ +  - ]:        316 :                 if (is_whitespace(*it) || *it == '+' || *it == '-') {
         [ +  + ][ +  + ]
    1149                 :            :                     // Ignore + or - followed by a space, or further + or -.
    1150                 :            :                     // Postfix + (such as in C++ and H+) is handled as part of
    1151                 :            :                     // the term lexing code in parse_term().
    1152                 :         33 :                     newprev = *it++;
    1153                 :         33 :                     break;
    1154                 :            :                 }
    1155 [ +  + ][ +  + ]:        283 :                 if (mode == DEFAULT && (flags & FLAG_LOVEHATE)) {
    1156                 :            :                     int token;
    1157         [ +  + ]:        253 :                     if (ch == '+') {
    1158                 :        151 :                         token = LOVE;
    1159         [ +  + ]:        102 :                     } else if (last_was_operator) {
    1160                 :          6 :                         token = HATE_AFTER_AND;
    1161                 :            :                     } else {
    1162                 :         96 :                         token = HATE;
    1163                 :            :                     }
    1164         [ +  - ]:        253 :                     Parse(&parser, token, NULL, &state);
    1165                 :        283 :                     goto just_had_operator_needing_term;
    1166                 :            :                 }
    1167                 :            :                 // Need to prevent the term after a LOVE or HATE starting a
    1168                 :            :                 // term group...
    1169                 :         30 :                 break;
    1170                 :            : 
    1171                 :            :               case '(': // Bracketed subexpression.
    1172                 :            :                 // Skip whitespace.
    1173         [ +  - ]:        407 :                 it = find_if(it, end, is_not_whitespace);
    1174                 :            :                 // Ignore ( at the end of the query string.
    1175         [ -  + ]:        407 :                 if (it == end) goto done;
    1176 [ +  + ][ +  + ]:        407 :                 if (prev > ' ' && strchr("()+-", prev) == NULL) {
    1177                 :            :                     // Or if not after whitespace or a bracket or '+' or '-'.
    1178                 :        179 :                     break;
    1179                 :            :                 }
    1180         [ -  + ]:        228 :                 if (*it == ')') {
    1181                 :            :                     // Ignore empty ().
    1182                 :          0 :                     newprev = *it++;
    1183                 :          0 :                     break;
    1184                 :            :                 }
    1185 [ +  + ][ +  + ]:        228 :                 if (mode == DEFAULT && (flags & FLAG_BOOLEAN)) {
    1186         [ +  - ]:        210 :                     prefix_stack.push_back(prefix_stack.back());
    1187         [ +  - ]:        210 :                     Parse(&parser, BRA, NULL, &state);
    1188                 :            :                 }
    1189                 :        228 :                 break;
    1190                 :            : 
    1191                 :            :               case ')': // End of bracketed subexpression.
    1192 [ +  + ][ +  + ]:        409 :                 if (mode == DEFAULT && (flags & FLAG_BOOLEAN)) {
    1193                 :            :                     // Remove the prefix we pushed for the corresponding BRA.
    1194                 :            :                     // If brackets are unmatched, it's a syntax error, but
    1195                 :            :                     // that's no excuse to SEGV!
    1196         [ +  + ]:        285 :                     if (prefix_stack.size() > 1) prefix_stack.pop_back();
    1197         [ +  - ]:        285 :                     Parse(&parser, KET, NULL, &state);
    1198                 :            :                 }
    1199                 :        409 :                 break;
    1200                 :            : 
    1201                 :            :               case '~': // Synonym expansion.
    1202                 :            :                 // Ignore at the end of the query string.
    1203         [ -  + ]:         55 :                 if (it == end) goto done;
    1204 [ +  + ][ +  + ]:         55 :                 if (mode == DEFAULT && (flags & FLAG_SYNONYM)) {
    1205 [ +  + ][ -  + ]:         32 :                     if (prev > ' ' && strchr("+-(", prev) == NULL) {
    1206                 :            :                         // Or if not after whitespace, +, -, or an open bracket.
    1207                 :          0 :                         break;
    1208                 :            :                     }
    1209         [ +  + ]:         32 :                     if (!is_wordchar(*it)) {
    1210                 :            :                         // Ignore if not followed by a word character.
    1211                 :          2 :                         break;
    1212                 :            :                     }
    1213         [ +  - ]:         30 :                     Parse(&parser, SYNONYM, NULL, &state);
    1214                 :         30 :                     mode = EXPLICIT_SYNONYM;
    1215                 :         30 :                     goto just_had_operator_needing_term;
    1216                 :            :                 }
    1217                 :         23 :                 break;
    1218                 :            :               case '*':
    1219         [ +  + ]:         35 :                 if (flags & FLAG_WILDCARD_MULTI) {
    1220                 :          8 :                     it = p;
    1221                 :         14 :                     goto leading_wildcard;
    1222                 :            :                 }
    1223                 :         27 :                 break;
    1224                 :            :               case '?':
    1225         [ +  + ]:         25 :                 if (flags & FLAG_WILDCARD_SINGLE) {
    1226                 :          6 :                     it = p;
    1227                 :          6 :                     goto leading_wildcard;
    1228                 :            :                 }
    1229                 :         19 :                 break;
    1230                 :            :             }
    1231                 :            :             // Skip any other characters.
    1232                 :       2165 :             continue;
    1233                 :            :         }
    1234                 :            : 
    1235                 :            :         Assert(is_wordchar(*it));
    1236                 :            : 
    1237                 :            : leading_wildcard:
    1238                 :      89146 :         size_t term_start_index = it.raw() - qs.data();
    1239                 :            : 
    1240                 :      89146 :         newprev = 'A'; // Any letter will do...
    1241                 :            : 
    1242                 :            :         // A term, a prefix, or a boolean operator.
    1243                 :      89146 :         const FieldInfo * field_info = NULL;
    1244 [ +  + ][ +  + ]:     177676 :         if ((mode == DEFAULT || mode == IN_GROUP || mode == IN_GROUP2 || mode == EXPLICIT_SYNONYM) &&
                 [ +  + ]
           [ +  +  +  + ]
                 [ +  + ]
    1245                 :      88530 :             !field_map.empty()) {
    1246                 :            :             // Check for a fieldname prefix (e.g. title:historical).
    1247         [ +  - ]:       3314 :             Utf8Iterator p = find_if(it, end, is_not_wordchar);
    1248 [ +  + ][ +  + ]:       3314 :             if (p != end && *p == ':' && ++p != end && *p > ' ' && *p != ')') {
         [ +  - ][ +  + ]
         [ +  - ][ +  + ]
    1249         [ +  - ]:        254 :                 string field;
    1250                 :        254 :                 p = it;
    1251         [ +  + ]:       1674 :                 while (*p != ':')
    1252         [ +  - ]:       1420 :                     Unicode::append_utf8(field, *p++);
    1253                 :        254 :                 map<string, FieldInfo>::const_iterator f;
    1254         [ +  - ]:        254 :                 f = field_map.find(field);
    1255         [ +  + ]:        254 :                 if (f != field_map.end()) {
    1256                 :            :                     // Special handling for prefixed fields, depending on the
    1257                 :            :                     // type of the prefix.
    1258                 :        230 :                     unsigned ch = *++p;
    1259                 :        230 :                     field_info = &(f->second);
    1260                 :            : 
    1261         [ +  + ]:        230 :                     if (field_info->type != NON_BOOLEAN) {
    1262                 :            :                         // Drop out of IN_GROUP if we're in it.
    1263 [ +  + ][ +  + ]:        103 :                         if (mode == IN_GROUP || mode == IN_GROUP2)
    1264                 :         11 :                             mode = DEFAULT;
    1265                 :        103 :                         it = p;
    1266         [ +  - ]:        103 :                         string name;
    1267 [ +  - ][ +  + ]:        103 :                         if (it != end && is_double_quote(*it)) {
                 [ +  + ]
    1268                 :            :                             // Quoted boolean term (can contain any character).
    1269                 :         18 :                             bool fancy = (*it != '"');
    1270                 :         18 :                             ++it;
    1271         [ +  + ]:        143 :                             while (it != end) {
    1272         [ +  + ]:        125 :                                 if (*it == '"') {
    1273                 :            :                                     // Interpret "" as an escaped ".
    1274 [ +  + ][ -  + ]:         12 :                                     if (++it == end || *it != '"')
                 [ +  + ]
    1275                 :         10 :                                         break;
    1276 [ +  + ][ +  + ]:        113 :                                 } else if (fancy && is_double_quote(*it)) {
                 [ +  + ]
    1277                 :            :                                     // If the opening quote was ASCII, then the
    1278                 :            :                                     // closing one must be too - otherwise
    1279                 :            :                                     // the user can't protect non-ASCII double
    1280                 :            :                                     // quote characters by quoting or escaping.
    1281                 :          4 :                                     ++it;
    1282                 :          4 :                                     break;
    1283                 :            :                                 }
    1284         [ +  - ]:        111 :                                 Unicode::append_utf8(name, *it++);
    1285                 :            :                             }
    1286                 :            :                         } else {
    1287                 :            :                             // Can't boolean filter prefix a subexpression, so
    1288                 :            :                             // just use anything following the prefix until the
    1289                 :            :                             // next space or ')' as part of the boolean filter
    1290                 :            :                             // term.
    1291 [ +  + ][ +  + ]:        569 :                             while (it != end && *it > ' ' && *it != ')')
         [ +  + ][ +  + ]
    1292         [ +  - ]:        484 :                                 Unicode::append_utf8(name, *it++);
    1293                 :            :                         }
    1294                 :            :                         // Build the unstemmed form in field.
    1295         [ +  - ]:        103 :                         field += ':';
    1296         [ +  - ]:        103 :                         field += name;
    1297                 :            :                         // Clear any pending range error.
    1298                 :        103 :                         state.error = NULL;
    1299 [ +  - ][ +  - ]:        103 :                         Term * token = new Term(&state, name, field_info, field);
    1300         [ +  - ]:        103 :                         Parse(&parser, BOOLEAN_FILTER, token, &state);
    1301                 :        103 :                         continue;
    1302                 :            :                     }
    1303                 :            : 
    1304 [ +  + ][ +  + ]:        127 :                     if ((flags & FLAG_PHRASE) && is_double_quote(ch)) {
                 [ +  + ]
    1305                 :            :                         // Prefixed phrase, e.g.: subject:"space flight"
    1306                 :         15 :                         mode = IN_PREFIXED_QUOTES;
    1307         [ +  - ]:         15 :                         Parse(&parser, QUOTE, NULL, &state);
    1308                 :         15 :                         it = p;
    1309                 :         15 :                         newprev = ch;
    1310                 :         15 :                         ++it;
    1311         [ +  - ]:         15 :                         prefix_stack.push_back(field_info);
    1312                 :         15 :                         continue;
    1313                 :            :                     }
    1314                 :            : 
    1315 [ +  + ][ +  - ]:        112 :                     if (ch == '(' && (flags & FLAG_BOOLEAN)) {
    1316                 :            :                         // Prefixed subexpression, e.g.: title:(fast NEAR food)
    1317                 :         13 :                         mode = DEFAULT;
    1318         [ +  - ]:         13 :                         Parse(&parser, BRA, NULL, &state);
    1319                 :         13 :                         it = p;
    1320                 :         13 :                         newprev = ch;
    1321                 :         13 :                         ++it;
    1322         [ +  - ]:         13 :                         prefix_stack.push_back(field_info);
    1323                 :         13 :                         continue;
    1324                 :            :                     }
    1325                 :            : 
    1326         [ +  + ]:         99 :                     if (ch != ':') {
    1327                 :            :                         // Allow 'path:/usr/local' but not 'foo::bar::baz'.
    1328         [ +  + ]:         98 :                         while (is_phrase_generator(ch)) {
    1329         [ +  + ]:          7 :                             if (++p == end)
    1330                 :          2 :                                 goto not_prefix;
    1331                 :          5 :                             ch = *p;
    1332                 :            :                         }
    1333                 :            :                     }
    1334                 :            : 
    1335         [ +  + ]:         97 :                     if (is_wordchar(ch)) {
    1336                 :            :                         // Prefixed term.
    1337                 :         89 :                         it = p;
    1338                 :            :                     } else {
    1339                 :            : not_prefix:
    1340                 :            :                         // It looks like a prefix but isn't, so parse it as
    1341                 :            :                         // text instead.
    1342         [ +  + ]:        254 :                         field_info = NULL;
    1343                 :            :                     }
    1344                 :       3314 :                 }
    1345                 :            :             }
    1346                 :            :         }
    1347                 :            : 
    1348                 :            : phrased_term:
    1349                 :            :         bool was_acronym;
    1350                 :      89343 :         bool is_cjk_term = false;
    1351                 :      89343 :         size_t first_wildcard = string::npos;
    1352                 :            :         size_t term_char_count;
    1353                 :      89343 :         unsigned edit_distance = NO_EDIT_DISTANCE;
    1354                 :            :         string term = parse_term(it, end, cjk_enable, flags,
    1355                 :            :                                  is_cjk_term, was_acronym, first_wildcard,
    1356         [ +  - ]:      89343 :                                  term_char_count, edit_distance);
    1357                 :            : 
    1358 [ +  + ][ +  + ]:     178297 :         if (first_wildcard == string::npos &&
    1359         [ +  + ]:      88851 :             edit_distance == NO_EDIT_DISTANCE &&
    1360 [ +  + ][ +  + ]:      88851 :             (mode == DEFAULT || mode == IN_GROUP || mode == IN_GROUP2) &&
                 [ +  + ]
    1361         [ +  + ]:      82760 :             (flags & FLAG_BOOLEAN) &&
    1362                 :            :             // Don't want to interpret A.N.D. as an AND operator.
    1363         [ +  + ]:      82754 :             !was_acronym &&
    1364         [ +  + ]:      82723 :             !field_info &&
    1365 [ +  + ][ +  + ]:     261020 :             term.size() >= 2 && term.size() <= 4 && U_isalpha(term[0])) {
         [ +  - ][ +  + ]
    1366                 :            :             // Boolean operators.
    1367         [ +  - ]:      81164 :             string op = term;
    1368         [ +  + ]:      81164 :             if (flags & FLAG_BOOLEAN_ANY_CASE) {
    1369 [ +  - ][ +  - ]:         22 :                 for (string::iterator i = op.begin(); i != op.end(); ++i) {
                 [ +  + ]
    1370                 :         16 :                     *i = C_toupper(*i);
    1371                 :            :                 }
    1372                 :            :             }
    1373         [ +  + ]:      81164 :             if (op.size() == 3) {
    1374 [ +  - ][ +  + ]:      80542 :                 if (op == "AND") {
    1375         [ +  - ]:         62 :                     Parse(&parser, AND, NULL, &state);
    1376                 :         62 :                     goto just_had_operator;
    1377                 :            :                 }
    1378 [ +  - ][ +  + ]:      80480 :                 if (op == "NOT") {
    1379         [ +  - ]:         36 :                     Parse(&parser, NOT, NULL, &state);
    1380                 :         36 :                     goto just_had_operator;
    1381                 :            :                 }
    1382 [ +  - ][ +  + ]:      80444 :                 if (op == "XOR") {
    1383         [ +  - ]:         12 :                     Parse(&parser, XOR, NULL, &state);
    1384                 :         12 :                     goto just_had_operator;
    1385                 :            :                 }
    1386 [ +  - ][ +  + ]:      80432 :                 if (op == "ADJ") {
    1387 [ +  - ][ +  + ]:          8 :                     if (it != end && *it == '/') {
                 [ +  + ]
    1388                 :          5 :                         size_t width = 0;
    1389                 :          5 :                         Utf8Iterator p = it;
    1390 [ +  - ][ +  + ]:          7 :                         while (++p != end && U_isdigit(*p)) {
                 [ +  + ]
    1391                 :          2 :                             width = (width * 10) + (*p - '0');
    1392                 :            :                         }
    1393 [ +  + ][ +  - ]:          5 :                         if (width && (p == end || is_whitespace(*p))) {
         [ +  - ][ +  + ]
    1394                 :          2 :                             it = p;
    1395 [ +  - ][ +  - ]:          2 :                             Parse(&parser, ADJ, new Term(width), &state);
                 [ +  - ]
    1396                 :          5 :                             goto just_had_operator;
    1397                 :            :                         }
    1398                 :            :                     } else {
    1399         [ +  - ]:          3 :                         Parse(&parser, ADJ, NULL, &state);
    1400                 :      80430 :                         goto just_had_operator;
    1401                 :            :                     }
    1402                 :            :                 }
    1403         [ +  + ]:        622 :             } else if (op.size() == 2) {
    1404 [ +  - ][ +  + ]:        274 :                 if (op == "OR") {
    1405         [ +  - ]:         43 :                     Parse(&parser, OR, NULL, &state);
    1406                 :         43 :                     goto just_had_operator;
    1407                 :            :                 }
    1408         [ +  - ]:        348 :             } else if (op.size() == 4) {
    1409 [ +  - ][ +  + ]:        348 :                 if (op == "NEAR") {
    1410 [ +  - ][ +  + ]:         17 :                     if (it != end && *it == '/') {
                 [ +  + ]
    1411                 :          5 :                         size_t width = 0;
    1412                 :          5 :                         Utf8Iterator p = it;
    1413 [ +  - ][ +  + ]:          7 :                         while (++p != end && U_isdigit(*p)) {
                 [ +  + ]
    1414                 :          2 :                             width = (width * 10) + (*p - '0');
    1415                 :            :                         }
    1416 [ +  + ][ +  - ]:          5 :                         if (width && (p == end || is_whitespace(*p))) {
         [ +  - ][ +  + ]
    1417                 :          2 :                             it = p;
    1418 [ +  - ][ +  - ]:          2 :                             Parse(&parser, NEAR, new Term(width), &state);
                 [ +  - ]
    1419                 :          5 :                             goto just_had_operator;
    1420                 :            :                         }
    1421                 :            :                     } else {
    1422         [ +  - ]:         12 :                         Parse(&parser, NEAR, NULL, &state);
    1423         [ +  + ]:      81164 :                         goto just_had_operator;
    1424                 :            :                     }
    1425                 :            :                 }
    1426                 :      81164 :             }
    1427                 :            :         }
    1428                 :            : 
    1429                 :            :         // If no prefix is set, use the default one.
    1430         [ +  + ]:      89171 :         if (!field_info) field_info = prefix_stack.back();
    1431                 :            : 
    1432                 :            :         Assert(field_info->type == NON_BOOLEAN);
    1433                 :            : 
    1434                 :            :         {
    1435         [ +  - ]:      89171 :             string unstemmed_term(term);
    1436 [ +  - ][ +  - ]:      89171 :             term = Unicode::tolower(term);
    1437                 :            : 
    1438                 :            :             // Reuse stem_strategy - STEM_SOME here means "stem terms except
    1439                 :            :             // when used with positional operators".
    1440                 :      89171 :             stem_strategy stem_term = stem_action;
    1441         [ +  + ]:      89171 :             if (stem_term != STEM_NONE) {
    1442         [ +  + ]:      89161 :                 if (!stemmer.internal.get()) {
    1443                 :            :                     // No stemmer is set.
    1444                 :      85207 :                     stem_term = STEM_NONE;
    1445 [ +  + ][ -  + ]:       3954 :                 } else if (first_wildcard != string::npos ||
    1446                 :       3916 :                            edit_distance != NO_EDIT_DISTANCE) {
    1447                 :         38 :                     stem_term = STEM_NONE;
    1448 [ +  + ][ +  + ]:       3916 :                 } else if (stem_term == STEM_SOME ||
    1449                 :            :                            stem_term == STEM_SOME_FULL_POS) {
    1450   [ +  +  +  + ]:       8791 :                     if (!should_stem(unstemmed_term) ||
                 [ +  + ]
    1451         [ +  + ]:       4940 :                         (it != end && is_stem_preventer(*it))) {
    1452                 :            :                         // Don't stem this particular term.
    1453                 :      89161 :                         stem_term = STEM_NONE;
    1454                 :            :                     }
    1455                 :            :                 }
    1456                 :            :             }
    1457                 :            : 
    1458         [ +  + ]:      89171 :             if (first_wildcard != string::npos) {
    1459         [ +  + ]:        389 :                 if (first_wildcard < state.get_min_wildcard_prefix_len()) {
    1460                 :         13 :                     errmsg = "Too few characters before wildcard";
    1461         [ +  - ]:         13 :                     return state.query;
    1462                 :            :                 }
    1463                 :            :             }
    1464                 :            : 
    1465                 :            :             Term * term_obj = new Term(&state, term, field_info,
    1466                 :            :                                        unstemmed_term, stem_term, term_pos++,
    1467 [ +  - ][ +  - ]:      89158 :                                        edit_distance);
    1468                 :            : 
    1469 [ +  + ][ +  + ]:      89158 :             if (first_wildcard != string::npos ||
    1470                 :      88782 :                 edit_distance != NO_EDIT_DISTANCE) {
    1471 [ +  + ][ +  + ]:        479 :                 if (mode == IN_GROUP || mode == IN_GROUP2) {
    1472                 :            :                     // Drop out of IN_GROUP and flag that the group
    1473                 :            :                     // can be empty if all members are stopwords.
    1474         [ +  + ]:         74 :                     if (mode == IN_GROUP2)
    1475         [ +  - ]:         40 :                         Parse(&parser, EMPTY_GROUP_OK, NULL, &state);
    1476                 :         74 :                     mode = DEFAULT;
    1477                 :            :                 }
    1478                 :            :                 Parse(&parser,
    1479                 :        479 :                       first_wildcard != string::npos ? WILD_TERM : EDIT_TERM,
    1480                 :            :                       term_obj,
    1481 [ +  + ][ +  - ]:        479 :                       &state);
    1482                 :        479 :                 continue;
    1483                 :            :             }
    1484                 :            : 
    1485         [ +  + ]:      88679 :             if (is_cjk_term) {
    1486         [ +  - ]:         34 :                 Parse(&parser, CJKTERM, term_obj, &state);
    1487         [ +  + ]:         34 :                 if (it == end) break;
    1488                 :         21 :                 continue;
    1489                 :            :             }
    1490                 :            : 
    1491 [ +  + ][ +  + ]:      88645 :             if (mode == DEFAULT || mode == IN_GROUP || mode == IN_GROUP2) {
                 [ +  + ]
    1492 [ +  + ][ +  + ]:      87674 :                 if (it == end && (flags & FLAG_PARTIAL)) {
                 [ +  + ]
    1493                 :       4218 :                     auto min_len = state.get_min_partial_prefix_len();
    1494         [ +  + ]:       4218 :                     if (term_char_count >= min_len) {
    1495 [ +  + ][ -  + ]:        202 :                         if (mode == IN_GROUP || mode == IN_GROUP2) {
    1496                 :            :                             // Drop out of IN_GROUP and flag that the group
    1497                 :            :                             // can be empty if all members are stopwords.
    1498         [ -  + ]:         13 :                             if (mode == IN_GROUP2)
    1499         [ #  # ]:          0 :                                 Parse(&parser, EMPTY_GROUP_OK, NULL, &state);
    1500                 :         13 :                             mode = DEFAULT;
    1501                 :            :                         }
    1502                 :            :                         // Final term of a partial match query, with no
    1503                 :            :                         // following characters - treat as a wildcard.
    1504         [ +  - ]:        202 :                         Parse(&parser, PARTIAL_TERM, term_obj, &state);
    1505                 :       4218 :                         continue;
    1506                 :            :                     }
    1507                 :            :                 }
    1508                 :            :             }
    1509                 :            : 
    1510                 :            :             // Check spelling, if we're a normal term, and any of the prefixes
    1511                 :            :             // are empty.
    1512 [ +  + ][ +  + ]:      88443 :             if ((flags & FLAG_SPELLING_CORRECTION) && !was_acronym) {
    1513                 :         76 :                 const list<string> & pfxes = field_info->prefixes;
    1514                 :         76 :                 list<string>::const_iterator pfx_it;
    1515         [ +  - ]:        152 :                 for (pfx_it = pfxes.begin(); pfx_it != pfxes.end(); ++pfx_it) {
    1516         [ -  + ]:         76 :                     if (!pfx_it->empty())
    1517                 :          0 :                         continue;
    1518         [ +  - ]:         76 :                     const string & suggest = db.get_spelling_suggestion(term);
    1519         [ +  + ]:         76 :                     if (!suggest.empty()) {
    1520 [ +  + ][ +  - ]:         47 :                         if (corrected_query.empty()) corrected_query = qs;
    1521                 :         47 :                         size_t term_end_index = it.raw() - qs.data();
    1522                 :         47 :                         size_t n = term_end_index - term_start_index;
    1523                 :         47 :                         size_t pos = term_start_index + correction_offset;
    1524         [ +  - ]:         47 :                         corrected_query.replace(pos, n, suggest);
    1525                 :         47 :                         correction_offset += suggest.size();
    1526                 :         47 :                         correction_offset -= n;
    1527                 :            :                     }
    1528                 :         76 :                     break;
    1529                 :         76 :                 }
    1530                 :            :             }
    1531                 :            : 
    1532         [ +  + ]:      88443 :             if (mode == IN_PHRASED_TERM) {
    1533         [ +  - ]:        328 :                 Parse(&parser, PHR_TERM, term_obj, &state);
    1534                 :            :             } else {
    1535                 :            :                 // See if the next token will be PHR_TERM - if so, this one
    1536                 :            :                 // needs to be TERM not GROUP_TERM.
    1537         [ +  + ]:     129553 :                 if ((mode == IN_GROUP || mode == IN_GROUP2) &&
           [ +  +  +  + ]
                 [ +  + ]
    1538                 :      41438 :                     is_phrase_generator(*it)) {
    1539                 :            :                     // FIXME: can we clean this up?
    1540                 :        102 :                     Utf8Iterator p = it;
    1541         [ +  + ]:        106 :                     do {
    1542                 :        106 :                         ++p;
    1543 [ +  + ][ +  + ]:        106 :                     } while (p != end && is_phrase_generator(*p));
    1544                 :            :                     // Don't generate a phrase unless the phrase generators are
    1545                 :            :                     // immediately followed by another term.
    1546 [ +  + ][ +  + ]:        102 :                     if (p != end && is_wordchar(*p)) {
                 [ +  + ]
    1547                 :        102 :                         mode = DEFAULT;
    1548                 :            :                     }
    1549                 :            :                 }
    1550                 :            : 
    1551                 :      88115 :                 int token = TERM;
    1552 [ +  + ][ +  + ]:      88115 :                 if (mode == IN_GROUP || mode == IN_GROUP2) {
    1553                 :      41392 :                     mode = IN_GROUP2;
    1554                 :      41392 :                     token = GROUP_TERM;
    1555                 :            :                 }
    1556         [ +  - ]:      88115 :                 Parse(&parser, token, term_obj, &state);
    1557 [ +  + ][ +  + ]:      88115 :                 if (token == TERM && mode != DEFAULT)
    1558   [ +  +  +  + ]:      89171 :                     continue;
    1559                 :      87800 :             }
    1560                 :            :         }
    1561                 :            : 
    1562         [ +  + ]:      89171 :         if (it == end) break;
    1563                 :            : 
    1564         [ +  + ]:      83249 :         if (is_phrase_generator(*it)) {
    1565                 :            :             // Skip multiple phrase generators.
    1566         [ +  + ]:        479 :             do {
    1567                 :        479 :                 ++it;
    1568 [ +  + ][ +  + ]:        479 :             } while (it != end && is_phrase_generator(*it));
    1569                 :            :             // Don't generate a phrase unless the phrase generators are
    1570                 :            :             // immediately followed by another term.
    1571 [ +  + ][ +  + ]:        438 :             if (it != end && is_wordchar(*it)) {
                 [ +  + ]
    1572                 :        328 :                 mode = IN_PHRASED_TERM;
    1573                 :        328 :                 term_start_index = it.raw() - qs.data();
    1574                 :        328 :                 goto phrased_term;
    1575                 :            :             }
    1576 [ +  + ][ +  - ]:      82811 :         } else if (mode == DEFAULT || mode == IN_GROUP || mode == IN_GROUP2) {
                 [ +  + ]
    1577                 :      82629 :             int old_mode = mode;
    1578                 :      82629 :             mode = DEFAULT;
    1579 [ +  + ][ +  + ]:      82629 :             if (!last_was_operator_needing_term && is_whitespace(*it)) {
                 [ +  + ]
    1580                 :      82065 :                 newprev = ' ';
    1581                 :            :                 // Skip multiple whitespace.
    1582         [ +  + ]:      82080 :                 do {
    1583                 :      82080 :                     ++it;
    1584 [ +  + ][ +  + ]:      82080 :                 } while (it != end && is_whitespace(*it));
    1585                 :            :                 // Don't generate a group unless the terms are only separated
    1586                 :            :                 // by whitespace.
    1587 [ +  + ][ +  + ]:      82065 :                 if (it != end && is_wordchar(*it)) {
                 [ +  + ]
    1588 [ +  - ][ +  + ]:      41627 :                     if (old_mode == IN_GROUP || old_mode == IN_GROUP2) {
    1589                 :      40816 :                         mode = IN_GROUP2;
    1590                 :            :                     } else {
    1591   [ +  +  +  +  :      89343 :                         mode = IN_GROUP;
                   +  + ]
    1592                 :            :                     }
    1593                 :            :                 }
    1594                 :            :             }
    1595                 :            :         }
    1596                 :      82921 :     }
    1597                 :            : done:
    1598         [ +  + ]:      64446 :     if (!state.error) {
    1599                 :            :         // Implicitly close any unclosed quotes.
    1600 [ +  + ][ -  + ]:      64320 :         if (mode == IN_QUOTES || mode == IN_PREFIXED_QUOTES)
    1601         [ +  - ]:         33 :             Parse(&parser, QUOTE, NULL, &state);
    1602                 :            : 
    1603                 :            :         // Implicitly close all unclosed brackets.
    1604         [ +  + ]:      64338 :         while (prefix_stack.size() > 1) {
    1605         [ +  - ]:         18 :             Parse(&parser, KET, NULL, &state);
    1606                 :         18 :             prefix_stack.pop_back();
    1607                 :            :         }
    1608         [ +  - ]:      64320 :         Parse(&parser, 0, NULL, &state);
    1609                 :            :     }
    1610                 :            : 
    1611                 :      64446 :     errmsg = state.error;
    1612         [ +  - ]:     128905 :     return state.query;
    1613                 :            : }
    1614                 :            : 
    1615                 :            : }
    1616                 :            : %include {
    1617                 :            : 
    1618                 :            : struct ProbQuery {
    1619                 :            :     Query* query = NULL;
    1620                 :            :     Query* love = NULL;
    1621                 :            :     Query* hate = NULL;
    1622                 :            :     // filter is a map from prefix to a query for that prefix.  Queries with
    1623                 :            :     // the same prefix are combined with OR, and the results of this are
    1624                 :            :     // combined with AND to get the full filter.
    1625                 :            :     map<string, Query> filter;
    1626                 :            : 
    1627                 :      37630 :     ProbQuery() {}
    1628                 :            : 
    1629                 :            :     explicit
    1630                 :       1472 :     ProbQuery(Query* query_) : query(query_) {}
    1631                 :            : 
    1632                 :      39102 :     ~ProbQuery() {
    1633         [ +  + ]:      19551 :         delete query;
    1634         [ +  + ]:      19551 :         delete love;
    1635         [ +  + ]:      19551 :         delete hate;
    1636                 :      19551 :     }
    1637                 :            : 
    1638                 :         60 :     void add_filter(const string& grouping, const Query & q) {
    1639                 :         60 :         filter[grouping] = q;
    1640                 :         60 :     }
    1641                 :            : 
    1642                 :         34 :     void append_filter(const string& grouping, const Query & qnew) {
    1643         [ +  - ]:         34 :         auto it = filter.find(grouping);
    1644         [ +  + ]:         34 :         if (it == filter.end()) {
    1645 [ +  - ][ +  - ]:         23 :             filter.insert(make_pair(grouping, qnew));
    1646                 :            :         } else {
    1647                 :         11 :             Query & q = it->second;
    1648                 :            :             // We OR multiple filters with the same prefix if they're
    1649                 :            :             // exclusive, otherwise we AND them.
    1650                 :         11 :             bool exclusive = !grouping.empty();
    1651         [ +  + ]:         11 :             if (exclusive) {
    1652         [ +  - ]:          8 :                 q |= qnew;
    1653                 :            :             } else {
    1654         [ +  - ]:          3 :                 q &= qnew;
    1655                 :            :             }
    1656                 :            :         }
    1657                 :         34 :     }
    1658                 :            : 
    1659                 :      18657 :     void add_filter_range(const string& grouping, const Query & range) {
    1660                 :      18657 :         filter[grouping] = range;
    1661                 :      18657 :     }
    1662                 :            : 
    1663                 :         14 :     void append_filter_range(const string& grouping, const Query & range) {
    1664                 :         14 :         Query & q = filter[grouping];
    1665                 :         14 :         q |= range;
    1666                 :         14 :     }
    1667                 :            : 
    1668                 :      18743 :     Query merge_filters() const {
    1669                 :      18743 :         auto i = filter.begin();
    1670                 :            :         Assert(i != filter.end());
    1671         [ +  - ]:      18743 :         Query q = i->second;
    1672         [ +  + ]:      18755 :         while (++i != filter.end()) {
    1673         [ +  - ]:         12 :             q &= i->second;
    1674                 :            :         }
    1675                 :      18743 :         return q;
    1676                 :            :     }
    1677                 :            : };
    1678                 :            : 
    1679                 :            : /// A group of terms separated only by whitespace.
    1680                 :            : class TermGroup {
    1681                 :            :     vector<Term *> terms;
    1682                 :            : 
    1683                 :            :     /** Controls how to handle a group where all terms are stopwords.
    1684                 :            :      *
    1685                 :            :      *  If true, then as_group() returns NULL.  If false, then the
    1686                 :            :      *  stopword status of the terms is ignored.
    1687                 :            :      */
    1688                 :            :     bool empty_ok;
    1689                 :            : 
    1690                 :       1200 :     TermGroup(Term* t1, Term* t2) : empty_ok(false) {
    1691         [ +  - ]:        600 :         add_term(t1);
    1692         [ +  - ]:        600 :         add_term(t2);
    1693                 :        600 :     }
    1694                 :            : 
    1695                 :            :   public:
    1696                 :            :     /// Factory function - ensures heap allocation.
    1697                 :        600 :     static TermGroup* create(Term* t1, Term* t2) {
    1698         [ +  - ]:        600 :         return new TermGroup(t1, t2);
    1699                 :            :     }
    1700                 :            : 
    1701                 :       1200 :     ~TermGroup() {
    1702         [ +  + ]:      42592 :         for (auto&& t : terms) {
    1703         [ +  - ]:      41992 :             delete t;
    1704                 :            :         }
    1705                 :        600 :     }
    1706                 :            : 
    1707                 :            :     /// Add a Term object to this TermGroup object.
    1708                 :      41992 :     void add_term(Term * term) {
    1709                 :      41992 :         terms.push_back(term);
    1710                 :      41992 :     }
    1711                 :            : 
    1712                 :            :     /// Set the empty_ok flag.
    1713                 :         40 :     void set_empty_ok() { empty_ok = true; }
    1714                 :            : 
    1715                 :            :     /// Convert to a Xapian::Query * using default_op.
    1716                 :            :     Query * as_group(State *state) const;
    1717                 :            : };
    1718                 :            : 
    1719                 :            : Query *
    1720                 :        600 : TermGroup::as_group(State *state) const
    1721                 :            : {
    1722         [ +  - ]:        600 :     const Xapian::Stopper * stopper = state->get_stopper();
    1723                 :        600 :     size_t stoplist_size = state->stoplist_size();
    1724                 :        600 :     bool default_op_is_positional = is_positional(state->default_op());
    1725                 :            : reprocess:
    1726                 :        602 :     Query::op default_op = state->default_op();
    1727                 :        602 :     vector<Query> subqs;
    1728         [ +  - ]:        602 :     subqs.reserve(terms.size());
    1729         [ +  + ]:        602 :     if (state->flags & QueryParser::FLAG_AUTO_MULTIWORD_SYNONYMS) {
    1730                 :            :         // Check for multi-word synonyms.
    1731         [ +  - ]:         38 :         Database db = state->get_database();
    1732                 :            : 
    1733         [ +  - ]:         76 :         string key;
    1734                 :         38 :         vector<Term*>::const_iterator begin = terms.begin();
    1735                 :         38 :         vector<Term*>::const_iterator i = begin;
    1736         [ +  + ]:      20612 :         while (i != terms.end()) {
    1737         [ +  - ]:      20574 :             TermIterator synkey(db.synonym_keys_begin((*i)->name));
    1738         [ +  + ]:      41148 :             TermIterator synend(db.synonym_keys_end((*i)->name));
    1739         [ +  + ]:      20574 :             if (synkey == synend) {
    1740                 :            :                 // No multi-synonym matches.
    1741 [ -  + ][ #  # ]:      10004 :                 if (stopper && (*stopper)((*i)->name)) {
         [ #  # ][ -  + ]
    1742         [ #  # ]:          0 :                     state->add_to_stoplist(*i);
    1743                 :            :                 } else {
    1744         [ -  + ]:      10004 :                     if (default_op_is_positional)
    1745                 :          0 :                         (*i)->need_positions();
    1746 [ +  - ][ +  - ]:      10004 :                     subqs.push_back((*i)->get_query_with_auto_synonyms());
    1747                 :            :                 }
    1748                 :      10004 :                 begin = ++i;
    1749                 :      10004 :                 continue;
    1750                 :            :             }
    1751         [ +  - ]:      10570 :             key.resize(0);
    1752         [ +  + ]:      38394 :             while (i != terms.end()) {
    1753 [ +  + ][ +  - ]:      37978 :                 if (!key.empty()) key += ' ';
    1754         [ +  - ]:      37978 :                 key += (*i)->name;
    1755                 :      37978 :                 ++i;
    1756         [ +  - ]:      37978 :                 synkey.skip_to(key);
    1757 [ +  + ][ +  - ]:      37978 :                 if (synkey == synend || !startswith(*synkey, key)) break;
         [ -  + ][ +  + ]
         [ +  + ][ #  # ]
    1758                 :            :             }
    1759                 :            :             // Greedily try to match as many consecutive words as possible.
    1760 [ +  - ][ +  + ]:      31144 :             TermIterator syn, end;
    1761                 :            :             while (true) {
    1762 [ +  - ][ +  - ]:      28524 :                 syn = db.synonyms_begin(key);
    1763         [ +  - ]:      28524 :                 end = db.synonyms_end(key);
    1764         [ +  + ]:      28524 :                 if (syn != end) break;
    1765         [ -  + ]:      17954 :                 if (--i == begin) break;
    1766         [ +  - ]:      17954 :                 key.resize(key.size() - (*i)->name.size() - 1);
    1767                 :            :             }
    1768         [ -  + ]:      10570 :             if (i == begin) {
    1769                 :            :                 // No multi-synonym matches.
    1770 [ #  # ][ #  # ]:          0 :                 if (stopper && (*stopper)((*i)->name)) {
         [ #  # ][ #  # ]
    1771         [ #  # ]:          0 :                     state->add_to_stoplist(*i);
    1772                 :            :                 } else {
    1773         [ #  # ]:          0 :                     if (default_op_is_positional)
    1774                 :          0 :                         (*i)->need_positions();
    1775 [ #  # ][ #  # ]:          0 :                     subqs.push_back((*i)->get_query_with_auto_synonyms());
    1776                 :            :                 }
    1777                 :          0 :                 begin = ++i;
    1778                 :          0 :                 continue;
    1779                 :            :             }
    1780                 :            : 
    1781         [ +  - ]:      21140 :             vector<Query> subqs2;
    1782                 :      10570 :             vector<Term*>::const_iterator j;
    1783         [ +  + ]:      30594 :             for (j = begin; j != i; ++j) {
    1784 [ -  + ][ #  # ]:      20024 :                 if (stopper && (*stopper)((*j)->name)) {
         [ #  # ][ -  + ]
    1785         [ #  # ]:          0 :                     state->add_to_stoplist(*j);
    1786                 :            :                 } else {
    1787         [ -  + ]:      20024 :                     if (default_op_is_positional)
    1788                 :          0 :                         (*i)->need_positions();
    1789 [ +  - ][ +  - ]:      20024 :                     subqs2.push_back((*j)->get_query());
    1790                 :            :                 }
    1791                 :            :             }
    1792                 :      21140 :             Query q_original_terms;
    1793         [ -  + ]:      10570 :             if (default_op_is_positional) {
    1794         [ #  # ]:          0 :                 q_original_terms = Query(default_op,
    1795                 :            :                                          subqs2.begin(), subqs2.end(),
    1796         [ #  # ]:          0 :                                          subqs2.size() + 9);
    1797                 :            :             } else {
    1798         [ +  - ]:      21140 :                 q_original_terms = Query(default_op,
    1799         [ +  - ]:      10570 :                                          subqs2.begin(), subqs2.end());
    1800                 :            :             }
    1801                 :      10570 :             subqs2.clear();
    1802                 :            : 
    1803                 :            :             // Use the position of the first term for the synonyms.
    1804                 :            :             Query q(Query::OP_SYNONYM,
    1805                 :      10570 :                     SynonymIterator(syn, (*begin)->pos, &q_original_terms),
    1806   [ +  -  +  - ]:      31710 :                     SynonymIterator(end));
                 [ +  - ]
    1807         [ +  - ]:      10570 :             subqs.push_back(q);
    1808                 :            : 
    1809                 :      10570 :             begin = i;
    1810                 :      20612 :         }
    1811                 :            :     } else {
    1812                 :        564 :         vector<Term*>::const_iterator i;
    1813         [ +  + ]:      12533 :         for (i = terms.begin(); i != terms.end(); ++i) {
    1814 [ +  + ][ +  - ]:      11969 :             if (stopper && (*stopper)((*i)->name)) {
         [ +  + ][ +  + ]
    1815         [ +  - ]:        148 :                 state->add_to_stoplist(*i);
    1816                 :            :             } else {
    1817         [ +  + ]:      11821 :                 if (default_op_is_positional)
    1818                 :         32 :                     (*i)->need_positions();
    1819 [ +  - ][ +  - ]:      11821 :                 subqs.push_back((*i)->get_query_with_auto_synonyms());
    1820                 :            :             }
    1821                 :            :         }
    1822                 :            :     }
    1823                 :            : 
    1824 [ +  + ][ +  + ]:        604 :     if (!empty_ok && stopper && subqs.empty() &&
           [ +  +  +  - ]
                 [ +  + ]
    1825                 :          2 :         stoplist_size < state->stoplist_size()) {
    1826                 :            :         // This group is all stopwords, so roll-back, disable stopper
    1827                 :            :         // temporarily, and reprocess this group.
    1828         [ +  - ]:          2 :         state->stoplist_resize(stoplist_size);
    1829                 :          2 :         stopper = NULL;
    1830                 :          2 :         goto reprocess;
    1831                 :            :     }
    1832                 :            : 
    1833                 :        600 :     Query * q = NULL;
    1834         [ +  + ]:        600 :     if (!subqs.empty()) {
    1835         [ +  + ]:        570 :         if (default_op_is_positional) {
    1836                 :            :             q = new Query(default_op, subqs.begin(), subqs.end(),
    1837 [ +  - ][ +  - ]:         12 :                              subqs.size() + 9);
    1838                 :            :         } else {
    1839 [ +  - ][ +  - ]:        570 :             q = new Query(default_op, subqs.begin(), subqs.end());
    1840                 :            :         }
    1841                 :            :     }
    1842         [ +  - ]:        600 :     delete this;
    1843         [ +  + ]:        602 :     return q;
    1844                 :            : }
    1845                 :            : 
    1846                 :            : /// Some terms which form a positional sub-query.
    1847                 :            : class Terms {
    1848                 :            :     vector<Term *> terms;
    1849                 :            :     size_t window;
    1850                 :            : 
    1851                 :            :     /** Keep track of whether the terms added all have the same list of
    1852                 :            :      *  prefixes.  If so, we'll build a set of phrases, one using each prefix.
    1853                 :            :      *  This works around the limitation that a phrase cannot have multiple
    1854                 :            :      *  components which are "OR" combinations of terms, but is also probably
    1855                 :            :      *  what users expect: i.e., if a user specifies a phrase in a field, and
    1856                 :            :      *  that field maps to multiple prefixes, the user probably wants a phrase
    1857                 :            :      *  returned with all terms having one of those prefixes, rather than a
    1858                 :            :      *  phrase comprised of terms with differing prefixes.
    1859                 :            :      */
    1860                 :            :     bool uniform_prefixes;
    1861                 :            : 
    1862                 :            :     /** The list of prefixes of the terms added.
    1863                 :            :      *  This will be NULL if the terms have different prefixes.
    1864                 :            :      */
    1865                 :            :     const list<string> * prefixes;
    1866                 :            : 
    1867                 :            :     /// Convert to a query using the given operator and window size.
    1868                 :        443 :     Query * as_opwindow_query(Query::op op, Xapian::termcount w_delta) const {
    1869                 :        443 :         Query * q = NULL;
    1870                 :        443 :         size_t n_terms = terms.size();
    1871                 :        443 :         Xapian::termcount w = w_delta + terms.size();
    1872         [ +  + ]:        443 :         if (uniform_prefixes) {
    1873         [ +  - ]:        442 :             if (prefixes) {
    1874                 :        442 :                 list<string>::const_iterator piter;
    1875         [ +  + ]:        888 :                 for (piter = prefixes->begin(); piter != prefixes->end(); ++piter) {
    1876                 :        446 :                     vector<Query> subqs;
    1877         [ +  - ]:        446 :                     subqs.reserve(n_terms);
    1878                 :        446 :                     vector<Term *>::const_iterator titer;
    1879         [ +  + ]:       1646 :                     for (titer = terms.begin(); titer != terms.end(); ++titer) {
    1880                 :       1200 :                         Term * t = *titer;
    1881 [ +  - ][ +  - ]:       1200 :                         subqs.push_back(Query(t->make_term(*piter), 1, t->pos));
                 [ +  - ]
    1882                 :            :                     }
    1883                 :            :                     add_to_query(q, Query::OP_OR,
    1884 [ +  - ][ +  - ]:        446 :                                  Query(op, subqs.begin(), subqs.end(), w));
    1885                 :        446 :                 }
    1886                 :            :             }
    1887                 :            :         } else {
    1888                 :          1 :             vector<Query> subqs;
    1889         [ +  - ]:          1 :             subqs.reserve(n_terms);
    1890                 :          1 :             vector<Term *>::const_iterator titer;
    1891         [ +  + ]:          3 :             for (titer = terms.begin(); titer != terms.end(); ++titer) {
    1892 [ +  - ][ +  - ]:          2 :                 subqs.push_back((*titer)->get_query());
    1893                 :            :             }
    1894 [ +  - ][ +  - ]:          1 :             q = new Query(op, subqs.begin(), subqs.end(), w);
    1895                 :            :         }
    1896                 :            : 
    1897         [ +  - ]:        443 :         delete this;
    1898                 :        443 :         return q;
    1899                 :            :     }
    1900                 :            : 
    1901                 :        892 :     Terms() : window(0), uniform_prefixes(true), prefixes(NULL) { }
    1902                 :            : 
    1903                 :            :   public:
    1904                 :            :     /// Factory function - ensures heap allocation.
    1905                 :        446 :     static Terms* create() {
    1906                 :        446 :         return new Terms();
    1907                 :            :     }
    1908                 :            : 
    1909                 :        892 :     ~Terms() {
    1910         [ +  + ]:       1649 :         for (auto&& t : terms) {
    1911         [ +  - ]:       1203 :             delete t;
    1912                 :            :         }
    1913                 :        446 :     }
    1914                 :            : 
    1915                 :            :     /// Add an unstemmed Term object to this Terms object.
    1916                 :       1203 :     void add_positional_term(Term * term) {
    1917                 :       1203 :         const list<string> & term_prefixes = term->field_info->prefixes;
    1918         [ +  + ]:       1203 :         if (terms.empty()) {
    1919                 :        446 :             prefixes = &term_prefixes;
    1920 [ +  - ][ +  + ]:        757 :         } else if (uniform_prefixes && prefixes != &term_prefixes) {
    1921         [ +  - ]:          1 :             if (*prefixes != term_prefixes)  {
    1922                 :          1 :                 prefixes = NULL;
    1923                 :          1 :                 uniform_prefixes = false;
    1924                 :            :             }
    1925                 :            :         }
    1926                 :       1203 :         term->need_positions();
    1927                 :       1203 :         terms.push_back(term);
    1928                 :       1203 :     }
    1929                 :            : 
    1930                 :          4 :     void adjust_window(size_t alternative_window) {
    1931         [ +  - ]:          4 :         if (alternative_window > window) window = alternative_window;
    1932                 :          4 :     }
    1933                 :            : 
    1934                 :            :     /// Convert to a Xapian::Query * using adjacent OP_PHRASE.
    1935                 :        430 :     Query * as_phrase_query() const {
    1936                 :        430 :         return as_opwindow_query(Query::OP_PHRASE, 0);
    1937                 :            :     }
    1938                 :            : 
    1939                 :            :     /// Convert to a Xapian::Query * using OP_NEAR.
    1940                 :          9 :     Query * as_near_query() const {
    1941                 :            :         // The common meaning of 'a NEAR b' is "a within 10 terms of b", which
    1942                 :            :         // means a window size of 11.  For more than 2 terms, we just add one
    1943                 :            :         // to the window size for each extra term.
    1944                 :          9 :         size_t w = window;
    1945         [ +  + ]:          9 :         if (w == 0) w = 10;
    1946                 :          9 :         return as_opwindow_query(Query::OP_NEAR, w - 1);
    1947                 :            :     }
    1948                 :            : 
    1949                 :            :     /// Convert to a Xapian::Query * using OP_PHRASE to implement ADJ.
    1950                 :          4 :     Query * as_adj_query() const {
    1951                 :            :         // The common meaning of 'a ADJ b' is "a at most 10 terms before b",
    1952                 :            :         // which means a window size of 11.  For more than 2 terms, we just add
    1953                 :            :         // one to the window size for each extra term.
    1954                 :          4 :         size_t w = window;
    1955         [ +  + ]:          4 :         if (w == 0) w = 10;
    1956                 :          4 :         return as_opwindow_query(Query::OP_PHRASE, w - 1);
    1957                 :            :     }
    1958                 :            : };
    1959                 :            : 
    1960                 :            : void
    1961                 :          3 : Term::as_positional_cjk_term(Terms * terms) const
    1962                 :            : {
    1963                 :            : #ifdef USE_ICU
    1964                 :            :     if (state->flags & QueryParser::FLAG_CJK_WORDS) {
    1965                 :            :         for (CJKWordIterator tk(name); tk != CJKWordIterator(); ++tk) {
    1966                 :            :             const string& t = *tk;
    1967                 :            :             Term * c = new Term(state, t, field_info, unstemmed, stem, pos);
    1968                 :            :             terms->add_positional_term(c);
    1969                 :            :         }
    1970                 :            :         delete this;
    1971                 :            :         return;
    1972                 :            :     }
    1973                 :            : #endif
    1974                 :            :     // Add each individual CJK character to the phrase.
    1975         [ +  - ]:          3 :     string t;
    1976         [ +  + ]:          9 :     for (Utf8Iterator it(name); it != Utf8Iterator(); ++it) {
    1977         [ +  - ]:          6 :         Unicode::append_utf8(t, *it);
    1978 [ +  - ][ +  - ]:          6 :         Term * c = new Term(state, t, field_info, unstemmed, stem, pos);
    1979         [ +  - ]:          6 :         terms->add_positional_term(c);
    1980         [ +  - ]:          6 :         t.resize(0);
    1981                 :            :     }
    1982                 :            : 
    1983                 :            :     // FIXME: we want to add the n-grams as filters too for efficiency.
    1984                 :            : 
    1985         [ +  - ]:          3 :     delete this;
    1986                 :          3 : }
    1987                 :            : 
    1988                 :            : // Helper macro to check for missing arguments to a boolean operator.
    1989                 :            : #define VET_BOOL_ARGS(A, B, OP_TXT) \
    1990                 :            :     do {\
    1991                 :            :         if (!A || !B) {\
    1992                 :            :             state->error = "Syntax: <expression> " OP_TXT " <expression>";\
    1993                 :            :             yy_parse_failed(yypParser);\
    1994                 :            :             return;\
    1995                 :            :         }\
    1996                 :            :     } while (0)
    1997                 :            : 
    1998                 :            : }
    1999                 :            : 
    2000                 :            : %token_type {Term *}
    2001         [ +  + ]:       1442 : %token_destructor { delete $$; }
    2002                 :            : 
    2003                 :            : %extra_argument {State * state}
    2004                 :            : 
    2005                 :            : %parse_failure {
    2006                 :            :     // If we've not already set an error message, set a default one.
    2007         [ +  + ]:        156 :     if (!state->error) state->error = "parse error";
    2008                 :            : }
    2009                 :            : 
    2010                 :            : %syntax_error {
    2011                 :        115 :     yy_parse_failed(yypParser);
    2012                 :            : }
    2013                 :            : 
    2014                 :            : // Operators, grouped in order of increasing precedence:
    2015                 :            : %nonassoc ERROR.
    2016                 :            : %left OR.
    2017                 :            : %left XOR.
    2018                 :            : %left AND NOT.
    2019                 :            : %left NEAR ADJ.
    2020                 :            : %left LOVE HATE HATE_AFTER_AND SYNONYM.
    2021                 :            : 
    2022                 :            : // Destructors for terminal symbols:
    2023                 :            : 
    2024                 :            : // TERM is a query term, including prefix (if any).
    2025                 :            : %destructor TERM { delete $$; }
    2026                 :            : 
    2027                 :            : // GROUP_TERM is a query term which follows a TERM or another GROUP_TERM and
    2028                 :            : // is only separated by whitespace characters.
    2029                 :            : %destructor GROUP_TERM { delete $$; }
    2030                 :            : 
    2031                 :            : // PHR_TERM is a query term which follows a TERM or another PHR_TERM and is
    2032                 :            : // separated only by one or more phrase generator characters (hyphen and
    2033                 :            : // apostrophe are common examples - see is_phrase_generator() for the list
    2034                 :            : // of all punctuation which does this).
    2035                 :            : %destructor PHR_TERM { delete $$; }
    2036                 :            : 
    2037                 :            : // EDIT_TERM is like a TERM, but with an edit distance.
    2038                 :            : %destructor EDIT_TERM { delete $$; }
    2039                 :            : 
    2040                 :            : // WILD_TERM is like a TERM, but with wildcards which needs to be expanded.
    2041                 :            : %destructor WILD_TERM { delete $$; }
    2042                 :            : 
    2043                 :            : // PARTIAL_TERM is like a TERM, but it's at the end of the query string and
    2044                 :            : // we're doing "search as you type".  It expands to something like:
    2045                 :            : //     WILD_TERM($$+"*") OR stemmed_form
    2046                 :            : %destructor PARTIAL_TERM { delete $$; }
    2047                 :            : 
    2048                 :            : // BOOLEAN_FILTER is a query term with a prefix registered using
    2049                 :            : // add_boolean_prefix().  It's added to the query using an OP_FILTER operator,
    2050                 :            : // (or OP_AND_NOT if it's negated) e.g. site:xapian.org or -site:xapian.org
    2051                 :            : %destructor BOOLEAN_FILTER { delete $$; }
    2052                 :            : 
    2053                 :            : // Grammar rules:
    2054                 :            : 
    2055                 :            : // query - The whole query - just an expr or nothing.
    2056                 :            : 
    2057                 :            : // query non-terminal doesn't need a type, so just give a dummy one.
    2058                 :            : %type query {int}
    2059                 :            : 
    2060                 :            : query ::= expr(E). {
    2061                 :            :     // Save the parsed query in the State structure so we can return it.
    2062         [ +  - ]:      64282 :     if (E) {
    2063         [ +  - ]:      64282 :         state->query = *E;
    2064         [ +  - ]:      64282 :         delete E;
    2065                 :            :     } else {
    2066         [ #  # ]:          0 :         state->query = Query();
    2067                 :            :     }
    2068                 :            : }
    2069                 :            : 
    2070                 :            : query ::= . {
    2071                 :            :     // Handle a query string with no terms in.
    2072         [ +  - ]:          6 :     state->query = Query();
    2073                 :            : }
    2074                 :            : 
    2075                 :            : // expr - A query expression.
    2076                 :            : 
    2077                 :            : %type expr {Query *}
    2078         [ +  + ]:        169 : %destructor expr { delete $$; }
    2079                 :            : 
    2080                 :            : expr(E) ::= prob_expr(E).
    2081                 :            : 
    2082                 :            : expr(A) ::= bool_arg(A) AND bool_arg(B). {
    2083 [ +  - ][ +  + ]:     195313 :     VET_BOOL_ARGS(A, B, "AND");
    2084         [ +  - ]:         35 :     *A &= *B;
    2085         [ +  - ]:         35 :     delete B;
    2086                 :            : }
    2087                 :            : 
    2088                 :            : expr(A) ::= bool_arg(A) NOT bool_arg(B). {
    2089                 :            :     // 'NOT foo' -> '<alldocuments> NOT foo'
    2090 [ +  + ][ +  + ]:         22 :     if (!A && (state->flags & QueryParser::FLAG_PURE_NOT)) {
    2091 [ +  - ][ +  - ]:          2 :         A = new Query("", 1, 0);
                 [ +  - ]
    2092                 :            :     }
    2093 [ +  + ][ +  + ]:         22 :     VET_BOOL_ARGS(A, B, "NOT");
    2094         [ +  - ]:         12 :     *A &= ~*B;
    2095         [ +  - ]:         12 :     delete B;
    2096                 :            : }
    2097                 :            : 
    2098                 :            : expr(A) ::= bool_arg(A) AND NOT bool_arg(B). [NOT] {
    2099 [ +  + ][ +  + ]:         14 :     VET_BOOL_ARGS(A, B, "AND NOT");
    2100         [ +  - ]:          6 :     *A &= ~*B;
    2101         [ +  - ]:          6 :     delete B;
    2102                 :            : }
    2103                 :            : 
    2104                 :            : expr(A) ::= bool_arg(A) AND HATE_AFTER_AND bool_arg(B). [AND] {
    2105 [ +  + ][ -  + ]:          6 :     VET_BOOL_ARGS(A, B, "AND");
    2106         [ +  - ]:          5 :     *A &= ~*B;
    2107         [ +  - ]:          5 :     delete B;
    2108                 :            : }
    2109                 :            : 
    2110                 :            : expr(A) ::= bool_arg(A) OR bool_arg(B). {
    2111 [ +  + ][ -  + ]:         40 :     VET_BOOL_ARGS(A, B, "OR");
    2112         [ +  - ]:         37 :     *A |= *B;
    2113         [ +  - ]:         37 :     delete B;
    2114                 :            : }
    2115                 :            : 
    2116                 :            : expr(A) ::= bool_arg(A) XOR bool_arg(B). {
    2117 [ +  + ][ -  + ]:         12 :     VET_BOOL_ARGS(A, B, "XOR");
    2118         [ +  - ]:          9 :     *A ^= *B;
    2119         [ +  - ]:          9 :     delete B;
    2120                 :            : }
    2121                 :            : 
    2122                 :            : // bool_arg - an argument to a boolean operator such as AND or OR.
    2123                 :            : 
    2124                 :            : %type bool_arg {Query *}
    2125                 :            : %destructor bool_arg { delete $$; }
    2126                 :            : 
    2127                 :            : bool_arg(A) ::= expr(A).
    2128                 :            : 
    2129                 :            : bool_arg(A) ::= . [ERROR] {
    2130                 :            :     // Set the argument to NULL, which enables the bool_arg-using rules in
    2131                 :            :     // expr above to report uses of AND, OR, etc which don't have two
    2132                 :            :     // arguments.
    2133                 :         42 :     A = NULL;
    2134                 :            : }
    2135                 :            : 
    2136                 :            : // prob_expr - a single compound term, or a prob.
    2137                 :            : 
    2138                 :            : %type prob_expr {Query *}
    2139                 :            : %destructor prob_expr { delete $$; }
    2140                 :            : 
    2141                 :            : prob_expr(E) ::= prob(P). {
    2142                 :      19541 :     E = P->query;
    2143                 :      19541 :     P->query = NULL;
    2144                 :            :     // Handle any "+ terms".
    2145         [ +  + ]:      19541 :     if (P->love) {
    2146         [ -  + ]:        102 :         if (P->love->empty()) {
    2147                 :            :             // +<nothing>.
    2148         [ #  # ]:          0 :             delete E;
    2149                 :          0 :             E = P->love;
    2150         [ +  + ]:        102 :         } else if (E) {
    2151                 :         75 :             swap(E, P->love);
    2152         [ +  - ]:         75 :             add_to_query(E, Query::OP_AND_MAYBE, P->love);
    2153                 :            :         } else {
    2154                 :         27 :             E = P->love;
    2155                 :            :         }
    2156                 :        102 :         P->love = NULL;
    2157                 :            :     }
    2158                 :            :     // Handle any boolean filters.
    2159         [ +  + ]:      19541 :     if (!P->filter.empty()) {
    2160         [ +  + ]:      18743 :         if (E) {
    2161 [ +  - ][ +  - ]:         30 :             add_to_query(E, Query::OP_FILTER, P->merge_filters());
    2162                 :            :         } else {
    2163                 :            :             // Make the query a boolean one.
    2164 [ +  - ][ +  - ]:      18743 :             E = new Query(Query::OP_SCALE_WEIGHT, P->merge_filters(), 0.0);
                 [ +  - ]
    2165                 :            :         }
    2166                 :            :     }
    2167                 :            :     // Handle any "- terms".
    2168 [ +  + ][ +  - ]:      19541 :     if (P->hate && !P->hate->empty()) {
                 [ +  + ]
    2169         [ +  + ]:         81 :         if (!E) {
    2170                 :            :             // Can't just hate!
    2171                 :          4 :             yy_parse_failed(yypParser);
    2172                 :          4 :             return;
    2173                 :            :         }
    2174 [ +  - ][ +  - ]:         77 :         *E = Query(Query::OP_AND_NOT, *E, *P->hate);
    2175                 :            :     }
    2176         [ +  - ]:      19537 :     delete P;
    2177                 :            : }
    2178                 :            : 
    2179                 :            : prob_expr(E) ::= term(E).
    2180                 :            : 
    2181                 :            : // prob - a sub-expression consisting of stop_terms, "+" terms, "-" terms,
    2182                 :            : // boolean filters, and/or ranges.
    2183                 :            : //
    2184                 :            : // Note: stop_term can also be several other things other than a simple term!
    2185                 :            : 
    2186                 :            : %type prob {ProbQuery *}
    2187         [ +  - ]:         14 : %destructor prob { delete $$; }
    2188                 :            : 
    2189                 :            : prob(P) ::= RANGE(R). {
    2190         [ +  - ]:      18657 :     string grouping = R->name;
    2191         [ +  - ]:      37314 :     const Query & range = R->as_range_query();
    2192 [ +  - ][ +  - ]:      18657 :     P = new ProbQuery; /*P-overwrites-R*/
    2193         [ +  - ]:      37314 :     P->add_filter_range(grouping, range);
    2194                 :            : }
    2195                 :            : 
    2196                 :            : prob(P) ::= stop_prob(P) RANGE(R). {
    2197         [ +  - ]:         14 :     string grouping = R->name;
    2198         [ +  - ]:         28 :     const Query & range = R->as_range_query();
    2199         [ +  - ]:         28 :     P->append_filter_range(grouping, range);
    2200                 :            : }
    2201                 :            : 
    2202                 :            : prob(P) ::= stop_term(T) stop_term(U). {
    2203 [ +  - ][ +  - ]:        610 :     P = new ProbQuery(T); /*P-overwrites-T*/
    2204         [ +  - ]:        610 :     if (U) {
    2205                 :        610 :         Query::op op = state->default_op();
    2206 [ +  + ][ -  + ]:        610 :         if (P->query && is_positional(op)) {
                 [ -  + ]
    2207                 :            :             // If default_op is OP_NEAR or OP_PHRASE, set the window size to
    2208                 :            :             // 11 for the first pair of terms and it will automatically grow
    2209                 :            :             // by one for each subsequent term.
    2210                 :          0 :             Query * subqs[2] = { P->query, U };
    2211 [ #  # ][ #  # ]:          0 :             *(P->query) = Query(op, subqs, subqs + 2, 11);
    2212         [ #  # ]:          0 :             delete U;
    2213                 :            :         } else {
    2214         [ +  - ]:        610 :             add_to_query(P->query, op, U);
    2215                 :            :         }
    2216                 :            :     }
    2217                 :            : }
    2218                 :            : 
    2219                 :            : prob(P) ::= prob(P) stop_term(T). {
    2220                 :            :     // If T is a stopword, there's nothing to do here.
    2221 [ +  - ][ +  - ]:        447 :     if (T) add_to_query(P->query, state->default_op(), T);
    2222                 :            : }
    2223                 :            : 
    2224                 :            : prob(P) ::= LOVE term(T). {
    2225 [ +  - ][ +  - ]:         76 :     P = new ProbQuery;
    2226         [ +  + ]:         76 :     if (state->default_op() == Query::OP_AND) {
    2227                 :          6 :         P->query = T;
    2228                 :            :     } else {
    2229                 :         70 :         P->love = T;
    2230                 :            :     }
    2231                 :            : }
    2232                 :            : 
    2233                 :            : prob(P) ::= stop_prob(P) LOVE term(T). {
    2234         [ +  + ]:         66 :     if (state->default_op() == Query::OP_AND) {
    2235                 :            :         /* The default op is AND, so we just put loved terms into the query
    2236                 :            :          * (in this case the only effect of love is to ignore the stopword
    2237                 :            :          * list). */
    2238         [ +  - ]:          7 :         add_to_query(P->query, Query::OP_AND, T);
    2239                 :            :     } else {
    2240         [ +  - ]:         59 :         add_to_query(P->love, Query::OP_AND, T);
    2241                 :            :     }
    2242                 :            : }
    2243                 :            : 
    2244                 :            : prob(P) ::= HATE term(T). {
    2245 [ +  - ][ +  - ]:         20 :     P = new ProbQuery;
    2246                 :         20 :     P->hate = T;
    2247                 :            : }
    2248                 :            : 
    2249                 :            : prob(P) ::= stop_prob(P) HATE term(T). {
    2250         [ +  - ]:         68 :     add_to_query(P->hate, Query::OP_OR, T);
    2251                 :            : }
    2252                 :            : 
    2253                 :            : prob(P) ::= HATE BOOLEAN_FILTER(T). {
    2254 [ +  - ][ +  - ]:          1 :     P = new ProbQuery;
    2255 [ +  - ][ +  - ]:          1 :     P->hate = new Query(T->get_query());
    2256         [ +  - ]:          1 :     delete T;
    2257                 :            : }
    2258                 :            : 
    2259                 :            : prob(P) ::= stop_prob(P) HATE BOOLEAN_FILTER(T). {
    2260 [ +  - ][ +  - ]:          4 :     add_to_query(P->hate, Query::OP_OR, T->get_query());
    2261         [ +  - ]:          4 :     delete T;
    2262                 :            : }
    2263                 :            : 
    2264                 :            : prob(P) ::= BOOLEAN_FILTER(T). {
    2265 [ +  - ][ +  - ]:         60 :     P = new ProbQuery;
    2266 [ +  - ][ +  - ]:         60 :     P->add_filter(T->get_grouping(), T->get_query());
                 [ +  - ]
    2267         [ +  - ]:         60 :     delete T;
    2268                 :            : }
    2269                 :            : 
    2270                 :            : prob(P) ::= stop_prob(P) BOOLEAN_FILTER(T). {
    2271 [ +  - ][ +  - ]:         34 :     P->append_filter(T->get_grouping(), T->get_query());
                 [ +  - ]
    2272         [ +  - ]:         34 :     delete T;
    2273                 :            : }
    2274                 :            : 
    2275                 :            : prob(P) ::= LOVE BOOLEAN_FILTER(T). {
    2276                 :            :     // LOVE BOOLEAN_FILTER(T) is just the same as BOOLEAN_FILTER
    2277 [ +  - ][ +  - ]:          1 :     P = new ProbQuery;
    2278 [ +  - ][ +  - ]:          1 :     P->filter[T->get_grouping()] = T->get_query();
         [ +  - ][ +  - ]
    2279         [ +  - ]:          1 :     delete T;
    2280                 :            : }
    2281                 :            : 
    2282                 :            : prob(P) ::= stop_prob(P) LOVE BOOLEAN_FILTER(T). {
    2283                 :            :     // LOVE BOOLEAN_FILTER(T) is just the same as BOOLEAN_FILTER
    2284                 :            :     // We OR filters with the same prefix...
    2285 [ +  - ][ +  - ]:          3 :     Query & q = P->filter[T->get_grouping()];
    2286 [ +  - ][ +  - ]:          3 :     q |= T->get_query();
    2287         [ +  - ]:          3 :     delete T;
    2288                 :            : }
    2289                 :            : 
    2290                 :            : // stop_prob - A prob or a stop_term.
    2291                 :            : 
    2292                 :            : %type stop_prob {ProbQuery *}
    2293                 :            : %destructor stop_prob { delete $$; }
    2294                 :            : 
    2295                 :            : stop_prob(P) ::= prob(P).
    2296                 :            : 
    2297                 :            : stop_prob(P) ::= stop_term(T). {
    2298 [ +  - ][ +  - ]:        126 :     P = new ProbQuery(T); /*P-overwrites-T*/
    2299                 :            : }
    2300                 :            : 
    2301                 :            : // stop_term - A term which should be checked against the stopword list,
    2302                 :            : // or a compound_term.
    2303                 :            : //
    2304                 :            : // If a term is loved, hated, or in a phrase, we don't want to consult the
    2305                 :            : // stopword list, so stop_term isn't used there (instead term is).
    2306                 :            : 
    2307                 :            : %type stop_term {Query *}
    2308                 :            : %destructor stop_term { delete $$; }
    2309                 :            : 
    2310                 :            : stop_term(T) ::= TERM(U). {
    2311 [ +  - ][ +  + ]:        804 :     if (state->is_stopword(U)) {
    2312                 :         10 :         T = NULL;
    2313         [ +  - ]:         10 :         state->add_to_stoplist(U);
    2314                 :            :     } else {
    2315 [ +  - ][ +  - ]:        794 :         T = new Query(U->get_query_with_auto_synonyms());
    2316                 :            :     }
    2317         [ +  - ]:        804 :     delete U;
    2318                 :            : }
    2319                 :            : 
    2320                 :            : stop_term(T) ::= compound_term(T).
    2321                 :            : 
    2322                 :            : // term - A term or a compound_term.
    2323                 :            : 
    2324                 :            : %type term {Query *}
    2325                 :            : %destructor term { delete $$; }
    2326                 :            : 
    2327                 :            : term(T) ::= TERM(U). {
    2328 [ +  - ][ +  - ]:      44410 :     T = new Query(U->get_query_with_auto_synonyms());
    2329         [ +  - ]:      44410 :     delete U;
    2330                 :            : }
    2331                 :            : 
    2332                 :            : term(T) ::= compound_term(T).
    2333                 :            : 
    2334                 :            : // compound_term - A WILD_TERM, a quoted phrase (with or without prefix), a
    2335                 :            : // phrased_term, group, near_expr, adj_expr, or a bracketed subexpression (with
    2336                 :            : // or without prefix).
    2337                 :            : 
    2338                 :            : %type compound_term {Query *}
    2339                 :            : %destructor compound_term { delete $$; }
    2340                 :            : 
    2341                 :            : compound_term(T) ::= EDIT_TERM(U).
    2342         [ +  - ]:        103 :         { T = U->as_fuzzy_query(state); /*T-overwrites-U*/ }
    2343                 :            : 
    2344                 :            : compound_term(T) ::= WILD_TERM(U).
    2345         [ +  - ]:        376 :         { T = U->as_wildcarded_query(state); /*T-overwrites-U*/ }
    2346                 :            : 
    2347                 :            : compound_term(T) ::= PARTIAL_TERM(U).
    2348         [ +  - ]:        202 :         { T = U->as_partial_query(state); /*T-overwrites-U*/ }
    2349                 :            : 
    2350                 :            : compound_term(T) ::= QUOTE phrase(P) QUOTE.
    2351         [ +  - ]:        201 :         { T = P->as_phrase_query(); }
    2352                 :            : 
    2353                 :            : compound_term(T) ::= phrased_term(P).
    2354         [ +  - ]:        229 :         { T = P->as_phrase_query(); /*T-overwrites-P*/ }
    2355                 :            : 
    2356                 :            : compound_term(T) ::= group(P).
    2357         [ +  - ]:        600 :         { T = P->as_group(state); /*T-overwrites-P*/ }
    2358                 :            : 
    2359                 :            : compound_term(T) ::= near_expr(P).
    2360         [ +  - ]:          9 :         { T = P->as_near_query(); /*T-overwrites-P*/ }
    2361                 :            : 
    2362                 :            : compound_term(T) ::= adj_expr(P).
    2363         [ +  - ]:          4 :         { T = P->as_adj_query(); /*T-overwrites-P*/ }
    2364                 :            : 
    2365                 :            : compound_term(T) ::= BRA expr(E) KET.
    2366                 :        207 :         { T = E; }
    2367                 :            : 
    2368                 :            : compound_term(T) ::= SYNONYM TERM(U). {
    2369 [ +  - ][ +  - ]:         30 :     T = new Query(U->get_query_with_synonyms());
    2370         [ +  - ]:         30 :     delete U;
    2371                 :            : }
    2372                 :            : 
    2373                 :            : compound_term(T) ::= CJKTERM(U). {
    2374         [ +  - ]:         31 :     { T = U->as_cjk_query(); /*T-overwrites-U*/ }
    2375                 :            : }
    2376                 :            : 
    2377                 :            : // phrase - The "inside the quotes" part of a double-quoted phrase.
    2378                 :            : 
    2379                 :            : %type phrase {Terms *}
    2380                 :            : 
    2381         [ +  - ]:          3 : %destructor phrase { delete $$; }
    2382                 :            : 
    2383                 :            : phrase(P) ::= TERM(T). {
    2384         [ +  - ]:        199 :     P = Terms::create();
    2385         [ +  - ]:        199 :     P->add_positional_term(T);
    2386                 :            : }
    2387                 :            : 
    2388                 :            : phrase(P) ::= CJKTERM(T). {
    2389         [ +  - ]:          2 :     P = Terms::create();
    2390         [ +  - ]:          2 :     T->as_positional_cjk_term(P);
    2391                 :            : }
    2392                 :            : 
    2393                 :            : phrase(P) ::= phrase(P) TERM(T). {
    2394         [ +  - ]:        505 :     P->add_positional_term(T);
    2395                 :            : }
    2396                 :            : 
    2397                 :            : phrase(P) ::= phrase(P) CJKTERM(T). {
    2398         [ +  - ]:          1 :     T->as_positional_cjk_term(P);
    2399                 :            : }
    2400                 :            : 
    2401                 :            : // phrased_term - A phrased term works like a single term, but is actually
    2402                 :            : // 2 or more terms linked together into a phrase by punctuation.  There must be
    2403                 :            : // at least 2 terms in order to be able to have punctuation between the terms!
    2404                 :            : 
    2405                 :            : %type phrased_term {Terms *}
    2406                 :            : %destructor phrased_term { delete $$; }
    2407                 :            : 
    2408                 :            : phrased_term(P) ::= TERM(T) PHR_TERM(U). {
    2409         [ +  - ]:        232 :     P = Terms::create();
    2410         [ +  - ]:        232 :     P->add_positional_term(T);
    2411         [ +  - ]:        232 :     P->add_positional_term(U);
    2412                 :            : }
    2413                 :            : 
    2414                 :            : phrased_term(P) ::= phrased_term(P) PHR_TERM(T). {
    2415                 :            :     P->add_positional_term(T);
    2416                 :            : }
    2417                 :            : 
    2418                 :            : // group - A group of terms separated only by whitespace - candidates for
    2419                 :            : // multi-term synonyms.
    2420                 :            : 
    2421                 :            : %type group {TermGroup *}
    2422         [ #  # ]:          0 : %destructor group { delete $$; }
    2423                 :            : 
    2424                 :            : group(P) ::= TERM(T) GROUP_TERM(U). {
    2425         [ +  - ]:        600 :     P = TermGroup::create(T, U); /*P-overwrites-T*/
    2426                 :            : }
    2427                 :            : 
    2428                 :            : group(P) ::= group(P) GROUP_TERM(T). {
    2429         [ +  - ]:      40792 :     P->add_term(T);
    2430                 :            : }
    2431                 :            : 
    2432                 :            : group(P) ::= group(P) EMPTY_GROUP_OK. {
    2433                 :         40 :     P->set_empty_ok();
    2434                 :            : }
    2435                 :            : 
    2436                 :            : // near_expr - 2 or more terms with NEAR in between.  There must be at least 2
    2437                 :            : // terms in order for there to be any NEAR operators!
    2438                 :            : 
    2439                 :            : %type near_expr {Terms *}
    2440                 :            : %destructor near_expr { delete $$; }
    2441                 :            : 
    2442                 :            : near_expr(P) ::= TERM(T) NEAR(N) TERM(U). {
    2443         [ +  - ]:         13 :     P = Terms::create();
    2444         [ +  - ]:         13 :     P->add_positional_term(T);
    2445         [ +  - ]:         13 :     P->add_positional_term(U);
    2446         [ +  + ]:         13 :     if (N) {
    2447                 :          4 :         P->adjust_window(N->get_termpos());
    2448         [ +  - ]:          4 :         delete N;
    2449                 :            :     }
    2450                 :            : }
    2451                 :            : 
    2452                 :            : near_expr(P) ::= near_expr(P) NEAR(N) TERM(T). {
    2453         [ +  - ]:          3 :     P->add_positional_term(T);
    2454         [ -  + ]:          3 :     if (N) {
    2455                 :          0 :         P->adjust_window(N->get_termpos());
    2456         [ #  # ]:          0 :         delete N;
    2457                 :            :     }
    2458                 :            : }
    2459                 :            : 
    2460                 :            : // adj_expr - 2 or more terms with ADJ in between.  There must be at least 2
    2461                 :            : // terms in order for there to be any ADJ operators!
    2462                 :            : 
    2463                 :            : %type adj_expr {Terms *}
    2464                 :            : %destructor adj_expr { delete $$; }
    2465                 :            : 
    2466                 :            : adj_expr(P) ::= TERM(T) ADJ(N) TERM(U). {
    2467                 :            :     P = Terms::create();
    2468                 :            :     P->add_positional_term(T);
    2469                 :            :     P->add_positional_term(U);
    2470                 :            :     if (N) {
    2471                 :            :         P->adjust_window(N->get_termpos());
    2472                 :            :         delete N;
    2473                 :            :     }
    2474                 :            : }
    2475                 :            : 
    2476                 :            : adj_expr(P) ::= adj_expr(P) ADJ(N) TERM(T). {
    2477                 :            :     P->add_positional_term(T);
    2478                 :            :     if (N) {
    2479                 :            :         P->adjust_window(N->get_termpos());
    2480                 :            :         delete N;
    2481                 :            :     }
    2482                 :            : }
    2483                 :            : 
    2484                 :            : // Select lemon syntax highlighting in vim editor: vim: syntax=lemon

Generated by: LCOV version 1.11