ferret 0.9.6 → 0.10.0

data/ext/q_parser.c

@@ -80,19 +80,28 @@
 
 
 /* Copy the first part of user declarations.  */
-#line 1 "src/query_parser/q_parser.y"
+#line 1 "src/q_parser.y"
 
 #include <string.h>
+#include <ctype.h>
+#include <wctype.h>
 #include "search.h"
+#include "array.h"
 
 typedef struct Phrase {
-  int cnt;
-  int capa;
-  char ***words;
-  int  *w_cnt;
-  int  *w_capa;
+    int             size;
+    int             capa;
+    int             pos_inc;
+    PhrasePosition *positions;
 } Phrase;
 
+#define BCA_INIT_CAPA 4
+typedef struct BCArray {
+    int size;
+    int capa;
+    BooleanClause **clauses;
+} BCArray;
+
 
 
 /* Enabling traces.  */
@@ -114,17 +123,17 @@ typedef struct Phrase {
 #endif
 
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 14 "src/query_parser/q_parser.y"
+#line 23 "src/q_parser.y"
 typedef union YYSTYPE {
-  Query *query;
-  BooleanClause *bcls;
-  Array *array;
-  HashSet *hashset;
-  Phrase *phrase;
-  char *str;
+    Query *query;
+    BooleanClause *bcls;
+    BCArray *bclss;
+    HashSet *hashset;
+    Phrase *phrase;
+    char *str;
 } YYSTYPE;
 /* Line 196 of yacc.c.  */
-#line 128 "y.tab.c"
+#line 137 "y.tab.c"
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
@@ -133,62 +142,58 @@ typedef union YYSTYPE {
 
 
 /* Copy the second part of user declarations.  */
-#line 22 "src/query_parser/q_parser.y"
+#line 31 "src/q_parser.y"
 
-int yylex(YYSTYPE *lvalp, QParser *qp);
-int yyerror(QParser *qp, char const *msg);
+static int yylex(YYSTYPE *lvalp, QParser *qp);
+static int yyerror(QParser *qp, char const *msg);
 
 #define PHRASE_INIT_CAPA 4
-Query *get_bool_q(Array *bclauses);
+static Query *get_bool_q(BCArray *bca);
 
-Array *first_cls(BooleanClause *cls);
-Array *add_and_cls(Array *clauses, BooleanClause *cls);
-Array *add_or_cls(Array *clauses, BooleanClause *cls);
-Array *add_default_cls(QParser *qp, Array *clauses, BooleanClause *cls);
+static BCArray *first_cls(BooleanClause *boolean_clause);
+static BCArray *add_and_cls(BCArray *bca, BooleanClause *clause);
+static BCArray *add_or_cls(BCArray *bca, BooleanClause *clause);
+static BCArray *add_default_cls(QParser *qp, BCArray *bca, BooleanClause *clause);
 
-BooleanClause *get_bool_cls(Query *q, unsigned int occur);
+static BooleanClause *get_bool_cls(Query *q, unsigned int occur);
 
-Query *get_term_q(QParser *qp, char *field, char *word);
-Query *get_fuzzy_q(QParser *qp, char *field, char *word, char *slop);
-Query *get_wild_q(QParser *qp, char *field, char *pattern);
+static Query *get_term_q(QParser *qp, char *field, char *word);
+static Query *get_fuzzy_q(QParser *qp, char *field, char *word, char *slop);
+static Query *get_wild_q(QParser *qp, char *field, char *pattern);
 
-HashSet *first_field(QParser *qp, char *field);
-HashSet *add_field(QParser *qp, char *field);
+static HashSet *first_field(QParser *qp, char *field);
+static HashSet *add_field(QParser *qp, char *field);
 
-Query *get_phrase_q(QParser *qp, Phrase *phrase, char *slop);
+static Query *get_phrase_q(QParser *qp, Phrase *phrase, char *slop);
 
-Phrase *ph_first_word(char *word);
-Phrase *ph_add_word(Phrase *self, char *word);
-Phrase *ph_add_multi_word(Phrase *self, char *word);
+static Phrase *ph_first_word(char *word);
+static Phrase *ph_add_word(Phrase *self, char *word);
+static Phrase *ph_add_multi_word(Phrase *self, char *word);
 
-Query *get_range_q(char *field, char *from, char *to,
-  bool inc_lower, bool inc_upper);
+static Query *get_range_q(const char *field, const char *from, const char *to,
+                          bool inc_lower, bool inc_upper);
 
 #define FLDS(q, func) do {\
-  char *field;\
-  if (qp->fields->size == 0) {\
-    q = NULL;\
-  } else if (qp->fields->size == 1) {\
-    field = (char *)qp->fields->elems[0];\
-    q = func;\
-  } else {\
-    int i;Query *sq;\
-    q = bq_create(false);\
-    for (i = 0; i < qp->fields->size; i++) {\
-      field = (char *)qp->fields->elems[i];\
-      sq = func;\
-      if (sq) bq_add_query(q, sq, BC_SHOULD);\
-    }\
-    if (((BooleanQuery *)q->data)->clause_cnt == 0) {\
-      q_deref(q);\
-      q = NULL;\
+    char *field;\
+    if (qp->fields->size == 0) {\
+        q = NULL;\
+    } else if (qp->fields->size == 1) {\
+        field = (char *)qp->fields->elems[0];\
+        q = func;\
+    } else {\
+        int i;Query *sq;\
+        q = bq_new(false);\
+        for (i = 0; i < qp->fields->size; i++) {\
+            field = (char *)qp->fields->elems[i];\
+            sq = func;\
+            if (sq) bq_add_query_nr(q, sq, BC_SHOULD);\
+        }\
     }\
-  }\
 } while (0)
 
 
 /* Line 219 of yacc.c.  */
-#line 192 "y.tab.c"
+#line 197 "y.tab.c"
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
@@ -427,12 +432,12 @@ static const yysigned_char yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const unsigned char yyrline[] =
 {
-       0,    90,    90,    91,    93,    94,    95,    96,    98,    99,
-     100,   102,   103,   105,   106,   107,   108,   109,   110,   112,
-     113,   114,   116,   118,   118,   120,   120,   120,   123,   124,
-     126,   127,   128,   129,   131,   132,   133,   134,   135,   137,
-     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
-     148
+       0,    95,    95,    96,    98,    99,   100,   101,   103,   104,
+     105,   107,   108,   110,   111,   112,   113,   114,   115,   117,
+     118,   119,   121,   123,   123,   125,   125,   125,   128,   129,
+     131,   132,   133,   134,   136,   137,   138,   139,   140,   142,
+     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
+     153
 };
 #endif
 
@@ -1240,217 +1245,217 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-#line 90 "src/query_parser/q_parser.y"
+#line 95 "src/q_parser.y"
     { qp->result = (yyval.query) = NULL; }
     break;
 
   case 3:
-#line 91 "src/query_parser/q_parser.y"
-    { qp->result = (yyval.query) = get_bool_q((yyvsp[0].array)); }
+#line 96 "src/q_parser.y"
+    { qp->result = (yyval.query) = get_bool_q((yyvsp[0].bclss)); }
     break;
 
   case 4:
-#line 93 "src/query_parser/q_parser.y"
-    { (yyval.array) = first_cls((yyvsp[0].bcls)); }
+#line 98 "src/q_parser.y"
+    { (yyval.bclss) = first_cls((yyvsp[0].bcls)); }
     break;
 
   case 5:
-#line 94 "src/query_parser/q_parser.y"
-    { (yyval.array) = add_and_cls((yyvsp[-2].array), (yyvsp[0].bcls)); }
+#line 99 "src/q_parser.y"
+    { (yyval.bclss) = add_and_cls((yyvsp[-2].bclss), (yyvsp[0].bcls)); }
     break;
 
   case 6:
-#line 95 "src/query_parser/q_parser.y"
-    { (yyval.array) = add_or_cls((yyvsp[-2].array), (yyvsp[0].bcls)); }
+#line 100 "src/q_parser.y"
+    { (yyval.bclss) = add_or_cls((yyvsp[-2].bclss), (yyvsp[0].bcls)); }
     break;
 
   case 7:
-#line 96 "src/query_parser/q_parser.y"
-    { (yyval.array) = add_default_cls(qp, (yyvsp[-1].array), (yyvsp[0].bcls)); }
+#line 101 "src/q_parser.y"
+    { (yyval.bclss) = add_default_cls(qp, (yyvsp[-1].bclss), (yyvsp[0].bcls)); }
     break;
 
   case 8:
-#line 98 "src/query_parser/q_parser.y"
+#line 103 "src/q_parser.y"
     { (yyval.bcls) = get_bool_cls((yyvsp[0].query), BC_MUST); }
     break;
 
   case 9:
-#line 99 "src/query_parser/q_parser.y"
+#line 104 "src/q_parser.y"
     { (yyval.bcls) = get_bool_cls((yyvsp[0].query), BC_MUST_NOT); }
     break;
 
   case 10:
-#line 100 "src/query_parser/q_parser.y"
+#line 105 "src/q_parser.y"
     { (yyval.bcls) = get_bool_cls((yyvsp[0].query), BC_SHOULD); }
     break;
 
   case 12:
-#line 103 "src/query_parser/q_parser.y"
+#line 108 "src/q_parser.y"
     { if ((yyvsp[-2].query)) sscanf((yyvsp[0].str),"%f",&((yyvsp[-2].query)->boost)); (yyval.query)=(yyvsp[-2].query); }
     break;
 
   case 14:
-#line 106 "src/query_parser/q_parser.y"
-    { (yyval.query) = get_bool_q((yyvsp[-1].array)); }
+#line 111 "src/q_parser.y"
+    { (yyval.query) = get_bool_q((yyvsp[-1].bclss)); }
     break;
 
   case 19:
-#line 112 "src/query_parser/q_parser.y"
+#line 117 "src/q_parser.y"
     { FLDS((yyval.query), get_term_q(qp, field, (yyvsp[0].str))); }
     break;
 
   case 20:
-#line 113 "src/query_parser/q_parser.y"
+#line 118 "src/q_parser.y"
     { FLDS((yyval.query), get_fuzzy_q(qp, field, (yyvsp[-2].str), (yyvsp[0].str))); }
     break;
 
   case 21:
-#line 114 "src/query_parser/q_parser.y"
+#line 119 "src/q_parser.y"
     { FLDS((yyval.query), get_fuzzy_q(qp, field, (yyvsp[-1].str), NULL)); }
     break;
 
   case 22:
-#line 116 "src/query_parser/q_parser.y"
+#line 121 "src/q_parser.y"
     { FLDS((yyval.query), get_wild_q(qp, field, (yyvsp[0].str))); }
     break;
 
   case 23:
-#line 118 "src/query_parser/q_parser.y"
+#line 123 "src/q_parser.y"
     { qp->fields = qp->def_fields; }
     break;
 
   case 24:
-#line 119 "src/query_parser/q_parser.y"
+#line 124 "src/q_parser.y"
     { (yyval.query) = (yyvsp[-1].query); }
     break;
 
   case 25:
-#line 120 "src/query_parser/q_parser.y"
+#line 125 "src/q_parser.y"
     { qp->fields = qp->all_fields; }
     break;
 
   case 26:
-#line 120 "src/query_parser/q_parser.y"
+#line 125 "src/q_parser.y"
     {qp->fields = qp->def_fields;}
     break;
 
   case 27:
-#line 121 "src/query_parser/q_parser.y"
+#line 126 "src/q_parser.y"
     { (yyval.query) = (yyvsp[-1].query); }
     break;
 
   case 28:
-#line 123 "src/query_parser/q_parser.y"
+#line 128 "src/q_parser.y"
     { (yyval.hashset) = first_field(qp, (yyvsp[0].str)); }
     break;
 
   case 29:
-#line 124 "src/query_parser/q_parser.y"
+#line 129 "src/q_parser.y"
     { (yyval.hashset) = add_field(qp, (yyvsp[0].str));}
     break;
 
   case 30:
-#line 126 "src/query_parser/q_parser.y"
+#line 131 "src/q_parser.y"
     { (yyval.query) = get_phrase_q(qp, (yyvsp[-1].phrase), NULL); }
     break;
 
   case 31:
-#line 127 "src/query_parser/q_parser.y"
+#line 132 "src/q_parser.y"
     { (yyval.query) = get_phrase_q(qp, (yyvsp[-3].phrase), (yyvsp[0].str)); }
     break;
 
   case 32:
-#line 128 "src/query_parser/q_parser.y"
+#line 133 "src/q_parser.y"
     { (yyval.query) = NULL; }
     break;
 
   case 33:
-#line 129 "src/query_parser/q_parser.y"
+#line 134 "src/q_parser.y"
     { (yyval.query) = NULL; }
     break;
 
   case 34:
-#line 131 "src/query_parser/q_parser.y"
+#line 136 "src/q_parser.y"
     { (yyval.phrase) = ph_first_word((yyvsp[0].str)); }
     break;
 
   case 35:
-#line 132 "src/query_parser/q_parser.y"
+#line 137 "src/q_parser.y"
     { (yyval.phrase) = ph_first_word(NULL); }
     break;
 
   case 36:
-#line 133 "src/query_parser/q_parser.y"
+#line 138 "src/q_parser.y"
     { (yyval.phrase) = ph_add_word((yyvsp[-1].phrase), (yyvsp[0].str)); }
     break;
 
   case 37:
-#line 134 "src/query_parser/q_parser.y"
+#line 139 "src/q_parser.y"
     { (yyval.phrase) = ph_add_word((yyvsp[-2].phrase), NULL); }
     break;
 
   case 38:
-#line 135 "src/query_parser/q_parser.y"
+#line 140 "src/q_parser.y"
     { (yyval.phrase) = ph_add_multi_word((yyvsp[-2].phrase), (yyvsp[0].str));  }
     break;
 
   case 39:
-#line 137 "src/query_parser/q_parser.y"
+#line 142 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-2].str),  (yyvsp[-1].str),  true,  true)); }
     break;
 
   case 40:
-#line 138 "src/query_parser/q_parser.y"
+#line 143 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-2].str),  (yyvsp[-1].str),  true,  false)); }
     break;
 
   case 41:
-#line 139 "src/query_parser/q_parser.y"
+#line 144 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-2].str),  (yyvsp[-1].str),  false, true)); }
     break;
 
   case 42:
-#line 140 "src/query_parser/q_parser.y"
+#line 145 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-2].str),  (yyvsp[-1].str),  false, false)); }
     break;
 
   case 43:
-#line 141 "src/query_parser/q_parser.y"
+#line 146 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, NULL,(yyvsp[-1].str),  false, false)); }
     break;
 
   case 44:
-#line 142 "src/query_parser/q_parser.y"
+#line 147 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, NULL,(yyvsp[-1].str),  false, true)); }
     break;
 
   case 45:
-#line 143 "src/query_parser/q_parser.y"
+#line 148 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-1].str),  NULL,true,  false)); }
     break;
 
   case 46:
-#line 144 "src/query_parser/q_parser.y"
+#line 149 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[-1].str),  NULL,false, false)); }
     break;
 
   case 47:
-#line 145 "src/query_parser/q_parser.y"
+#line 150 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, NULL,(yyvsp[0].str),  false, false)); }
     break;
 
   case 48:
-#line 146 "src/query_parser/q_parser.y"
+#line 151 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, NULL,(yyvsp[0].str),  false, true)); }
     break;
 
   case 49:
-#line 147 "src/query_parser/q_parser.y"
+#line 152 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[0].str),  NULL,true,  false)); }
     break;
 
   case 50:
-#line 148 "src/query_parser/q_parser.y"
+#line 153 "src/q_parser.y"
     { FLDS((yyval.query), get_range_q(field, (yyvsp[0].str),  NULL,false, false)); }
     break;
 
@@ -1459,7 +1464,7 @@ yyreduce:
     }
 
 /* Line 1126 of yacc.c.  */
-#line 1463 "y.tab.c"
+#line 1468 "y.tab.c"
 
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -1727,613 +1732,682 @@ yyreturn:
 }
 
 
-#line 150 "src/query_parser/q_parser.y"
+#line 155 "src/q_parser.y"
 
 
 const char *special_char = "&:()[]{}!+\"~^-|<>=*?";
 const char *not_word =  " \t&:()[]{}!+\"~^-|<>=";
 
-int get_word(YYSTYPE *lvalp, QParser *qp)
+static int get_word(YYSTYPE *lvalp, QParser *qp)
 {
-  bool is_wild = false;
-  int len;
-  char c;
-  char *buf = qp->buf[qp->buf_index];
-  char *bufp = buf;
-  qp->buf_index = (qp->buf_index + 1) % CONC_WORDS;
-
-  qp->qstrp--; /* need to back up one character */
-  
-  while (!strchr(not_word, (c=*qp->qstrp++))) {
-    switch (c) {
-      case '\\':
-        if ((c=*qp->qstrp) == ' ' && c != '\t' && c != '\0') {
-          *bufp++ = '\\';
-        } else {
-          *bufp++ = c;
-          qp->qstrp++;
+    bool is_wild = false;
+    int len;
+    char c;
+    char *buf = qp->buf[qp->buf_index];
+    char *bufp = buf;
+    qp->buf_index = (qp->buf_index + 1) % QP_CONC_WORDS;
+
+    qp->qstrp--; /* need to back up one character */
+    
+    while (!strchr(not_word, (c=*qp->qstrp++))) {
+        switch (c) {
+            case '\\':
+                if ((c=*qp->qstrp) == ' ' && c != '\t' && c != '\0') {
+                    *bufp++ = '\\';
+                }
+                else {
+                    *bufp++ = c;
+                    qp->qstrp++;
+                }
+                break;
+            case '*': case '?':
+                is_wild = true;
+                /* fall through */
+            default:
+                *bufp++ = c;
         }
-        break;
-      case '*': case '?':
-        is_wild = true;
-      default:
-        *bufp++ = c;
     }
-  }
-  qp->qstrp--;
-  /* check for keywords. There are only four so we have a bit of a hack which
-   * just checks for all of them. */
-  *bufp = '\0';
-  len = (int)(bufp - buf);
-  if (len == 3) {
-    if (buf[0] == 'A' && buf[1] == 'N' && buf[2] == 'D') return AND;
-    if (buf[0] == 'N' && buf[1] == 'O' && buf[2] == 'T') return NOT;
-    if (buf[0] == 'R' && buf[1] == 'E' && buf[2] == 'Q') return REQ;
-  }
-  if (len == 2 && buf[0] == 'O' && buf[1] == 'R') return OR;
-
-  /* found a word so return it. */
-  lvalp->str = buf;
-  if (is_wild) return WILD_STR;
-  return WORD;
+    qp->qstrp--;
+    /* check for keywords. There are only four so we have a bit of a hack which
+     * just checks for all of them. */
+    *bufp = '\0';
+    len = (int)(bufp - buf);
+    if (len == 3) {
+        if (buf[0] == 'A' && buf[1] == 'N' && buf[2] == 'D') return AND;
+        if (buf[0] == 'N' && buf[1] == 'O' && buf[2] == 'T') return NOT;
+        if (buf[0] == 'R' && buf[1] == 'E' && buf[2] == 'Q') return REQ;
+    }
+    if (len == 2 && buf[0] == 'O' && buf[1] == 'R') return OR;
+
+    /* found a word so return it. */
+    lvalp->str = buf;
+    if (is_wild) return WILD_STR;
+    return WORD;
 }
 
-int yylex(YYSTYPE *lvalp, QParser *qp)
+static int yylex(YYSTYPE *lvalp, QParser *qp)
 {
-  char c, nc;
+    char c, nc;
 
-  while ((c=*qp->qstrp++) == ' ' || c == '\t')
-    ;
-  if (c == '\0')
-    return 0;
+    while ((c=*qp->qstrp++) == ' ' || c == '\t') {
+    }
 
-  if (strchr(special_char, c)) {   /* comment */
-    nc = *qp->qstrp;
-    switch (c) {
-      case '-': case '!': return NOT;
-      case '+': return REQ;
-      case '*':
-        if (nc == ':') return c;
-        break;
-      case '&':
-        if (nc == '&') {
-          qp->qstrp++;
-          return AND;
+    if (c == '\0') return 0;
+
+    if (strchr(special_char, c)) {   /* comment */
+        nc = *qp->qstrp;
+        switch (c) {
+            case '-': case '!': return NOT;
+            case '+': return REQ;
+            case '*':
+                if (nc == ':') return c;
+                break;
+            case '&':
+                if (nc == '&') {
+                    qp->qstrp++;
+                    return AND;
+                }
+                break; /* Don't return single & character. Use in word. */
+            case '|':
+                if (nc == '|') {
+                    qp->qstrp++;
+                    return OR;
+                }
+            default:
+                return c;
         }
-        break; /* Don't return single & character. Use in word. */
-      case '|':
-        if (nc == '|') {
-          qp->qstrp++;
-          return OR;
-        }
-      default:
-        return c;
     }
-  }
 
-  return get_word(lvalp, qp);
+    return get_word(lvalp, qp);
 }
 
-int yyerror(QParser *qp, char const *msg)
+static int yyerror(QParser *qp, char const *msg)
 {
-  if (!qp->handle_parse_errors) {
-    if (qp->clean_str) free(qp->qstr);
-    RAISE(PARSE_ERROR, (char *)msg);
-  }
-  return 0;
+    if (!qp->handle_parse_errors) {
+        char buf[1024];
+        buf[1023] = '\0';
+        strncpy(buf, qp->qstr, 1023);
+        if (qp->clean_str) {
+            free(qp->qstr);
+        }
+        mutex_unlock(&qp->mutex);
+        RAISE(PARSE_ERROR, "couldn't parse query ``%s''. Error message "
+              " was %se", buf, (char *)msg);
+    }
+    return 0;
 }
 
+#define BQ(query) ((BooleanQuery *)(query))
 
-Query *get_bool_q(Array *bclauses)
+static TokenStream *get_cached_ts(QParser *qp, char *field, char *text)
 {
-  Query *q;
-  BooleanQuery *bq;
-  BooleanClause *bc;
-
-  if (bclauses->size == 0) {
-    ary_destroy(bclauses);
-    q = NULL;
-  } else if (bclauses->size == 1) {
-    bc = (BooleanClause *)bclauses->elems[0];
-    q = bc->query;
-    free(bc);
-    ary_destroy(bclauses);
-  } else {
-    q = bq_create(false);
-    /* copy clauses into query */
-    bq = (BooleanQuery *)q->data;
-    bq->clause_cnt = bclauses->size;
-    bq->clause_capa = bclauses->allocated;
-    free(bq->clauses);
-    bq->clauses = (BooleanClause **)bclauses->elems;
-    free(bclauses);
-  }
-  return q;
+    TokenStream *ts = h_get(qp->ts_cache, field);
+    if (!ts) {
+        ts = a_get_ts(qp->analyzer, field, text);
+        h_set(qp->ts_cache, estrdup(field), ts);
+    }
+    else {
+        ts->reset(ts, text);
+    }
+    return ts;
 }
 
-
-Array *first_cls(BooleanClause *cls)
+static char *get_cached_field(HashTable *field_cache, const char *field)
 {
-  Array *clauses = ary_create(0, NULL);
-  if (cls) ary_append(clauses, cls);
-  return clauses;
+    char *cached_field = h_get(field_cache, field);
+    if (!cached_field) {
+        cached_field = estrdup(field);
+        h_set(field_cache, cached_field, cached_field);
+    }
+    return cached_field;
 }
 
-Array *add_and_cls(Array *clauses, BooleanClause *clause)
+static Query *get_bool_q(BCArray *bca)
 {
-  if (clause) {
-    BooleanClause *last_cl;
-    if (clauses->size == 1) {
-      last_cl = clauses->elems[0];
-      if (!last_cl->is_prohibited)  bc_set_occur(last_cl, BC_MUST);
-    }
+    Query *q;
+    const int clause_count = bca->size;
 
-    if (!clause->is_prohibited) bc_set_occur(clause, BC_MUST);
-    ary_append(clauses, clause);
-  }
-  return clauses;
+    if (clause_count == 0) {
+        q = NULL;
+        free(bca->clauses);
+    }
+    else if (clause_count == 1) {
+        BooleanClause *bc = bca->clauses[0];
+        q = bc->query;
+        free(bc);
+        free(bca->clauses);
+    }
+    else {
+        q = bq_new(false);
+        /* copy clauses into query */
+
+        BQ(q)->clause_cnt = clause_count;
+        BQ(q)->clause_capa = bca->capa;
+        free(BQ(q)->clauses);
+        BQ(q)->clauses = bca->clauses;
+    }
+    free(bca);
+    return q;
 }
 
-Array *add_or_cls(Array *clauses, BooleanClause *clause)
+static void bca_add_clause(BCArray *bca, BooleanClause *clause)
 {
-  if (clause) ary_append(clauses, clause);
-  return clauses;
+    if (bca->size >= bca->capa) {
+        bca->capa <<= 1;
+        REALLOC_N(bca->clauses, BooleanClause *, bca->capa);
+    }
+    bca->clauses[bca->size] = clause;
+    bca->size++;
 }
 
-Array *add_default_cls(QParser *qp, Array *clauses, BooleanClause *clause)
+static BCArray *first_cls(BooleanClause *clause)
 {
-  if (qp->or_default) {
-    add_or_cls(clauses, clause);
-  } else {
-    add_and_cls(clauses, clause);
-  }
-  return clauses;
+    BCArray *bca = ALLOC_AND_ZERO(BCArray);
+    bca->capa = BCA_INIT_CAPA;
+    bca->clauses = ALLOC_N(BooleanClause *, BCA_INIT_CAPA);
+    if (clause) {
+        bca_add_clause(bca, clause);
+    }
+    return bca;
 }
 
-BooleanClause *get_bool_cls(Query *q, unsigned int occur)
+static BCArray *add_and_cls(BCArray *bca, BooleanClause *clause)
 {
-  if (q) return bc_create(q, occur);
-  else return NULL;
+    if (clause) {
+        if (bca->size == 1) {
+            if (!bca->clauses[0]->is_prohibited) {
+                bc_set_occur(bca->clauses[0], BC_MUST);
+            }
+        }
+        if (!clause->is_prohibited) {
+            bc_set_occur(clause, BC_MUST);
+        }
+        bca_add_clause(bca, clause);
+    }
+    return bca;
 }
 
-Query *get_term_q(QParser *qp, char *field, char *word)
+static BCArray *add_or_cls(BCArray *bca, BooleanClause *clause)
 {
-  Query *q;
-  Token *token;
-  TokenStream *stream = a_get_ts(qp->analyzer, field, word);
-
-  if ((token = ts_next(stream)) == NULL) {
-    q = NULL;
-  } else {
-    Term *term = term_create(field, token->text);
-    if ((token = ts_next(stream)) == NULL) {
-      q = tq_create(term);
-    } else {
-      q = phq_create();
-      phq_add_term(q, term, 0);
-      do {
-        phq_add_term(q, term_create(field, token->text), token->pos_inc);
-      } while ((token = ts_next(stream)) != NULL);
+    if (clause) {
+        bca_add_clause(bca, clause);
     }
-  }
-  return q;
+    return bca;
 }
 
-Query *get_fuzzy_q(QParser *qp, char *field, char *word, char *slop_str)
+static BCArray *add_default_cls(QParser *qp, BCArray *bca,
+                                BooleanClause *clause)
 {
-  Query *q;
-  Token *token;
-  TokenStream *stream = a_get_ts(qp->analyzer, field, word);
-
-  if ((token = ts_next(stream)) == NULL) {
-    q = NULL;
-  } else {
-    /* it only makes sense to find one term in a fuzzy query */
-    Term *term = term_create(field, token->text);
-    if (slop_str) {
-      float slop;
-      sscanf(slop_str, "%f", &slop);
-      q = fuzq_create_mp(term, slop, DEF_PRE_LEN);
-    } else {
-      q = fuzq_create(term);
+    if (qp->or_default) {
+        add_or_cls(bca, clause);
+    }
+    else {
+        add_and_cls(bca, clause);
     }
-  }
-  return q;
+    return bca;
 }
 
-Query *get_wild_q(QParser *qp, char *field, char *pattern)
+static BooleanClause *get_bool_cls(Query *q, unsigned int occur)
 {
-  Query *q;
-  bool is_prefix = false;
-  char *p;
-  int len = (int)strlen(pattern);
-
-  if (qp->wild_lower) lower_str(pattern);
-  
-  /* simplify the wildcard query to a prefix query if possible. Basically a
-   * prefix query is any wildcard query that has a '*' as the last character
-   * and no other wildcard characters before it. */
-  if (pattern[len-1] == '*') {
-    is_prefix = true;
-    for (p = &pattern[len-2]; p >= pattern; p--) {
-      if (*p == '*' || *p == '?') {
-        is_prefix = false;
-        break;
-      }
+    if (q) {
+        return bc_new(q, occur);
+    }
+    else {
+        return NULL;
     }
-  }
-  
-  if (is_prefix) {
-    /* chop off the '*' temporarily to create the query */
-    pattern[len-1] = 0;
-    q = prefixq_create(term_create(field, pattern));;
-    pattern[len-1] = '*';
-  } else {
-    q = wcq_create(term_create(field, pattern));;
-  }
-  return q;
 }
 
-HashSet *add_field(QParser *qp, char *field)
+static Query *get_term_q(QParser *qp, char *field, char *word)
 {
-  char *orig_field;
-  if ((orig_field = hs_orig(qp->all_fields, field)) != NULL) {
-    hs_add(qp->fields, orig_field);
-  } else if (qp->allow_any_fields) {
-    field = estrdup(field);
-    hs_add(qp->all_fields, field);
-    hs_add(qp->fields, field);
-  }
-  return qp->fields;
+    Query *q;
+    Token *token;
+    TokenStream *stream = get_cached_ts(qp, field, word);
+
+    if ((token = ts_next(stream)) == NULL) {
+        q = NULL;
+    }
+    else {
+        q = tq_new(field, token->text);
+        if ((token = ts_next(stream)) != NULL) {
+            /* Less likely case, destroy the term query and create a 
+             * phrase query instead */
+            Query *phq = phq_new(field);
+            phq_add_term(phq, ((TermQuery *)q)->term, 0);
+            q->destroy_i(q);
+            q = phq;
+            do {
+                phq_add_term(q, token->text, token->pos_inc);
+            } while ((token = ts_next(stream)) != NULL);
+        }
+    }
+    return q;
 }
 
-HashSet *first_field(QParser *qp, char *field)
+static Query *get_fuzzy_q(QParser *qp, char *field, char *word, char *slop_str)
 {
-  qp->fields = qp->fields_buf;
-  qp->fields->size = 0;
-  h_clear(qp->fields->ht);
-  return add_field(qp, field);
+    Query *q;
+    Token *token;
+    TokenStream *stream = get_cached_ts(qp, field, word);
+
+    if ((token = ts_next(stream)) == NULL) {
+        q = NULL;
+    }
+    else {
+        /* it only makes sense to find one term in a fuzzy query */
+        float slop = DEF_MIN_SIM;
+        if (slop_str) {
+            sscanf(slop_str, "%f", &slop);
+        }
+        q = fuzq_new_conf(field, token->text, slop, DEF_PRE_LEN,
+                          qp->max_clauses);
+    }
+    return q;
 }
 
-void ph_destroy(Phrase *self)
+static char *lower_str(char *str)
 {
-  int i, j;
-  for (i = 0; i < self->cnt; i++) {
-    for (j = 0; j < self->w_cnt[i]; j++) {
-      free(self->words[i][j]);
+    const int max_len = (int)strlen(str) + 1;
+    int cnt;
+    wchar_t *wstr = ALLOC_N(wchar_t, max_len);
+    if ((cnt = mbstowcs(wstr, str, max_len)) > 0) {
+        wchar_t *w = wstr;
+        while (*w) {
+            *w = towlower(*w);
+            w++;
+        }
+        wcstombs(str, wstr, max_len);
     }
-    free(self->words[i]);
-  }
-  free(self->words);
-  free(self->w_cnt);
-  free(self->w_capa);
-  free(self);
+    else {
+        char *s = str;
+        while (*s) {
+            *s = tolower(*s);
+            s++;
+        }
+    }
+    free(wstr);
+    str[max_len] = '\0';
+    return str;
 }
 
-
-Phrase *ph_create()
+static Query *get_wild_q(QParser *qp, char *field, char *pattern)
 {
-  Phrase *self = ALLOC(Phrase);
-  self->cnt = 0;
-  self->capa = PHRASE_INIT_CAPA;
-  self->words = ALLOC_N(char **, PHRASE_INIT_CAPA);
-  self->w_cnt = ALLOC_N(int, PHRASE_INIT_CAPA);
-  self->w_capa = ALLOC_N(int, PHRASE_INIT_CAPA);
-  return self;
+    Query *q;
+    bool is_prefix = false;
+    char *p;
+    int len = (int)strlen(pattern);
+
+    if (qp->wild_lower) {
+        lower_str(pattern);
+    }
+    
+    /* simplify the wildcard query to a prefix query if possible. Basically a
+     * prefix query is any wildcard query that has a '*' as the last character
+     * and no other wildcard characters before it. */
+    if (pattern[len - 1] == '*') {
+        is_prefix = true;
+        for (p = &pattern[len - 2]; p >= pattern; p--) {
+            if (*p == '*' || *p == '?') {
+                is_prefix = false;
+                break;
+            }
+        }
+    }
+    if (is_prefix) {
+        /* chop off the '*' temporarily to create the query */
+        pattern[len - 1] = 0;
+        q = prefixq_new(field, pattern);
+        pattern[len - 1] = '*';
+    }
+    else {
+        q = wcq_new(field, pattern);
+    }
+    MTQMaxTerms(q) = qp->max_clauses;
+    return q;
 }
 
-Phrase *ph_first_word(char *word)
+static HashSet *add_field(QParser *qp, char *field)
 {
-  Phrase *self = ph_create();
-  if (word) { /* no point in adding NULL in start */
-    self->words[0] = ALLOC(char *);
-    self->words[0][0] = estrdup(word);
-    self->w_cnt[0] = self->w_capa[0] = 1;
-    self->cnt = 1;
-  }
-  return self;
+    if (qp->allow_any_fields || hs_exists(qp->all_fields, field)) {
+        hs_add(qp->fields, get_cached_field(qp->field_cache, field));
+    }
+    return qp->fields;
 }
 
-Phrase *ph_add_word(Phrase *self, char *word)
+static HashSet *first_field(QParser *qp, char *field)
 {
-  int i;
-  if (self->cnt == self->capa) {
-    self->capa <<= 1;
-    REALLOC_N(self->words, char **, self->capa);
-    REALLOC_N(self->w_cnt, int, self->capa);
-    REALLOC_N(self->w_capa, int, self->capa);
-  }
-  i = self->cnt;
-  self->cnt++;
-  self->words[i] = ALLOC(char *);
-  self->words[i][0] = word ? estrdup(word) : NULL;
-  self->w_cnt[i] = self->w_capa[i] = 1;
-  return self;
+    qp->fields = qp->fields_buf;
+    qp->fields->size = 0;
+    h_clear(qp->fields->ht);
+    return add_field(qp, field);
 }
 
-Phrase *ph_add_multi_word(Phrase *self, char *word)
+static void ph_destroy(Phrase *self)
 {
-  int i = self->cnt - 1;
+    int i;
+    for (i = 0; i < self->size; i++) {
+        ary_destroy(self->positions[i].terms, &free);
+    }
+    free(self->positions);
+    free(self);
+}
 
-  if (!word) return self; /* no point in adding NULL in multi */
 
-  if (self->w_cnt[i] >= self->w_capa[i]) {
-    self->w_capa[i] <<= 1;
-    REALLOC_N(self->words[i], char *, self->w_capa[i]);
-  }
-  self->words[i][self->w_cnt[i]] = estrdup(word);
-  self->w_cnt[i]++;
+static Phrase *ph_new()
+{
+  Phrase *self = ALLOC_AND_ZERO(Phrase);
+  self->capa = PHRASE_INIT_CAPA;
+  self->positions = ALLOC_AND_ZERO_N(PhrasePosition, PHRASE_INIT_CAPA);
   return self;
 }
 
-Query *get_normal_phrase_query(QParser *qp, char *field, Phrase *phrase, int slop)
+static Phrase *ph_first_word(char *word)
 {
-  int pos_inc = 0;
-  int i;
-  Token *token;
-  TokenStream *stream;
-  char *word;
-
-  Query *pq = phq_create();
-  ((PhraseQuery *)pq->data)->slop = slop;
-
-  for (i = 0; i < phrase->cnt; i++) {
-    word = phrase->words[i][0];
-    if (!word) {
-      pos_inc++;
-    } else {
-      stream = a_get_ts(qp->analyzer, field, word);
-      while ((token = ts_next(stream))) {
-        phq_add_term(pq, term_create(field, token->text),
-                     token->pos_inc + pos_inc);
-        pos_inc = 0;
-      }
+    Phrase *self = ph_new();
+    if (word) { /* no point in adding NULL in start */
+        self->positions[0].terms = ary_new_type_capa(char *, 1);
+        ary_push(self->positions[0].terms, estrdup(word));
+        self->size = 1;
     }
-  }
-  return pq;
+    return self;
 }
 
-Query *get_multi_phrase_query(QParser *qp, char *field, Phrase *phrase, int slop)
+static Phrase *ph_add_word(Phrase *self, char *word)
 {
-  int i, j;
-  int pos_inc = 0;
-  Token *token;
-  TokenStream *stream;
-  char *word;
-  Term **terms = NULL;
-  int t_cnt;
-
-  Query *mpq = mphq_create();
-  ((MultiPhraseQuery *)mpq->data)->slop = slop;
-
-  for (i = 0; i < phrase->cnt; i++) {
-    word = phrase->words[i][0];
-    if (!word) {
-      pos_inc++;
-    } else {
-      t_cnt = phrase->w_cnt[i];
-      if (t_cnt > 1) {
-        terms = ALLOC_N(Term *, t_cnt);
-        for (j = 0; j < t_cnt; j++) {
-          word = phrase->words[i][j];
-          stream = a_get_ts(qp->analyzer, field, word);
-          if ((token = ts_next(stream))) {
-            terms[j] = term_create(field, token->text);
-          } else {
-            t_cnt--; j--;
-          }
-        }
-        /* must advance at least one */
-        mphq_add_terms(mpq, terms, t_cnt, pos_inc + 1);
-      } else {
-        stream = a_get_ts(qp->analyzer, field, word);
-        while ((token = ts_next(stream))) {
-          terms = ALLOC(Term *);
-          terms[0] = term_create(field, token->text);
-          mphq_add_terms(mpq, terms, 1, token->pos_inc + pos_inc);
-          pos_inc = 0;
+    if (word) {
+        const int index = self->size;
+        PhrasePosition *pp = self->positions;
+        if (index >= self->capa) {
+            self->capa <<= 1;
+            REALLOC_N(pp, PhrasePosition, self->capa);
+            self->positions = pp;
         }
-      }
+        pp[index].pos = self->pos_inc;
+        pp[index].terms = ary_new_type_capa(char *, 1);
+        ary_push(pp[index].terms, estrdup(word));
+        self->size++;
+        self->pos_inc = 0;
+    }
+    else {
+        self->pos_inc++;
     }
-  }
-  return mpq;
+    return self;
 }
 
-Query *get_phrase_q(QParser *qp, Phrase *phrase, char *slop_str)
+static Phrase *ph_add_multi_word(Phrase *self, char *word)
 {
-  Query *q;
-  int i, j;
-  int slop;
-
-  if (phrase->cnt == 0) {
-    q = NULL;
-  } else if (phrase->cnt == 1) {
-    if (phrase->w_cnt[0] == 1) {
-      FLDS(q, get_term_q(qp, field, phrase->words[0][0]));
-    } else {
-      Query *bq;
-      q = bq_create(false);
-      for (j = 0; j < phrase->w_cnt[0]; j++) {
-        FLDS(bq, tq_create(term_create(field, phrase->words[0][j])));
-        if (bq) bq_add_query(q, bq, BC_SHOULD);
-      }
+    const int index = self->size - 1;
+    PhrasePosition *pp = self->positions;
+
+    if (word) {
+        ary_push(pp[index].terms, estrdup(word));
     }
-  } else {
-    bool multi_phrase = false;
-    for (i = 0; i < phrase->cnt; i++) {
-      if (phrase->w_cnt[i] > 1) multi_phrase = true;
+    return self;
+}
+
+static Query *get_phrase_query(QParser *qp, char *field,
+                           Phrase *phrase, char *slop_str)
+{
+    const int pos_cnt = phrase->size;
+    Query *q = NULL;
+
+    if (pos_cnt == 1) {
+        char **words = phrase->positions[0].terms;
+        const int word_count = ary_size(words);
+        if (word_count == 1) {
+            q = get_term_q(qp, field, words[0]);
+        }
+        else {
+            int i;
+            q = bq_new(false);
+            for (i = 0; i < word_count; i++) {
+                bq_add_query_nr(q, get_term_q(qp, field, words[i]), BC_SHOULD);
+            }
+        }
     }
-    slop = qp->def_slop;
-    if (slop_str) sscanf(slop_str, "%d", &slop);
-    if (multi_phrase) {
-      FLDS(q, get_multi_phrase_query(qp, field, phrase, slop));
-    } else {
-      FLDS(q, get_normal_phrase_query(qp, field, phrase, slop));
+    else if (pos_cnt > 1) {
+        Token *token;
+        TokenStream *stream;
+        int i, j;
+        q = phq_new(field);
+        if (slop_str) {
+            int slop;
+            sscanf(slop_str,"%d",&slop);
+            ((PhraseQuery *)q)->slop = slop;
+        }
+
+        for (i = 0; i < pos_cnt; i++) {
+            int pos_inc = phrase->positions[i].pos; /* Actually holds pos_inc */
+            char **words = phrase->positions[i].terms;
+            const int word_count = ary_size(words);
+            
+            if (word_count == 1) {
+                stream = get_cached_ts(qp, field, words[0]);
+                while ((token = ts_next(stream))) {
+                    phq_add_term(q, token->text, token->pos_inc + pos_inc);
+                    pos_inc = 0;
+                }
+            }
+            else {
+                bool added_position = false;
+
+                for (j = 0; j < word_count; j++) {
+                    stream = get_cached_ts(qp, field, words[j]);
+                    if ((token = ts_next(stream))) {
+                        if (!added_position) {
+                            phq_add_term(q, token->text, token->pos_inc + pos_inc);
+                            added_position = true;
+                        }
+                        else {
+                            phq_append_multi_term(q, token->text);
+                        }
+                    }
+                }
+            }
+        }
     }
-  }
-  ph_destroy(phrase);
-  return q;
+    return q;
+}
+
+static Query *get_phrase_q(QParser *qp, Phrase *phrase, char *slop_str)
+{
+    Query *q;
+    FLDS(q, get_phrase_query(qp, field, phrase, slop_str));
+    ph_destroy(phrase);
+    return q;
 }
 
-Query *get_range_q(char *field, char *from, char *to, bool inc_lower, bool inc_upper)
+static Query *get_range_q(const char *field, const char *from, const char *to,
+                          bool inc_lower, bool inc_upper)
 {
-  return rq_create(field, from, to, inc_lower, inc_upper);
+    return rq_new(field, from, to, inc_lower, inc_upper);
 }
 
 void qp_destroy(QParser *self)
 {
-  if (self->close_def_fields) hs_destroy_all(self->def_fields);
-  hs_destroy_all(self->all_fields);
-  hs_destroy(self->fields_buf);
-  a_deref(self->analyzer);
-  free(self);
+    if (self->close_def_fields) {
+        hs_destroy(self->def_fields);
+    }
+    hs_destroy(self->all_fields);
+    hs_destroy(self->fields_buf);
+    h_destroy(self->field_cache);
+    h_destroy(self->ts_cache);
+    a_deref(self->analyzer);
+    free(self);
 }
 
-QParser *qp_create(HashSet *all_fields, HashSet *def_fields, Analyzer *analyzer)
+QParser *qp_new(HashSet *all_fields, HashSet *def_fields, Analyzer *analyzer)
 {
-  int i;
-  QParser *self = ALLOC(QParser);
-  self->or_default = true;
-  self->wild_lower = true;
-  self->clean_str = false;
-  self->handle_parse_errors = false;
-  self->allow_any_fields = false;
-  self->def_slop = 0;
-  self->fields_buf = hs_str_create(NULL);
-  self->all_fields = all_fields;
-  if (def_fields) {
-    self->def_fields = def_fields;
-    for (i = 0; i < self->def_fields->size; i++) {
-      if (!hs_exists(self->all_fields, self->def_fields->elems[i])) {
-        hs_add(self->all_fields, estrdup(self->def_fields->elems[i]));
-      }
+    int i;
+    QParser *self = ALLOC(QParser);
+    self->or_default = true;
+    self->wild_lower = true;
+    self->clean_str = false;
+    self->max_clauses = QP_MAX_CLAUSES;
+    self->handle_parse_errors = false;
+    self->allow_any_fields = false;
+    self->def_slop = 0;
+    self->fields_buf = hs_new_str(NULL);
+    self->all_fields = all_fields;
+    if (def_fields) {
+        self->def_fields = def_fields;
+        for (i = 0; i < self->def_fields->size; i++) {
+            if (!hs_exists(self->all_fields, self->def_fields->elems[i])) {
+                hs_add(self->all_fields, estrdup(self->def_fields->elems[i]));
+            }
+        }
+        self->close_def_fields = true;
     }
-    self->close_def_fields = true;
-  } else {
-    self->def_fields = all_fields;
-    self->close_def_fields = false;
-  }
-  self->fields = self->def_fields;
-  /* make sure all_fields contains the default fields */
-  self->analyzer = analyzer;
-  self->buf_index = 0;
-  return self;
+    else {
+        self->def_fields = all_fields;
+        self->close_def_fields = false;
+    }
+    self->field_cache = h_new_str((free_ft)NULL, &free);
+    for (i = 0; i < self->all_fields->size; i++) {
+        char *field = estrdup(self->all_fields->elems[i]);
+        h_set(self->field_cache, field, field);
+    }
+    self->fields = self->def_fields;
+    /* make sure all_fields contains the default fields */
+    self->analyzer = analyzer;
+    self->ts_cache = h_new_str(&free, (free_ft)&ts_deref);
+    self->buf_index = 0;
+    mutex_init(&self->mutex, NULL);
+    return self;
 }
 
 /* these chars have meaning within phrases */
 static const char *PHRASE_CHARS = "<>|\"";
 
-void str_insert(char *str, int len, char chr)
+static void str_insert(char *str, int len, char chr)
 {
-  memmove(str+1, str, len*sizeof(char));
-  *str = chr;
+    memmove(str+1, str, len*sizeof(char));
+    *str = chr;
 }
 
 char *qp_clean_str(char *str)
 {
-  int b, pb = -1;
-  int br_cnt = 0;
-  bool quote_open = false;
-  char *sp, *nsp;
-
-  /* leave a little extra */
-  char *new_str = ALLOC_N(char, strlen(str)*2 + 1);
-
-  for (sp = str, nsp = new_str; *sp; sp++) {
-    b = *sp;
-    /* ignore escaped characters */
-    if (pb == '\\') {
-      if (quote_open && strrchr(PHRASE_CHARS, b)) {
-        *nsp++ = '\\'; /* this was left off the first time through */
-      }
-
-      *nsp++ = b;
-      /* \\ has escaped itself so has no power. Assign pb random char : */
-      pb = ((b == '\\') ? ':' : b);
-      continue;
-    }
-    switch (b) {
-      case '\\':
-        if (!quote_open) /* We do our own escaping below */
-          *nsp++ = b;
-        break;
-      case '"':
-        quote_open = !quote_open;
-        *nsp++ = b;
-        break;
-      case '(':
-        if (!quote_open) {
-          br_cnt++;
-        } else {
-          *nsp++ = '\\';
-        }
-        *nsp++ = b;
-        break;
-      case ')':
-        if (!quote_open) {
-          if (br_cnt == 0) {
-            str_insert(new_str, (int)(nsp - new_str), '(');
-            nsp++;
-          } else {
-            br_cnt--;
-          }
-        } else {
-          *nsp++ = '\\';
-        }
-        *nsp++ = b;
-        break;
-      case '>':
-        if (quote_open) {
-          if (pb == '<') {
-            /* remove the escape character */
-            nsp--;
-            nsp[-1] = '<';
-          } else {
-            *nsp++ = '\\';
-          }
+    int b, pb = -1;
+    int br_cnt = 0;
+    bool quote_open = false;
+    char *sp, *nsp;
+
+    /* leave a little extra */
+    char *new_str = ALLOC_N(char, strlen(str)*2 + 1);
+
+    for (sp = str, nsp = new_str; *sp; sp++) {
+        b = *sp;
+        /* ignore escaped characters */
+        if (pb == '\\') {
+            if (quote_open && strrchr(PHRASE_CHARS, b)) {
+                *nsp++ = '\\'; /* this was left off the first time through */
+            }
+            *nsp++ = b;
+            /* \\ has escaped itself so has no power. Assign pb random char : */
+            pb = ((b == '\\') ? ':' : b);
+            continue;
         }
-        *nsp++ = b;
-        break;
-      default:
-        if (quote_open) {
-          if (strrchr(special_char, b) && b != '|') {
-            *nsp++ = '\\';
-          }
+        switch (b) {
+            case '\\':
+                if (!quote_open) { /* We do our own escaping below */
+                    *nsp++ = b;
+                }
+                break;
+            case '"':
+                quote_open = !quote_open;
+                *nsp++ = b;
+                break;
+            case '(':
+              if (!quote_open) {
+                  br_cnt++;
+              }
+              else {
+                  *nsp++ = '\\';
+              }
+              *nsp++ = b;
+              break;
+            case ')':
+                if (!quote_open) {
+                    if (br_cnt == 0) {
+                        str_insert(new_str, (int)(nsp - new_str), '(');
+                        nsp++;
+                    }
+                    else {
+                        br_cnt--;
+                    }
+                }
+                else {
+                    *nsp++ = '\\';
+                }
+                *nsp++ = b;
+                break;
+            case '>':
+                if (quote_open) {
+                    if (pb == '<') {
+                        /* remove the escape character */
+                        nsp--;
+                        nsp[-1] = '<';
+                    }
+                    else {
+                        *nsp++ = '\\';
+                    }
+                }
+                *nsp++ = b;
+                break;
+            default:
+                if (quote_open) {
+                    if (strrchr(special_char, b) && b != '|') {
+                        *nsp++ = '\\';
+                    }
+                }
+                *nsp++ = b;
         }
-        *nsp++ = b;
+        pb = b;
+    }
+    if (quote_open) {
+        *nsp++ = '"';
     }
-    pb = b;
-  }
-  if (quote_open) *nsp++ = '"';
-  for (;br_cnt > 0; br_cnt--) {
-    *nsp++ = ')';
-  }
-  *nsp = '\0';
-  return new_str;  
+    for (;br_cnt > 0; br_cnt--) {
+      *nsp++ = ')';
+    }
+    *nsp = '\0';
+    return new_str;  
 }
 
 Query *qp_get_bad_query(QParser *qp, char *str)
 {
-  Query *q;
-  FLDS(q, get_term_q(qp, field, str));
-  return q;
+    Query *q;
+    FLDS(q, get_term_q(qp, field, str));
+    return q;
 }
 
 Query *qp_parse(QParser *self, char *qstr)
 {
-  if (self->clean_str) {
-    self->qstrp = self->qstr = qp_clean_str(qstr);
-  } else {
-    self->qstrp = self->qstr = qstr;
-  }
-  self->fields = self->def_fields;
-  self->result = NULL;
-  yyparse(self);
-  if (!self->result && self->handle_parse_errors)
-    self->result = qp_get_bad_query(self, self->qstr);
-  if (!self->result) self->result = bq_create(false);
-  if (self->clean_str) free(self->qstr);
-  return self->result;
+    Query *result;
+    mutex_lock(&self->mutex);
+    if (self->clean_str) {
+        self->qstrp = self->qstr = qp_clean_str(qstr);
+    }
+    else {
+        self->qstrp = self->qstr = qstr;
+    }
+    self->fields = self->def_fields;
+    self->result = NULL;
+
+    yyparse(self);
+
+    result = self->result;
+    if (!result && self->handle_parse_errors) {
+        result = qp_get_bad_query(self, self->qstr);
+    }
+    if (!result) {
+        result = bq_new(false);
+    }
+    if (self->clean_str) {
+        free(self->qstr);
+    }
+
+    mutex_unlock(&self->mutex);
+    return result;
 }