geo_coder 0.1.0

data/src/libsqlite3_geocoder/util.c

@@ -0,0 +1,37 @@
+# include <string.h>
+# include <ctype.h>
+
+int address_metaphone(const char *input, char *output, int max_phones) {
+    const char *n = input;
+    int i = 0;
+    if (isdigit(*n)) {
+        while (i < max_phones && isdigit(n[i]) && n[i] != '\0')
+            *output++ = n[i++];
+        *output = '\0';
+        return 1;
+    } else {
+        return metaphone(input, output, max_phones);
+    }
+}
+
+signed int rindex_nondigit (const char *string) {
+    signed int i = strlen(string);
+    if (!i) return -1;
+    for (i--; i >= 0 && isdigit(string[i]); i--);
+    return i;
+}
+
+signed int digit_suffix (const char *input, char *output) {
+    signed int i = rindex_nondigit(input);
+    strcpy(output, input+i+1);
+    return strlen(output);
+}
+
+signed int nondigit_prefix (const char *input, char *output) {
+    signed int i = rindex_nondigit(input);
+    if (i++ >= 0) {
+        strncpy(output, input, i);
+        output[i] = '\0';
+    }
+    return i;
+}

data/src/libsqlite3_geocoder/wkb_compress.c

@@ -0,0 +1,54 @@
+#include <stdint.h>
+#include <string.h>
+
+uint32_t compress_wkb_line (void *dest, const void *src, uint32_t len) {
+    uint32_t d, s;
+    double value;
+    if (!len) return 0;
+    for (s = 9, d = 0; s < len; d += 4, s += 8) {
+        value = *(double *)(src + s);
+        value *= 1000000;
+        *(int32_t *)(dest + d) = (int32_t) value;
+    }
+    return d; 
+}
+
+uint32_t uncompress_wkb_line (void *dest, const void *src, uint32_t len) {
+    uint32_t d, s;
+    double value;
+    if (!len) return 0;
+    memcpy(dest, "\01\02\00\00\00\06\00\00\00", 10);
+    for (s = 0, d = 9; s < len; s += 4, d += 8) {
+        value = (double) *(int32_t *)(src + s);
+        value /= 1000000;
+        *(double *)(dest + d) = value;
+    }
+    return d; 
+}
+
+
+#ifdef TEST
+
+#include <stdio.h>
+int main (int argc, char *argv) {
+    char hex[1024], *scan;
+    char wkb[512];
+    unsigned long len, clen;
+    
+    while (!feof(stdin)) {
+        fgets(hex, sizeof(hex), stdin);
+        for (scan = hex, len = 0; *scan && sizeof(wkb)>len; scan += 2, len++) {
+            if (sscanf(scan, "%2x", (uint32_t *)(wkb+len)) != 1) break;
+        }
+        clen = compress_wkb_line(hex, wkb, len);
+        printf("before: %lu, after: %lu\n", len, clen);
+        len = uncompress_wkb_line(wkb, hex, clen);
+        printf("before: %lu, after: %lu\n", clen, len);
+        for (scan = wkb + 9; scan < wkb + len; scan += 8) {
+            printf("%.6f ", *(double *)scan);
+        }
+        printf("\n");
+    }
+}
+
+#endif

data/src/metaphone/Makefile

@@ -0,0 +1,7 @@
+all: metaphone.so
+
+metaphone.so: extension.o metaphon.o
+	$(CC) -shared $^ -o $@
+
+clean:
+	rm -f *.o *.so

data/src/metaphone/README

@@ -0,0 +1,49 @@
+= SQLite 3 Metaphone extension =
+
+ * This library implements the Metaphone algorithm, originally developed by
+   Laurence Phillips, as an SQLite 3 extension function:
+
+     http://en.wikipedia.org/wiki/Metaphone
+
+ * This code is based around the original public domain implementation in
+   C by Gary Phillips, as provided by Sadi Evren Seker:
+
+    http://www.shedai.net/c/new/METAPHON.C
+
+ * Like SQLite and the Phillips implementation of Metaphone, this code
+   is provided in the public domain, in the hope that it will be useful.
+
+ * To compile the code, simply run `make`. You must have GNU Make and GCC
+   installed.
+
+ * The module implements one function, metaphone(), which takes a string
+   to convert to a metaphone representation as its first argument, and an
+   optional second argument to specify the maximum length of the output.
+
+ * To use the code, run `sqlite3` and enter the following:
+
+{{{
+    sqlite> .load /path/to/metaphone.so
+            -- you can use ./metaphone.so if the .so is in your 
+            -- current directory, or just metaphone.so if it's
+            -- somewhere in your library path.
+    sqlite> select metaphone("Schuyler");
+    SKLR
+    sqlite> select metaphone("Schuyler", 3);
+    SKL
+    sqlite> select metaphone("Skyler");
+    SKLR
+    sqlite> select metaphone("Skylar");
+    SKLR
+    sqlite> select metaphone("SQLite rules!");
+    SKLTRLS
+    sqlite> select metaphone("SQLite roolz!!!1!");
+    SKLTRLS
+}}}
+
+Questions? Comments? Complaints? Approbation? Email schuyler@nocat.net.
+
+Schuyler Erle
+9 March 2008
+
+=30=

data/src/metaphone/extension.c

@@ -0,0 +1,37 @@
+# include <sqlite3.h>
+# include <sqlite3ext.h>
+# include <stdio.h>
+# include <string.h>
+
+static SQLITE_EXTENSION_INIT1;
+
+static void
+sqlite3_metaphone (sqlite3_context *context, int argc, sqlite3_value **argv) {
+    const unsigned char *input = sqlite3_value_text(argv[0]);
+    int max_phones = 0;
+    char *output; 
+    int len;
+    if (sqlite3_value_type(argv[0]) == SQLITE_NULL) {
+        sqlite3_result_null(context);
+        return;
+    }
+    if (argc > 1)
+        max_phones = sqlite3_value_int(argv[1]);
+    if (max_phones <= 0)
+        max_phones = strlen(input);
+    output = sqlite3_malloc((max_phones+1)*sizeof(char));
+    len = metaphone(input, output, max_phones); 
+    sqlite3_result_text(context, output, len, SQLITE_TRANSIENT);
+}
+
+int sqlite3_extension_init (sqlite3 * db, char **pzErrMsg,
+                            const sqlite3_api_routines *pApi) {
+    SQLITE_EXTENSION_INIT2(pApi);
+    sqlite3_create_function(db, "metaphone", 1, SQLITE_ANY,
+                            NULL, sqlite3_metaphone, NULL, NULL);
+    sqlite3_create_function(db, "metaphone", 2, SQLITE_ANY,
+                            NULL, sqlite3_metaphone, NULL, NULL);
+    return 0;
+}
+
+

data/src/metaphone/metaphon.c

@@ -0,0 +1,251 @@
+/* +++Customized by SDE for sqlite3 use 09-Mar-2009 */
+/* +++File obtained from http://www.shedai.net/c/new/METAPHON.C */
+/* +++Date previously modified: 05-Jul-1997 */
+
+/*
+**  METAPHON.C - Phonetic string matching
+**
+**  The Metaphone algorithm was developed by Lawrence Phillips. Like the
+**  Soundex algorithm, it compares words that sound alike but are spelled
+**  differently. Metaphone was designed to overcome difficulties encountered
+**  with Soundex.
+**
+**  This implementation was written by Gary A. Parker and originally published
+**  in the June/July, 1991 (vol. 5 nr. 4) issue of C Gazette. As published,
+**  this code was explicitly placed in the public domain by the author.
+*/
+
+#include <ctype.h>
+#include <string.h> /* strlen() */
+#include <stdio.h>
+#define malloc(x) sqlite3_malloc((x))
+#define free(x) sqlite3_free((x))
+
+/*
+**  Character coding array
+*/
+
+static char vsvfn[26] = {
+      1,16,4,16,9,2,4,16,9,2,0,2,2,2,1,4,0,2,4,4,1,0,0,0,8,0};
+/*    A  B C  D E F G  H I J K L M N O P Q R S T U V W X Y Z      */
+
+/*
+**  Macros to access the character coding array
+*/
+
+#define vowel(x)  (vsvfn[(x) - 'A'] & 1)  /* AEIOU    */
+#define same(x)   (vsvfn[(x) - 'A'] & 2)  /* FJLMNR   */
+#define varson(x) (vsvfn[(x) - 'A'] & 4)  /* CGPST    */
+#define frontv(x) (vsvfn[(x) - 'A'] & 8)  /* EIY      */
+#define noghf(x)  (vsvfn[(x) - 'A'] & 16) /* BDH      */
+
+int metaphone(const char *Word, char *Metaph, int max_phones)
+{
+      char *n, *n_start, *n_end;    /* Pointers to string               */
+      char *metaph_start = Metaph, *metaph_end;    
+                                    /* Pointers to metaph         */
+      int ntrans_len = strlen(Word)+4;
+      char *ntrans = (char *)malloc(sizeof(char) * ntrans_len);
+                                    /* Word with uppercase letters      */
+      int KSflag;                   /* State flag for X translation     */
+
+      /*
+      ** Copy word to internal buffer, dropping non-alphabetic characters
+      ** and converting to upper case.
+      */
+
+      for (n = ntrans + 1, n_end = ntrans + ntrans_len - 2;
+            *Word && n < n_end; ++Word)
+      {
+            if (isalpha(*Word))
+                  *n++ = toupper(*Word);
+      }
+
+      if (n == ntrans + 1) {
+            free(ntrans);
+            Metaph[0]='\0';
+            return 1;           /* Return if zero characters        */
+      }
+      else  n_end = n;          /* Set end of string pointer        */
+
+      /*
+      ** Pad with '\0's, front and rear
+      */
+
+      *n++ = '\0';
+      *n   = '\0';
+      n    = ntrans;
+      *n++ = '\0';
+
+      /*
+      ** Check for PN, KN, GN, WR, WH, and X at start
+      */
+
+      switch (*n)
+      {
+      case 'P':
+      case 'K':
+      case 'G':
+            if ('N' == *(n + 1))
+                  *n++ = '\0';
+            break;
+
+      case 'A':
+            if ('E' == *(n + 1))
+                  *n++ = '\0';
+            break;
+
+      case 'W':
+            if ('R' == *(n + 1))
+                  *n++ = '\0';
+            else if ('H' == *(n + 1))
+            {
+                  *(n + 1) = *n;
+                  *n++ = '\0';
+            }
+            break;
+
+      case 'X':
+            *n = 'S';
+            break;
+      }
+
+      /*
+      ** Now loop through the string, stopping at the end of the string
+      ** or when the computed Metaphone code is max_phones characters long.
+      */
+
+      KSflag = 0;              /* State flag for KStranslation     */
+      for (metaph_end = Metaph + max_phones, n_start = n;
+            n <= n_end && Metaph < metaph_end; ++n)
+      {
+            if (KSflag)
+            {
+                  KSflag = 0;
+                  *Metaph++ = *n;
+            }
+            else
+            {
+                  /* Drop duplicates except for CC    */
+
+                  if (*(n - 1) == *n && *n != 'C')
+                        continue;
+
+                  /* Check for F J L M N R  or first letter vowel */
+
+                  if (same(*n) || (n == n_start && vowel(*n)))
+                        *Metaph++ = *n;
+                  else switch (*n)
+                  {
+                  case 'B':
+                        if (n < n_end || *(n - 1) != 'M')
+                              *Metaph++ = *n;
+                        break;
+
+                  case 'C':
+                        if (*(n - 1) != 'S' || !frontv(*(n + 1)))
+                        {
+                              if ('I' == *(n + 1) && 'A' == *(n + 2))
+                                    *Metaph++ = 'X';
+                              else if (frontv(*(n + 1)))
+                                    *Metaph++ = 'S';
+                              else if ('H' == *(n + 1))
+                                    *Metaph++ = ((n == n_start &&
+                                          !vowel(*(n + 2))) ||
+                                          'S' == *(n - 1)) ? 'K' : 'X';
+                              else  *Metaph++ = 'K';
+                        }
+                        break;
+
+                  case 'D':
+                        *Metaph++ = ('G' == *(n + 1) && frontv(*(n + 2))) ?
+                              'J' : 'T';
+                        break;
+
+                  case 'G':
+                        if ((*(n + 1) != 'H' || vowel(*(n + 2))) &&
+                              (*(n + 1) != 'N' || ((n + 1) < n_end &&
+                              (*(n + 2) != 'E' || *(n + 3) != 'D'))) &&
+                              (*(n - 1) != 'D' || !frontv(*(n + 1))))
+                        {
+                              *Metaph++ = (frontv(*(n + 1)) &&
+                                    *(n + 2) != 'G') ? 'J' : 'K';
+                        }
+                        else if ('H' == *(n + 1) && !noghf(*(n - 3)) &&
+                              *(n - 4) != 'H')
+                        {
+                              *Metaph++ = 'F';
+                        }
+                        break;
+
+                  case 'H':
+                        if (!varson(*(n - 1)) && (!vowel(*(n - 1)) ||
+                              vowel(*(n + 1))))
+                        {
+                              *Metaph++ = 'H';
+                        }
+                        break;
+
+                  case 'K':
+                        if (*(n - 1) != 'C')
+                              *Metaph++ = 'K';
+                        break;
+
+                  case 'P':
+                        *Metaph++ = ('H' == *(n + 1)) ? 'F' : 'P';
+                        break;
+
+                  case 'Q':
+                        *Metaph++ = 'K';
+                        break;
+
+                  case 'S':
+                        *Metaph++ = ('H' == *(n + 1) || ('I' == *(n + 1) &&
+                              ('O' == *(n + 2) || 'A' == *(n + 2)))) ?
+                              'X' : 'S';
+                        break;
+
+                  case 'T':
+                        if ('I' == *(n + 1) && ('O' == *(n + 2) ||
+                              'A' == *(n + 2)))
+                        {
+                              *Metaph++ = 'X';
+                        }
+                        else if ('H' == *(n + 1))
+                              *Metaph++ = 'O';
+                        else if (*(n + 1) != 'C' || *(n + 2) != 'H')
+                              *Metaph++ = 'T';
+                        break;
+
+                  case 'V':
+                        *Metaph++ = 'F';
+                        break;
+
+                  case 'W':
+                  case 'Y':
+                        if (vowel(*(n + 1)))
+                              *Metaph++ = *n;
+                        break;
+
+                  case 'X':
+                        if (n == n_start)
+                              *Metaph++ = 'S';
+                        else
+                        {
+                              *Metaph++ = 'K';
+                              KSflag = 1;
+                        }
+                        break;
+
+                  case 'Z':
+                        *Metaph++ = 'S';
+                        break;
+                  }
+            }
+      }
+
+      *Metaph = '\0';
+      free(ntrans);
+      return strlen(metaph_start);
+}
+

data/src/shp2sqlite/Makefile

@@ -0,0 +1,37 @@
+# **********************************************************************
+# * $Id: Makefile.in
+# *
+# * PostGIS - Spatial Types for PostgreSQL
+# * http://postgis.refractions.net
+# * Copyright 2008 Mark Cave-Ayland
+# *
+# * This is free software; you can redistribute and/or modify it under
+# * the terms of the GNU General Public Licence. See the COPYING file.
+# *
+# **********************************************************************
+
+CC=gcc
+CFLAGS=-g -O2  -fPIC -DPIC  -Wall -Wmissing-prototypes
+
+# Filenames with extension as determined by the OS
+SHP2SQLITE=shp2sqlite
+LIBLWGEOM=../liblwgeom/liblwgeom.a
+
+# iconv flags
+ICONV_LDFLAGS=-lc
+
+all: $(SHP2SQLITE)
+
+$(LIBLWGEOM):
+	make -C ../liblwgeom
+
+$(SHP2SQLITE): shpopen.o dbfopen.o getopt.o shp2sqlite.o $(LIBLWGEOM)
+	$(CC) -L/usr/local/libiconv/lib/ -liconv -I/usr/include $(CFLAGS) $^ $(ICONV_LDFLAGS) -lm -o $@
+
+
+install: all
+	@cp $(SHP2SQLITE) ../../bin
+
+clean:
+	@rm -f *.o $(SHP2SQLITE)
+