Changeset b39568e8202274e6aed953a924659cef1f971d55

Timestamp:

04/23/08 11:17:03 (9 months ago)

Author:

David Balmain <dbalmain@…>

Parents:

3d5c1b18b9912541a77e63bdb908db34f068b328

Children:

7799d1d6f07fd24cc0cf0b784340f994374fc5b1

git-committer:

David Balmain <dbalmain@gmail.com> / 2008-04-23T11:17:03Z+1000

Message:

Added h_new_ptr to hash.h

h_new_ptr creates a Hash that users the pointer address as the hash so it is
very efficient. If you want to use this hash with strings you need to intern
the strings. To illustrate;

Hash *h = h_new_ptr(&free);
char *key1 = estrdup("key");
char *key2 = estrdup("key");
char *val = estrdup("val");

h_set(h, key1, val);
assert(NULL == h_get(key2));

Location:

c

Files:

• include/hash.h (modified) (4 diffs)
• include/intern.h (modified) (1 diff)
• include/internal.h (modified) (2 diffs)
• src/hash.c (modified) (1 diff)
• src/q_parser.c (modified) (33 diffs)
• test/test_hash.c (modified) (19 diffs)

c/include/hash.h

@@ -110 +110 @@
 
 /**
- * Create a new Hash that uses any type of object as it's key. The
+ * Create a new Hash that uses any type of object as its key. The
  * Hash will store all keys and values so if you want to destroy those
  * values when the Hash is destroyed then you should pass free functions.
@@ -131 +131 @@
 
 /**
- * Create a new Hash that uses null-terminated strings as it's keys. The
+ * Create a new Hash that uses null-terminated strings as its keys. The
  * Hash will store all keys and values so if you want to destroy those
  * values when the Hash is destroyed then you should pass free functions.
@@ -148 +148 @@
 
 /**
- * Create a new Hash that uses integers as it's keys. The
- * Hash will store all values so if you want to destroy those
- * values when the Hash is destroyed then you should pass a free function.
- * NULL will suffice otherwise.
+ * Create a new Hash that uses integers as its keys. The Hash will store all
+ * values so if you want to destroy those values when the Hash is destroyed
+ * then you should pass a free function.  NULL will suffice otherwise.
  *
  * @param free_value function to free the value stored in the Hash when
@@ -159 +158 @@
  */
 extern FrtHash *frt_h_new_int(frt_free_ft free_value);
+
+/**
+ * Create a new Hash that uses pointers as its keys. The Hash will store all
+ * values so if you want to destroy those values when the Hash is destroyed
+ * then you should pass a free function. NULL will suffice otherwise.
+ *
+ * @param free_value function to free the value stored in the Hash when
+ *    an entry is deleted, replaced or when the Hash is destroyed. If you
+ *    pass NULL in place of this parameter the value will not be destroyed.
+ * @return A newly allocated Hash
+ */
+#define frt_h_new_ptr(free_value) frt_h_new_int(free_value)
 
 /**

c/include/intern.h

@@ -6 +6 @@
 extern const char *frt_intern_and_free(char *str);
 
+#define FRT_I frt_intern
+#define FRT_IF frt_intern_and_free
+
 #endif

c/include/internal.h

@@ -73 +73 @@
 #define HAS_VARARGS                        FRT_HAS_VARARGS
 #define HS_MIN_SIZE                        FRT_HS_MIN_SIZE
+#define I                                  FRT_I
+#define IF                                 FRT_IF
 #define INDEX_ERROR                        FRT_INDEX_ERROR
 #define INDEX_INTERVAL                     FRT_INDEX_INTERVAL
@@ -524 +526 @@
 #define h_new                                   frt_h_new
 #define h_new_int                               frt_h_new_int
+#define h_new_ptr                               frt_h_new_ptr
 #define h_new_str                               frt_h_new_str
 #define h_rem                                   frt_h_rem

c/src/hash.c

@@ -199 +199 @@
 }
 
-Hash *h_new_ptr(free_ft free_key, free_ft free_value)
-{
-    Hash *self     = h_new_str(free_key, free_value);
-
-    self->lookup_i = &h_lookup_ptr;
-    self->eq_i     = NULL;
-    self->hash_i   = NULL;
-
-    return self;
-}
-
 Hash *h_new(hash_ft hash, eq_ft eq, free_ft free_key, free_ft free_value)
 {

c/src/q_parser.c

@@ -207 +207 @@
 static void qp_pop_fields(QParser *self);
 
+/**
+ * +FLDS+ calls +func+ for all fields on top of the field stack. +func+
+ * must return a query. If there is more than one field on top of FieldStack
+ * then +FLDS+ will combing all the queries returned by +func+ into a single
+ * BooleanQuery which it than assigns to +q+. If there is only one field, the
+ * return value of +func+ is assigned to +q+ directly.
+ */
 #define FLDS(q, func) do {\
     TRY {\
@@ -250 +257 @@
 
 /* Line 216 of yacc.c.  */
-#line 253 "src/q_parser.c"
+#line 260 "src/q_parser.c"
 
 #ifdef short
@@ -553 +560 @@
 static const yytype_uint16 yyrline[] =
 {
-       0,   218,   218,   219,   221,   222,   223,   224,   226,   227,
-     228,   230,   231,   233,   234,   235,   236,   237,   238,   239,
-     241,   242,   243,   245,   247,   247,   249,   249,   249,   252,
-     253,   255,   256,   257,   258,   260,   261,   262,   263,   264,
-     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
-     276,   277
+       0,   225,   225,   226,   228,   229,   230,   231,   233,   234,
+     235,   237,   238,   240,   241,   242,   243,   244,   245,   246,
+     248,   249,   250,   252,   254,   254,   256,   256,   256,   259,
+     260,   262,   263,   264,   265,   267,   268,   269,   270,   271,
+     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
+     283,   284
 };
 #endif
@@ -1217 +1224 @@
     {
       case 27: /* "bool_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1222 "src/q_parser.c"
+#line 1229 "src/q_parser.c"
         break;
       case 28: /* "bool_clss" */
-#line 215 "src/q_parser.y"
+#line 222 "src/q_parser.y"
         { if ((yyvaluep->bclss) && qp->destruct) bca_destroy((yyvaluep->bclss)); };
-#line 1227 "src/q_parser.c"
+#line 1234 "src/q_parser.c"
         break;
       case 29: /* "bool_cls" */
-#line 214 "src/q_parser.y"
+#line 221 "src/q_parser.y"
         { if ((yyvaluep->bcls) && qp->destruct) bc_deref((yyvaluep->bcls)); };
-#line 1232 "src/q_parser.c"
+#line 1239 "src/q_parser.c"
         break;
       case 30: /* "boosted_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1237 "src/q_parser.c"
+#line 1244 "src/q_parser.c"
         break;
       case 31: /* "q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1242 "src/q_parser.c"
+#line 1249 "src/q_parser.c"
         break;
       case 32: /* "term_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1247 "src/q_parser.c"
+#line 1254 "src/q_parser.c"
         break;
       case 33: /* "wild_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1252 "src/q_parser.c"
+#line 1259 "src/q_parser.c"
         break;
       case 34: /* "field_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1257 "src/q_parser.c"
+#line 1264 "src/q_parser.c"
         break;
       case 39: /* "phrase_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1262 "src/q_parser.c"
+#line 1269 "src/q_parser.c"
         break;
       case 40: /* "ph_words" */
-#line 216 "src/q_parser.y"
+#line 223 "src/q_parser.y"
         { if ((yyvaluep->phrase) && qp->destruct) ph_destroy((yyvaluep->phrase)); };
-#line 1267 "src/q_parser.c"
+#line 1274 "src/q_parser.c"
         break;
       case 41: /* "range_q" */
-#line 213 "src/q_parser.y"
+#line 220 "src/q_parser.y"
         { if ((yyvaluep->query) && qp->destruct) q_deref((yyvaluep->query)); };
-#line 1272 "src/q_parser.c"
+#line 1279 "src/q_parser.c"
         break;
 
@@ -1578 +1585 @@
     {
         case 2:
-#line 218 "src/q_parser.y"
+#line 225 "src/q_parser.y"
     {   qp->result = (yyval.query) = NULL; }
     break;
 
   case 3:
-#line 219 "src/q_parser.y"
+#line 226 "src/q_parser.y"
     { T qp->result = (yyval.query) = get_bool_q((yyvsp[(1) - (1)].bclss)); E }
     break;
 
   case 4:
-#line 221 "src/q_parser.y"
+#line 228 "src/q_parser.y"
     { T (yyval.bclss) = first_cls((yyvsp[(1) - (1)].bcls)); E }
     break;
 
   case 5:
-#line 222 "src/q_parser.y"
+#line 229 "src/q_parser.y"
     { T (yyval.bclss) = add_and_cls((yyvsp[(1) - (3)].bclss), (yyvsp[(3) - (3)].bcls)); E }
     break;
 
   case 6:
-#line 223 "src/q_parser.y"
+#line 230 "src/q_parser.y"
     { T (yyval.bclss) = add_or_cls((yyvsp[(1) - (3)].bclss), (yyvsp[(3) - (3)].bcls)); E }
     break;
 
   case 7:
-#line 224 "src/q_parser.y"
+#line 231 "src/q_parser.y"
     { T (yyval.bclss) = add_default_cls(qp, (yyvsp[(1) - (2)].bclss), (yyvsp[(2) - (2)].bcls)); E }
     break;
 
   case 8:
-#line 226 "src/q_parser.y"
+#line 233 "src/q_parser.y"
     { T (yyval.bcls) = get_bool_cls((yyvsp[(2) - (2)].query), BC_MUST); E }
     break;
 
   case 9:
-#line 227 "src/q_parser.y"
+#line 234 "src/q_parser.y"
     { T (yyval.bcls) = get_bool_cls((yyvsp[(2) - (2)].query), BC_MUST_NOT); E }
     break;
 
   case 10:
-#line 228 "src/q_parser.y"
+#line 235 "src/q_parser.y"
     { T (yyval.bcls) = get_bool_cls((yyvsp[(1) - (1)].query), BC_SHOULD); E }
     break;
 
   case 12:
-#line 231 "src/q_parser.y"
+#line 238 "src/q_parser.y"
     { T if ((yyvsp[(1) - (3)].query)) sscanf((yyvsp[(3) - (3)].str),"%f",&((yyvsp[(1) - (3)].query)->boost));  (yyval.query)=(yyvsp[(1) - (3)].query); E }
     break;
 
   case 14:
-#line 234 "src/q_parser.y"
+#line 241 "src/q_parser.y"
     { T (yyval.query) = bq_new_max(true, qp->max_clauses); E }
     break;
 
   case 15:
-#line 235 "src/q_parser.y"
+#line 242 "src/q_parser.y"
     { T (yyval.query) = get_bool_q((yyvsp[(2) - (3)].bclss)); E }
     break;
 
   case 20:
-#line 241 "src/q_parser.y"
+#line 248 "src/q_parser.y"
     { FLDS((yyval.query), get_term_q(qp, field, (yyvsp[(1) - (1)].str))); Y}
     break;
 
   case 21:
-#line 242 "src/q_parser.y"
+#line 249 "src/q_parser.y"
     { FLDS((yyval.query), get_fuzzy_q(qp, field, (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str))); Y}
     break;
 
   case 22:
-#line 243 "src/q_parser.y"
+#line 250 "src/q_parser.y"
     { FLDS((yyval.query), get_fuzzy_q(qp, field, (yyvsp[(1) - (2)].str), NULL)); Y}
     break;
 
   case 23:
-#line 245 "src/q_parser.y"
+#line 252 "src/q_parser.y"
     { FLDS((yyval.query), get_wild_q(qp, field, (yyvsp[(1) - (1)].str))); Y}
     break;
 
   case 24:
-#line 247 "src/q_parser.y"
+#line 254 "src/q_parser.y"
     { qp_pop_fields(qp); }
     break;
 
   case 25:
-#line 248 "src/q_parser.y"
+#line 255 "src/q_parser.y"
     { (yyval.query) = (yyvsp[(3) - (4)].query); }
     break;
 
   case 26:
-#line 249 "src/q_parser.y"
+#line 256 "src/q_parser.y"
     { qp_push_fields(qp, qp->all_fields, false); }
     break;
 
   case 27:
-#line 249 "src/q_parser.y"
+#line 256 "src/q_parser.y"
     { qp_pop_fields(qp); }
     break;
 
   case 28:
-#line 250 "src/q_parser.y"
+#line 257 "src/q_parser.y"
     { (yyval.query) = (yyvsp[(4) - (5)].query); }
     break;
 
   case 29:
-#line 252 "src/q_parser.y"
+#line 259 "src/q_parser.y"
     { (yyval.hashset) = first_field(qp, (yyvsp[(1) - (1)].str)); }
     break;
 
   case 30:
-#line 253 "src/q_parser.y"
+#line 260 "src/q_parser.y"
     { (yyval.hashset) = add_field(qp, (yyvsp[(3) - (3)].str));}
     break;
 
   case 31:
-#line 255 "src/q_parser.y"
+#line 262 "src/q_parser.y"
     { (yyval.query) = get_phrase_q(qp, (yyvsp[(2) - (3)].phrase), NULL); }
     break;
 
   case 32:
-#line 256 "src/q_parser.y"
+#line 263 "src/q_parser.y"
     { (yyval.query) = get_phrase_q(qp, (yyvsp[(2) - (5)].phrase), (yyvsp[(5) - (5)].str)); }
     break;
 
   case 33:
-#line 257 "src/q_parser.y"
+#line 264 "src/q_parser.y"
     { (yyval.query) = NULL; }
     break;
 
   case 34:
-#line 258 "src/q_parser.y"
+#line 265 "src/q_parser.y"
     { (yyval.query) = NULL; (void)(yyvsp[(4) - (4)].str);}
     break;
 
   case 35:
-#line 260 "src/q_parser.y"
+#line 267 "src/q_parser.y"
     { (yyval.phrase) = ph_first_word((yyvsp[(1) - (1)].str)); }
     break;
 
   case 36:
-#line 261 "src/q_parser.y"
+#line 268 "src/q_parser.y"
     { (yyval.phrase) = ph_first_word(NULL); }
     break;
 
   case 37:
-#line 262 "src/q_parser.y"
+#line 269 "src/q_parser.y"
     { (yyval.phrase) = ph_add_word((yyvsp[(1) - (2)].phrase), (yyvsp[(2) - (2)].str)); }
     break;
 
   case 38:
-#line 263 "src/q_parser.y"
+#line 270 "src/q_parser.y"
     { (yyval.phrase) = ph_add_word((yyvsp[(1) - (3)].phrase), NULL); }
     break;
 
   case 39:
-#line 264 "src/q_parser.y"
+#line 271 "src/q_parser.y"
     { (yyval.phrase) = ph_add_multi_word((yyvsp[(1) - (3)].phrase), (yyvsp[(3) - (3)].str));  }
     break;
 
   case 40:
-#line 266 "src/q_parser.y"
+#line 273 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (4)].str),  (yyvsp[(3) - (4)].str),  true,  true)); Y}
     break;
 
   case 41:
-#line 267 "src/q_parser.y"
+#line 274 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (4)].str),  (yyvsp[(3) - (4)].str),  true,  false)); Y}
     break;
 
   case 42:
-#line 268 "src/q_parser.y"
+#line 275 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (4)].str),  (yyvsp[(3) - (4)].str),  false, true)); Y}
     break;
 
   case 43:
-#line 269 "src/q_parser.y"
+#line 276 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (4)].str),  (yyvsp[(3) - (4)].str),  false, false)); Y}
     break;
 
   case 44:
-#line 270 "src/q_parser.y"
+#line 277 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, NULL,(yyvsp[(2) - (3)].str),  false, false)); Y}
     break;
 
   case 45:
-#line 271 "src/q_parser.y"
+#line 278 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, NULL,(yyvsp[(2) - (3)].str),  false, true)); Y}
     break;
 
   case 46:
-#line 272 "src/q_parser.y"
+#line 279 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (3)].str),  NULL,true,  false)); Y}
     break;
 
   case 47:
-#line 273 "src/q_parser.y"
+#line 280 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (3)].str),  NULL,false, false)); Y}
     break;
 
   case 48:
-#line 274 "src/q_parser.y"
+#line 281 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, NULL,(yyvsp[(2) - (2)].str),  false, false)); Y}
     break;
 
   case 49:
-#line 275 "src/q_parser.y"
+#line 282 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, NULL,(yyvsp[(3) - (3)].str),  false, true)); Y}
     break;
 
   case 50:
-#line 276 "src/q_parser.y"
+#line 283 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(3) - (3)].str),  NULL,true,  false)); Y}
     break;
 
   case 51:
-#line 277 "src/q_parser.y"
+#line 284 "src/q_parser.y"
     { FLDS((yyval.query), get_r_q(qp, field, (yyvsp[(2) - (2)].str),  NULL,false, false)); Y}
     break;
@@ -1799 +1806 @@
 
 /* Line 1267 of yacc.c.  */
-#line 1802 "src/q_parser.c"
+#line 1809 "src/q_parser.c"
       default: break;
     }
@@ -2013 +2020 @@
 
 
-#line 279 "src/q_parser.y"
+#line 286 "src/q_parser.y"
 
 
@@ -2019 +2026 @@
 static const char *not_word =   " \t()[]{}!\"~^|<>=";
 
+/**
+ * +get_word+ gets the next query-word from the query string. A query-word is
+ * basically a string of non-special or escaped special characters. It is
+ * Analyzer agnostic. It is up to the get_*_q methods to tokenize the word and
+ * turn it into a +Query+. See the documentation for each get_*_q method to
+ * see how it handles tokenization.
+ *
+ * Note that +get_word+ is also responsible for returning field names and
+ * matching the special tokens 'AND', 'NOT', 'REQ' and 'OR'.
+ */
 static int get_word(YYSTYPE *lvalp, QParser *qp)
 {
@@ -2062 +2079 @@
                 *bufp++ = c;
         }
-        /* we've exceeded the static buffer. switch to the dynamic
-           one. */
+        /* we've exceeded the static buffer. switch to the dynamic one. The
+         * dynamic buffer is allocated enough space to hold the whole query
+         * string so it's capacity doesn't need to be checked again once
+         * allocated. */
         if (!qp->dynbuf && ((bufp - buf) == MAX_WORD_SIZE)) {
             qp->dynbuf = ALLOC_AND_ZERO_N(char, strlen(qp->qstr) + 1);
@@ -2073 +2092 @@
 get_word_done:
     qp->qstrp--;
-    /* check for keywords. There are only four so we have a bit of a hack which
-     * just checks for all of them. */
+    /* 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);
@@ -2094 +2113 @@
 }
 
+/**
+ * +yylex+ is the lexing method called by the QueryParser. It breaks the
+ * query up into special characters;
+ * 
+ *     ( "&:()[]{}!\"~^|<>=*?+-" )
+ *
+ * and tokens; 
+ * 
+ *   - QWRD
+ *   - WILD_STR
+ *   - AND['AND', '&&']
+ *   - OR['OR', '||']
+ *   - REQ['REQ', '+']
+ *   - NOT['NOT', '-', '~']
+ *
+ * QWRD tokens are query word tokens which are made up of characters other
+ * than the special characters. They can also contain special characters when
+ * escaped with a backslash '\'. WILD_STR is the same as QWRD except that it
+ * may also contain '?' and '*' characters.
+ *
+ * If any of the special chars are seen they will usually be returned straight
+ * away. The exceptions are the wild chars '*' and '?', and '&' which will be
+ * treated as a plain old word character unless followed by another '&'.
+ * 
+ * If no special characters or tokens are found then yylex delegates to
+ * +get_word+ which will fetch the next query-word.
+ */
 static int yylex(YYSTYPE *lvalp, QParser *qp)
 {
@@ -2132 +2178 @@
 }
 
+/**
+ * yyerror gets called if there is an parse error with the yacc parser.
+ * It is responsible for clearing any memory that was allocated during the
+ * parsing process.
+ */
 static int yyerror(QParser *qp, char const *msg)
 {
@@ -2152 +2203 @@
 #define BQ(query) ((BooleanQuery *)(query))
 
+/**
+ * The QueryParser caches a tokenizer for each field so that it doesn't need
+ * to allocate a new tokenizer for each term in the query. This would be quite
+ * expensive as tokenizers use quite a large hunk of memory.
+ *
+ * This method returns the query parser for a particular field and sets it up
+ * with the text to be tokenized.
+ */
 static TokenStream *get_cached_ts(QParser *qp, char *field, char *text)
 {
@@ -2172 +2231 @@
 }
 
+/**
+ * Turns a BooleanClause array into a BooleanQuery. It will optimize the query
+ * if 0 or 1 clauses are present to NULL or the actual query in the clause
+ * respectively.
+ */
 static Query *get_bool_q(BCArray *bca)
 {
@@ -2207 +2271 @@
 }
 
+/**
+ * Base method for appending BooleanClauses to a BooleanClause array. This
+ * method doesn't care about the type of clause (MUST, SHOULD, MUST_NOT).
+ */
 static void bca_add_clause(BCArray *bca, BooleanClause *clause)
 {
@@ -2217 +2285 @@
 }
 
+/**
+ * Add the first clause to a BooleanClause array. This method is also
+ * responsible for allocating a new BooleanClause array.
+ */
 static BCArray *first_cls(BooleanClause *clause)
 {
@@ -2228 +2300 @@
 }
 
+/**
+ * Add AND clause to the BooleanClause array. The means that it will set the
+ * clause being added and the previously added clause from SHOULD clauses to
+ * MUST clauses. (If they are currently MUST_NOT clauses they stay as they
+ * are.)
+ */