whistlepig 0.1

data/ext/whistlepig/query-parser.tab.h

@@ -0,0 +1,85 @@
+
+/* A Bison parser, made by GNU Bison 2.4.1.  */
+
+/* Skeleton interface for Bison's Yacc-like parsers in C
+   
+      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+   
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+   
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     WORD = 258,
+     OR = 259
+   };
+#endif
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+{
+
+/* Line 1676 of yacc.c  */
+#line 30 "query-parser.y"
+
+  wp_query* query;
+  char* string;
+
+
+
+/* Line 1676 of yacc.c  */
+#line 63 "query-parser.tab.h"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+

data/ext/whistlepig/query.c

@@ -0,0 +1,194 @@
+#include "query.h"
+
+static wp_query* wp_query_new() {
+  wp_query* ret = malloc(sizeof(wp_query));
+  ret->type = 0; // error
+  ret->field = ret->word = NULL;
+  ret->num_children = 0;
+  ret->children = ret->next = ret->last = NULL;
+  ret->search_data = NULL;
+
+  return ret;
+}
+
+static char* strdup(const char* old) { // sigh... not in c99
+  size_t len = strlen(old) + 1;
+  char *new = malloc(len * sizeof(char));
+  return memcpy(new, old, len);
+}
+
+wp_query* wp_query_clone(wp_query* other) {
+  wp_query* ret = malloc(sizeof(wp_query));
+  ret->type = other->type;
+  ret->num_children = other->num_children;
+  ret->search_data = NULL;
+
+  if(other->field) ret->field = strdup(other->field);
+  else ret->field = NULL;
+
+  if(other->word) ret->word = strdup(other->word);
+  else ret->word = NULL;
+
+  ret->children = ret->next = ret->last = NULL; // set below
+  for(wp_query* child = other->children; child != NULL; child = child->next) {
+    wp_query* clone = wp_query_clone(child);
+    if(ret->last == NULL) ret->children = ret->last = clone;
+    else {
+      ret->last->next = clone;
+      ret->last = clone;
+    }
+  }
+
+  return ret;
+}
+
+wp_query* wp_query_new_term(const char* field, const char* word) {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_TERM;
+  ret->field = field;
+  ret->word = word;
+  return ret;
+}
+
+wp_query* wp_query_new_label(const char* label) {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_LABEL;
+  ret->word = label;
+  ret->field = NULL;
+  return ret;
+}
+
+wp_query* wp_query_new_conjunction() {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_CONJ;
+  return ret;
+}
+
+wp_query* wp_query_new_disjunction() {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_DISJ;
+  return ret;
+}
+
+wp_query* wp_query_new_phrase() {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_PHRASE;
+  return ret;
+}
+
+wp_query* wp_query_new_negation() {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_NEG;
+  return ret;
+}
+
+wp_query* wp_query_new_empty() {
+  wp_query* ret = wp_query_new();
+  ret->type = WP_QUERY_EMPTY;
+  return ret;
+}
+
+wp_query* wp_query_add(wp_query* a, wp_query* b) {
+  if(a->type == WP_QUERY_EMPTY) {
+    wp_query_free(a);
+    return b;
+  }
+  else if(b->type == WP_QUERY_EMPTY) {
+    wp_query_free(b);
+    return a;
+  }
+  else {
+    a->num_children++;
+    if(a->last == NULL) a->children = a->last = b;
+    else {
+      a->last->next = b;
+      a->last = b;
+    }
+    return a;
+  }
+}
+
+void wp_query_free(wp_query* q) {
+  if(q->field) free((void*)q->field);
+  if(q->word) free((void*)q->word);
+  while(q->children) {
+    wp_query* b = q->children;
+    q->children = q->children->next;
+    wp_query_free(b);
+  }
+  free(q);
+}
+
+static int subquery_to_s(wp_query* q, size_t n, char* buf) {
+  char* orig_buf = buf;
+
+  for(wp_query* child = q->children; child != NULL; child = child->next) {
+    if((n - (buf - orig_buf)) < 1) break; // can we add a space?
+    buf += sprintf(buf, " ");
+    buf += wp_query_to_s(child, n - (buf - orig_buf), buf);
+  }
+
+  return buf - orig_buf;
+}
+
+#define min(a, b) (a < b ? a : b)
+
+int wp_query_to_s(wp_query* q, size_t n, char* buf) {
+  int ret;
+  char* orig_buf = buf;
+
+  if(q->type == WP_QUERY_EMPTY) {
+    buf[0] = '\0';
+    ret = n;
+  }
+  else if(q->type == WP_QUERY_TERM) {
+    size_t term_n = (size_t)snprintf(buf, n, "%s:\"%s\"", q->field, q->word);
+    ret = min(term_n, n);
+  }
+  else if(q->type == WP_QUERY_LABEL) {
+    size_t term_n = (size_t)snprintf(buf, n, "~%s", q->word);
+    ret = min(term_n, n);
+  }
+  else {
+    switch(q->type) {
+    case WP_QUERY_CONJ:
+      if(n >= 4) { // "(AND"
+        buf += snprintf(buf, n, "(AND");
+        n -= 4;
+      }
+      break;
+    case WP_QUERY_DISJ:
+      if(n >= 3) { // "(OR"
+        buf += snprintf(buf, n, "(OR");
+        n -= 3;
+      }
+      break;
+    case WP_QUERY_PHRASE:
+      if(n >= 7) { // "(PHRASE"
+        buf += snprintf(buf, n, "(PHRASE");
+        n -= 7;
+      }
+      break;
+    case WP_QUERY_NEG:
+      if(n >= 4) {
+        buf += snprintf(buf, n, "(NOT");
+        n -= 4;
+      }
+      break;
+    }
+
+    int subq_size = subquery_to_s(q, n, buf);
+    n -= subq_size;
+    buf += subq_size;
+    if(n >= 1) buf += sprintf(buf, ")");
+    ret = buf - orig_buf;
+  }
+
+  return ret;
+}
+
+wp_query* wp_query_set_all_child_fields(wp_query* q, const char* field) {
+  if(q->type == WP_QUERY_TERM) q->field = field;
+  else for(wp_query* child = q->children; child != NULL; child = child->next) wp_query_set_all_child_fields(child, strdup(field));
+  return q;
+}

data/ext/whistlepig/query.h

@@ -0,0 +1,78 @@
+#ifndef WP_QUERY_H_
+#define WP_QUERY_H_
+
+// whistlepig query
+// (c) 2011 William Morgan. See COPYING for license terms.
+//
+// a query. typically built up by the parser, but you can also build it
+// programmatically yourself if you like.
+//
+// note that queries contain segment-specific search state in them. see
+// search.c for details.
+
+#include <stdint.h>
+#include <stdlib.h>
+#include "segment.h"
+
+#define WP_QUERY_TERM 1
+#define WP_QUERY_CONJ 2
+#define WP_QUERY_DISJ 3
+#define WP_QUERY_PHRASE 4
+#define WP_QUERY_NEG 5
+#define WP_QUERY_LABEL 6
+#define WP_QUERY_EMPTY 7
+
+// a node in the query tree
+typedef struct wp_query {
+  uint8_t type;
+  const char* field;
+  const char* word;
+
+  uint16_t num_children;
+  struct wp_query* children;
+  struct wp_query* next;
+  struct wp_query* last;
+
+  uint16_t segment_idx; // used to continue queries across segments (see index.c)
+  void* search_data; // whatever state we need for actually doing searches
+} wp_query;
+
+// API methods
+
+// public: make a query node with a term
+wp_query* wp_query_new_term(const char* field, const char* word);
+
+// public: make a query node with a label
+wp_query* wp_query_new_label(const char* label);
+
+// public: make a query conjuction node
+wp_query* wp_query_new_conjunction();
+
+// public: make a query disjunction node
+wp_query* wp_query_new_disjunction();
+
+// public: make a query phrase node
+wp_query* wp_query_new_phrase();
+
+// public: make a query negation node
+wp_query* wp_query_new_negation();
+
+// public: make an empty query node.
+wp_query* wp_query_new_empty();
+
+// public: deep clone of a query, but dropping all search state.
+wp_query* wp_query_clone(wp_query* other);
+
+// public: add a query node as a child of another
+wp_query* wp_query_add(wp_query* a, wp_query* b);
+
+// private: set all children fields to a particular value
+wp_query* wp_query_set_all_child_fields(wp_query* q, const char* field);
+
+// public: free a query
+void wp_query_free(wp_query* q);
+
+// public: build a string representation of a query by writing at most n chars to buf
+int wp_query_to_s(wp_query* q, size_t n, char* buf);
+
+#endif