swishe 0.1

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Patrick Gundlach
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,33 @@
+= Readme for Swish-e Ruby Bindings
+
+== Example usage
+ require "swishe"
+ sw=SwishE.new("swishe-index")
+ sw.query("searchstring").each do |result|
+   puts result.docpath
+   puts result.rank
+   # .... 
+ end
+ sw.close
+
+== Installing the bindings
+
+You have two choices installing the bindings. First, use the gem command, such as
+ gem install swishe
+in case the gem command doesn't find the Swish-e C-library you might need to supply the path
+to the library on the gem command line, for example:
+ gem install swishe -- --with-swishe-dir=/opt/swishe/2.4.3/
+
+The other way to install the ruby bindings for Swish-e would be to download the source file
+and run setup.rb manually:
+ ruby setup.rb all
+and again, if your system doesn't find the Swish-e library, you need to supply those:
+ ruby setup.rb all --  --with-swishe-dir=/opt/swishe/2.4.3/
+Needles to say that you need to change the path according to your system requirements.
+
+== Other Stuff
+Author:: Patrick Gundlach <patrick <at> gundla.ch>
+Project Page::  http://www.rubyforge.org/projects/swishe
+Homepage:: (Documentation) http://swishe.rubyforge.org
+License::  Copyright (c) 2006 Patrick Gundlach.
+           Released under the terms of the MIT license.  See the file MIT-LICENSE

data/ext/MANIFEST

@@ -0,0 +1,3 @@
+extconf.rb
+swish-e.i
+swishe_base.c

data/ext/extconf.rb

@@ -0,0 +1,13 @@
+#!/opt/ruby/1.8/bin/ruby
+
+#  ruby setup.rb all -- --with-swishe-dir=/opt/swishe/2.4.3
+require 'mkmf'
+
+dir_config "swishe"
+if have_header("swish-e.h") and have_library('swish-e')
+  create_makefile('swishe_base')
+else
+  puts "error creating makefile"
+  exit 1
+end
+

data/ext/swishe_base.c

@@ -0,0 +1,2510 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.24
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
+#  if defined(__SUNPRO_CC) 
+#    define SWIG_TEMPLATE_DISAMBIGUATOR template
+#  else
+#    define SWIG_TEMPLATE_DISAMBIGUATOR 
+#  endif
+#endif
+
+/* ruby.swg */
+/* Implementation : RUBY */
+#define SWIGRUBY 1
+
+#include "ruby.h"
+
+/* Flags for pointer conversion */
+#define SWIG_POINTER_EXCEPTION     0x1
+#define SWIG_POINTER_DISOWN        0x2
+
+#define NUM2USHRT(n) (\
+    (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\
+    ? (unsigned short) NUM2UINT(n) \
+    : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\
+               NUM2UINT(n)), (short)0)\
+)
+
+#define NUM2SHRT(n) (\
+    (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\
+    ? (short)NUM2INT(n)\
+    : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\
+               NUM2INT(n)), (short)0)\
+)
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+} swig_class;
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+/* Contract support */
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else
+
+
+/***********************************************************************
+ * swigrun.swg
+ *
+ *     This file contains generic CAPI SWIG runtime support for pointer
+ *     type checking.
+ *
+ ************************************************************************/
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "1"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+#define SWIG_QUOTE_STRING(x) #x
+#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+#define SWIG_TYPE_TABLE_NAME
+#endif
+
+#include <string.h>
+
+#ifndef SWIGINLINE
+#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#  define SWIGINLINE inline
+#else
+#  define SWIGINLINE
+#endif
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the swig runtime code.
+  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  
+  But only do this if is strictly necessary, ie, if you have problems
+  with your compiler or so.
+*/
+#ifndef SWIGRUNTIME
+#define SWIGRUNTIME static
+#endif
+#ifndef SWIGRUNTIMEINLINE
+#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+typedef struct swig_type_info {
+  const char             *name;
+  swig_converter_func     converter;
+  const char             *str;
+  void                   *clientdata;
+  swig_dycast_func        dcast;
+  struct swig_type_info  *next;
+  struct swig_type_info  *prev;
+} swig_type_info;
+
+/* 
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return *f1 - *f2;
+  }
+  return (l1 - f1) - (l2 - f2);
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  int equiv = 0;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (!equiv && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Register a type mapping with the type-checking
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
+  swig_type_info *tc, *head, *ret, *next;
+  /* Check to see if this type has already been registered */
+  tc = *tl;
+  while (tc) {
+    /* check simple type equivalence */
+    int typeequiv = (strcmp(tc->name, ti->name) == 0);   
+    /* check full type equivalence, resolving typedefs */
+    if (!typeequiv) {
+      /* only if tc is not a typedef (no '|' on it) */
+      if (tc->str && ti->str && !strstr(tc->str,"|")) {
+	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
+      }
+    }
+    if (typeequiv) {
+      /* Already exists in the table.  Just add additional types to the list */
+      if (ti->clientdata) tc->clientdata = ti->clientdata;
+      head = tc;
+      next = tc->next;
+      goto l1;
+    }
+    tc = tc->prev;
+  }
+  head = ti;
+  next = 0;
+
+  /* Place in list */
+  ti->prev = *tl;
+  *tl = ti;
+
+  /* Build linked lists */
+  l1:
+  ret = head;
+  tc = ti + 1;
+  /* Patch up the rest of the links */
+  while (tc->name) {
+    head->next = tc;
+    tc->prev = head;
+    head = tc;
+    tc++;
+  }
+  if (next) next->prev = head;
+  head->next = next;
+
+  return ret;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  swig_type_info *s;
+  if (!ty) return 0;        /* Void pointer */
+  s = ty->next;             /* First element always just a name */
+  do {
+    if (strcmp(s->name,c) == 0) {
+      if (s == ty->next) return s;
+      /* Move s to the top of the linked list */
+      s->prev->next = s->next;
+      if (s->next) {
+        s->next->prev = s->prev;
+      }
+      /* Insert s as second element in the list */
+      s->next = ty->next;
+      if (ty->next) ty->next->prev = s;
+      ty->next = s;
+      s->prev = ty;
+      return s;
+    }
+    s = s->next;
+  } while (s && (s != ty->next));
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_type_info *ty, void *ptr) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+}
+
+/* 
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+  Search for a swig_type_info structure
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
+  swig_type_info *ty = tl;
+  while (ty) {
+    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
+    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
+    ty = ty->prev;
+  }
+  return 0;
+}
+
+/* 
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
+  swig_type_info *tc, *equiv;
+  if (ti->clientdata) return;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+  equiv = ti->next;
+  while (equiv) {
+    if (!equiv->converter) {
+      tc = tl;
+      while (tc) {
+        if ((strcmp(tc->name, equiv->name) == 0))
+          SWIG_TypeClientDataTL(tl,tc,clientdata);
+        tc = tc->prev;
+      }
+    }
+    equiv = equiv->next;
+  }
+}
+
+/* 
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static char hex[17] = "0123456789abcdef";
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  register unsigned char uu;
+  for (; u != eu; ++u) {
+    uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/* 
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register int d = *(c++);
+    register unsigned char uu = 0;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else 
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else 
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+  This function will propagate the clientdata field of type to any new
+  swig_type_info structures that have been added into the list of
+  equivalent types.  It is like calling SWIG_TypeClientData(type,
+  clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
+  swig_type_info *equiv = type->next;
+  swig_type_info *tc;
+  if (!type->clientdata) return;
+  while (equiv) {
+    if (!equiv->converter) {
+      tc = tl;
+      while (tc) {
+        if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
+          SWIG_TypeClientDataTL(tl,tc, type->clientdata);
+        tc = tc->prev;
+      }
+    }
+    equiv = equiv->next;
+  }
+}
+
+/* 
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/***********************************************************************
+ * common.swg
+ *
+ *     This file contains generic SWIG runtime support for pointer
+ *     type checking as well as a few commonly used macros to control
+ *     external linkage.
+ *
+ * Author : David Beazley (beazley@cs.uchicago.edu)
+ *
+ * Copyright (c) 1999-2000, The University of Chicago
+ * 
+ * This file may be freely redistributed without license or fee provided
+ * this copyright message remains intact.
+ ************************************************************************/
+
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#  if !defined(STATIC_LINKED)
+#    define SWIGEXPORT(a) __declspec(dllexport) a
+#  else
+#    define SWIGEXPORT(a) a
+#  endif
+#else
+#  define SWIGEXPORT(a) a
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************/
+
+
+/* The static type info list */
+
+static swig_type_info *swig_type_list = 0;
+static swig_type_info **swig_type_list_handle = &swig_type_list;
+  
+
+/* Register a type mapping with the type-checking */
+static swig_type_info *
+SWIG_TypeRegister(swig_type_info *ti) {
+  return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
+}
+
+/* Search for a swig_type_info structure */
+static swig_type_info *
+SWIG_TypeQuery(const char *name) {
+  return SWIG_TypeQueryTL(*swig_type_list_handle, name);
+}
+
+/* Set the clientdata field for a type */
+static void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+static void
+SWIG_PropagateClientData(swig_type_info *type) {
+  SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Common SWIG API */
+#define SWIG_ConvertPtr(obj, pp, type, flags) \
+  SWIG_Ruby_ConvertPtr(obj, pp, type, flags)
+#define SWIG_NewPointerObj(p, type, flags) \
+  SWIG_Ruby_NewPointerObj(p, type, flags)
+#define SWIG_MustGetPtr(p, type, argnum, flags) \
+  SWIG_Ruby_MustGetPtr(p, type, argnum, flags)
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime() \
+  SWIG_Ruby_InitRuntime()
+#define SWIG_define_class(ty) \
+  SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty) \
+  SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value) \
+  SWIG_Ruby_MangleStr(value)
+#define SWIG_CheckConvert(value, ty) \
+  SWIG_Ruby_CheckConvert(value, ty)
+#define SWIG_NewPackedObj(ptr, sz, ty) \
+  SWIG_Ruby_NewPackedObj(ptr, sz, ty)
+#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
+  SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+
+/* rubydef.swg */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static VALUE _mSWIG = Qnil;
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Initialize Ruby runtime support */
+static void
+SWIG_Ruby_InitRuntime(void)
+{
+    VALUE pointer;
+    
+    if (_mSWIG == Qnil) {
+        _mSWIG = rb_define_module("SWIG");
+    }
+    
+    /* first check if pointer already created */
+    pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+    if (pointer != Qnil) {
+      Data_Get_Struct(pointer, swig_type_info *, swig_type_list_handle);
+    } else {
+      /* register a new class */
+      VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+      /* create and store the structure pointer to a global variable */
+      swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, swig_type_list_handle);
+      rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+    }
+}
+
+/* Define Ruby class for C type */
+static void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+    VALUE klass;
+    char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    if (NIL_P(_cSWIG_Pointer)) {
+	_cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+	rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+    }
+    klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+    free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+static VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
+{
+    char *klass_name;
+    swig_class *sklass;
+    VALUE klass;
+    VALUE obj;
+    
+    if (!ptr)
+	return Qnil;
+    
+    if (type->clientdata) {
+      sklass = (swig_class *) type->clientdata;
+      obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
+    } else {
+      klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+      sprintf(klass_name, "TYPE%s", type->name);
+      klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+      free((void *) klass_name);
+      obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+    }
+    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
+    return obj;
+}
+
+/* Create a new class instance (always owned) */
+static VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+    VALUE obj;
+    swig_class *sklass = (swig_class *) type->clientdata;
+    obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
+    return obj;
+}
+
+/* Get type mangle from class name */
+static SWIGINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Convert a pointer value */
+static int
+SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
+{
+  char *c;
+  swig_type_info *tc;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    *ptr = 0;
+    return 0;
+  } else {
+    Data_Get_Struct(obj, void, *ptr);
+  }
+  
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+        if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+          if (*ptr == 0)
+            rb_raise(rb_eRuntimeError, "This %s already released", ty->str);
+          return 0;
+        }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      if (flags & SWIG_POINTER_EXCEPTION)
+        rb_raise(rb_eTypeError, "Expected %s", ty->str);
+      else
+        return -1;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      if (flags & SWIG_POINTER_EXCEPTION)
+        rb_raise(rb_eTypeError, "Expected %s", ty->str);
+      else
+        return -1;
+    }
+    *ptr = SWIG_TypeCast(tc, *ptr);
+  }
+  return 0;
+}
+
+/* Convert a pointer value, signal an exception on a type mismatch */
+static SWIGINLINE void *
+SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags)
+{
+  void *result;
+  SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
+  return result;
+}
+
+/* Check convert */
+static SWIGINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c)
+    return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+static VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+static void
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) {
+  swig_type_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return;
+
+type_error:
+
+  if (flags) {
+    if (ty) {
+      rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name);
+    } else {
+      rb_raise(rb_eTypeError, "Expected a pointer");
+    }
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define  SWIGTYPE_p_FILE swig_types[0] 
+#define  SWIGTYPE_p_time_t swig_types[1] 
+#define  SWIGTYPE_p_unsigned_long swig_types[2] 
+#define  SWIGTYPE_p_u_PropValue1 swig_types[3] 
+#define  SWIGTYPE_p_SWISH_HEADER_VALUE swig_types[4] 
+#define  SWIGTYPE_p_p_char swig_types[5] 
+#define  SWIGTYPE_p_PropType swig_types[6] 
+#define  SWIGTYPE_p_SWISH_HEADER_TYPE swig_types[7] 
+#define  SWIGTYPE_p_p_void swig_types[8] 
+#define  SWIGTYPE_p_void swig_types[9] 
+#define  SWIGTYPE_p_PropValue swig_types[10] 
+static swig_type_info *swig_types[12];
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_swishe_base
+#define SWIG_name    "Swishe_base"
+
+static VALUE mSwishe_base;
+
+static void SWIG_AsVal(VALUE obj, int *val)
+{
+    *val = (int) NUM2INT(obj);
+}
+
+
+#include "stdio.h"
+#include "swish-e.h"
+
+
+
+swig_class cSWISH_HEADER_VALUE;
+static void free_SWISH_HEADER_VALUE(SWISH_HEADER_VALUE *);
+
+swig_class cU_PropValue1;
+static void free_u_PropValue1(u_PropValue1 *);
+
+swig_class cPropValue;
+static void free_PropValue(PropValue *);
+static VALUE
+_wrap_SWISH_HEADER_VALUE_string_set(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    char *arg2 = (char *) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    arg2 = StringValuePtr(argv[0]);
+    {
+        if (arg2) {
+            arg1->string = (char const *) malloc(strlen(arg2)+1);
+            strcpy((char*)arg1->string,arg2);
+        } else {
+            arg1->string = 0;
+        }
+    }
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_string_get(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    result = (char *) ((arg1)->string);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_string_list_set(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    char **arg2 = (char **) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_char, 1);
+    if (arg1) (arg1)->string_list = (char const **)arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_string_list_get(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    char **result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    result = (char **) ((arg1)->string_list);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_char,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_number_set(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    unsigned long arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    arg2 = NUM2ULONG(argv[0]);
+    if (arg1) (arg1)->number = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_number_get(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    unsigned long result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    result = (unsigned long) ((arg1)->number);
+    
+    vresult = UINT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_boolean_set(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    int arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    arg2 = NUM2INT(argv[0]);
+    if (arg1) (arg1)->boolean = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SWISH_HEADER_VALUE_boolean_get(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *arg1 = (SWISH_HEADER_VALUE *) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    result = (int) ((arg1)->boolean);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+static VALUE
+_wrap_SWISH_HEADER_VALUE_allocate(VALUE self) {
+#else
+    static VALUE
+    _wrap_SWISH_HEADER_VALUE_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+        
+        
+        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_SWISH_HEADER_VALUE);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+        rb_obj_call_init(vresult, argc, argv);
+#endif
+        return vresult;
+    }
+    
+
+static VALUE
+_wrap_new_SWISH_HEADER_VALUE(int argc, VALUE *argv, VALUE self) {
+    SWISH_HEADER_VALUE *result;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    result = (SWISH_HEADER_VALUE *)(SWISH_HEADER_VALUE *) calloc(1, sizeof(SWISH_HEADER_VALUE));
+    DATA_PTR(self) = result;
+    return self;
+}
+
+
+static void
+free_SWISH_HEADER_VALUE(SWISH_HEADER_VALUE *arg1) {
+    free((char *) arg1);
+}
+static VALUE
+_wrap_SwishHeaderNames(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char **result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char **)SwishHeaderNames(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_char,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishIndexNames(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char **result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char **)SwishIndexNames(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_char,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishHeaderValue(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    SWISH_HEADER_TYPE *arg4 = (SWISH_HEADER_TYPE *) 0 ;
+    SWISH_HEADER_VALUE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 4) || (argc > 4))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = StringValuePtr(argv[2]);
+    SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_SWISH_HEADER_TYPE, 1);
+    result = SwishHeaderValue(arg1,(char const *)arg2,(char const *)arg3,arg4);
+    
+    {
+        SWISH_HEADER_VALUE * resultptr;
+        resultptr = (SWISH_HEADER_VALUE *) malloc(sizeof(SWISH_HEADER_VALUE));
+        memmove(resultptr, &result, sizeof(SWISH_HEADER_VALUE));
+        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    }
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResultIndexValue(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *arg2 = (char *) 0 ;
+    SWISH_HEADER_TYPE *arg3 = (SWISH_HEADER_TYPE *) 0 ;
+    SWISH_HEADER_VALUE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 3) || (argc > 3))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_SWISH_HEADER_TYPE, 1);
+    result = SwishResultIndexValue(arg1,(char const *)arg2,arg3);
+    
+    {
+        SWISH_HEADER_VALUE * resultptr;
+        resultptr = (SWISH_HEADER_VALUE *) malloc(sizeof(SWISH_HEADER_VALUE));
+        memmove(resultptr, &result, sizeof(SWISH_HEADER_VALUE));
+        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    }
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishMetaList(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    SWISH_META_LIST result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SWISH_META_LIST)SwishMetaList(arg1,(char const *)arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishPropertyList(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    SWISH_META_LIST result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SWISH_META_LIST)SwishPropertyList(arg1,(char const *)arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResultMetaList(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    SWISH_META_LIST result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (SWISH_META_LIST)SwishResultMetaList(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResultPropertyList(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    SWISH_META_LIST result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (SWISH_META_LIST)SwishResultPropertyList(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishMetaName(int argc, VALUE *argv, VALUE self) {
+    SW_META arg1 = (SW_META) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char *)SwishMetaName(arg1);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishMetaType(int argc, VALUE *argv, VALUE self) {
+    SW_META arg1 = (SW_META) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishMetaType(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishMetaID(int argc, VALUE *argv, VALUE self) {
+    SW_META arg1 = (SW_META) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishMetaID(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishInit(int argc, VALUE *argv, VALUE self) {
+    char *arg1 = (char *) 0 ;
+    SW_HANDLE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    arg1 = StringValuePtr(argv[0]);
+    result = (SW_HANDLE)SwishInit(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishQuery(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    SW_RESULTS result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SW_RESULTS)SwishQuery(arg1,arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_New_Search_Object(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    SW_SEARCH result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SW_SEARCH)New_Search_Object(arg1,arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishRankScheme(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    int arg2 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = NUM2INT(argv[1]);
+    SwishRankScheme(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishSetRefPtr(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    void *arg2 = (void *) 0 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SWIG_ConvertPtr(argv[1], (void **) &arg2, 0, 1);
+    SwishSetRefPtr(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishGetRefPtr(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    void *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (void *)SwishGetRefPtr(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishSearch_parent(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    void *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (void *)SwishSearch_parent(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResults_parent(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    void *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (void *)SwishResults_parent(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResult_parent(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    void *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (void *)SwishResult_parent(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_ResultsSetRefPtr(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    void *arg2 = (void *) 0 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SWIG_ConvertPtr(argv[1], (void **) &arg2, 0, 1);
+    ResultsSetRefPtr(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishSetStructure(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    int arg2 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = NUM2INT(argv[1]);
+    SwishSetStructure(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishPhraseDelimiter(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    char arg2 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = NUM2CHR(argv[1]);
+    SwishPhraseDelimiter(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishSetSort(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    char *arg2 = (char *) 0 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    SwishSetSort(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishSetQuery(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    char *arg2 = (char *) 0 ;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    SwishSetQuery(arg1,arg2);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishSetSearchLimit(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    char *arg4 = (char *) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 4) || (argc > 4))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = StringValuePtr(argv[2]);
+    arg4 = StringValuePtr(argv[3]);
+    result = (int)SwishSetSearchLimit(arg1,arg2,arg3,arg4);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResetSearchLimit(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SwishResetSearchLimit(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishExecute(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    char *arg2 = (char *) 0 ;
+    SW_RESULTS result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SW_RESULTS)SwishExecute(arg1,arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishHits(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishHits(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishParsedWords(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    char *arg2 = (char *) 0 ;
+    SWISH_HEADER_VALUE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = SwishParsedWords(arg1,(char const *)arg2);
+    
+    {
+        SWISH_HEADER_VALUE * resultptr;
+        resultptr = (SWISH_HEADER_VALUE *) malloc(sizeof(SWISH_HEADER_VALUE));
+        memmove(resultptr, &result, sizeof(SWISH_HEADER_VALUE));
+        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    }
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishRemovedStopwords(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    char *arg2 = (char *) 0 ;
+    SWISH_HEADER_VALUE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = SwishRemovedStopwords(arg1,(char const *)arg2);
+    
+    {
+        SWISH_HEADER_VALUE * resultptr;
+        resultptr = (SWISH_HEADER_VALUE *) malloc(sizeof(SWISH_HEADER_VALUE));
+        memmove(resultptr, &result, sizeof(SWISH_HEADER_VALUE));
+        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_SWISH_HEADER_VALUE, 1);
+    }
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishSeekResult(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    int arg2 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = NUM2INT(argv[1]);
+    result = (int)SwishSeekResult(arg1,arg2);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishNextResult(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    SW_RESULT result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (SW_RESULT)SwishNextResult(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResultPropertyStr(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (char *)SwishResultPropertyStr(arg1,arg2);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishResultPropertyULong(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *arg2 = (char *) 0 ;
+    unsigned long result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (unsigned long)SwishResultPropertyULong(arg1,arg2);
+    
+    vresult = UINT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SW_ResultToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    SW_HANDLE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (SW_HANDLE)SW_ResultToSW_HANDLE(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SW_ResultsToSW_HANDLE(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    SW_HANDLE result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (SW_HANDLE)SW_ResultsToSW_HANDLE(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_Free_Search_Object(int argc, VALUE *argv, VALUE self) {
+    SW_SEARCH arg1 = (SW_SEARCH) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    Free_Search_Object(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_Free_Results_Object(int argc, VALUE *argv, VALUE self) {
+    SW_RESULTS arg1 = (SW_RESULTS) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    Free_Results_Object(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishClose(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SwishClose(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishError(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishError(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishCriticalError(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishCriticalError(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishAbortLastError(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SwishAbortLastError(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishErrorString(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char *)SwishErrorString(arg1);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishLastErrorMsg(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char *)SwishLastErrorMsg(arg1);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_set_error_handle(int argc, VALUE *argv, VALUE self) {
+    FILE *arg1 = (FILE *) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FILE, 1);
+    set_error_handle(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishErrorsToStderr(int argc, VALUE *argv, VALUE self) {
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SwishErrorsToStderr();
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishWordsByLetter(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    char arg3 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 3) || (argc > 3))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = NUM2CHR(argv[2]);
+    result = (char *)SwishWordsByLetter(arg1,arg2,arg3);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishStemWord(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (char *)SwishStemWord(arg1,arg2);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyWord(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *arg2 = (char *) 0 ;
+    SW_FUZZYWORD result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 2) || (argc > 2))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    result = (SW_FUZZYWORD)SwishFuzzyWord(arg1,arg2);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzy(int argc, VALUE *argv, VALUE self) {
+    SW_HANDLE arg1 = (SW_HANDLE) 0 ;
+    char *arg2 = (char *) 0 ;
+    char *arg3 = (char *) 0 ;
+    SW_FUZZYWORD result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 3) || (argc > 3))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = StringValuePtr(argv[2]);
+    result = (SW_FUZZYWORD)SwishFuzzy(arg1,(char const *)arg2,arg3);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_void,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyWordList(int argc, VALUE *argv, VALUE self) {
+    SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
+    char **result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char **)SwishFuzzyWordList(arg1);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_char,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyWordCount(int argc, VALUE *argv, VALUE self) {
+    SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishFuzzyWordCount(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyWordError(int argc, VALUE *argv, VALUE self) {
+    SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (int)SwishFuzzyWordError(arg1);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyWordFree(int argc, VALUE *argv, VALUE self) {
+    SW_FUZZYWORD arg1 = (SW_FUZZYWORD) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    SwishFuzzyWordFree(arg1);
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_SwishFuzzyMode(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    result = (char *)SwishFuzzyMode(arg1);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_str_set(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    char *arg2 = (char *) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    arg2 = StringValuePtr(argv[0]);
+    {
+        if (arg1->v_str) free((char*)arg1->v_str);
+        if (arg2) {
+            arg1->v_str = (char *) malloc(strlen(arg2)+1);
+            strcpy((char*)arg1->v_str,arg2);
+        } else {
+            arg1->v_str = 0;
+        }
+    }
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_str_get(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    char *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    result = (char *) ((arg1)->v_str);
+    
+    vresult = rb_str_new2(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_int_set(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    int arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    arg2 = NUM2INT(argv[0]);
+    if (arg1) (arg1)->v_int = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_int_get(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    result = (int) ((arg1)->v_int);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_date_set(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    time_t arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    {
+        time_t * ptr;
+        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_time_t, 1);
+        if (ptr) arg2 = *ptr;
+    }
+    if (arg1) (arg1)->v_date = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_date_get(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    time_t result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    result =  ((arg1)->v_date);
+    
+    {
+        time_t * resultptr;
+        resultptr = (time_t *) malloc(sizeof(time_t));
+        memmove(resultptr, &result, sizeof(time_t));
+        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_time_t, 1);
+    }
+    return vresult;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_float_set(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    double arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    arg2 = (double) NUM2DBL(argv[0]);
+    if (arg1) (arg1)->v_float = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_float_get(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    double result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    result = (double) ((arg1)->v_float);
+    
+    vresult = rb_float_new(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_ulong_set(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    unsigned long arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    arg2 = NUM2ULONG(argv[0]);
+    if (arg1) (arg1)->v_ulong = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_u_PropValue1_v_ulong_get(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *arg1 = (u_PropValue1 *) 0 ;
+    unsigned long result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_u_PropValue1, 1);
+    result = (unsigned long) ((arg1)->v_ulong);
+    
+    vresult = UINT2NUM(result);
+    return vresult;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+static VALUE
+_wrap_u_PropValue1_allocate(VALUE self) {
+#else
+    static VALUE
+    _wrap_u_PropValue1_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+        
+        
+        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_u_PropValue1);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+        rb_obj_call_init(vresult, argc, argv);
+#endif
+        return vresult;
+    }
+    
+
+static VALUE
+_wrap_new_u_PropValue1(int argc, VALUE *argv, VALUE self) {
+    u_PropValue1 *result;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    result = (u_PropValue1 *)(u_PropValue1 *) calloc(1, sizeof(u_PropValue1));
+    DATA_PTR(self) = result;
+    return self;
+}
+
+
+static void
+free_u_PropValue1(u_PropValue1 *arg1) {
+    free((char *) arg1);
+}
+static VALUE
+_wrap_PropValue_datatype_set(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    PropType arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    arg2 = (PropType) NUM2INT(argv[0]);
+    if (arg1) (arg1)->datatype = (PropType )arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_PropValue_datatype_get(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    PropType result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    result = (PropType) ((arg1)->datatype);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_PropValue_value_set(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    u_PropValue1 *arg2 = (u_PropValue1 *) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_u_PropValue1, 1);
+    if (arg1) (arg1)->value = *arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_PropValue_value_get(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    u_PropValue1 *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    result = (u_PropValue1 *)& ((arg1)->value);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_u_PropValue1,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_PropValue_destroy_set(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    int arg2 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    arg2 = NUM2INT(argv[0]);
+    if (arg1) (arg1)->destroy = arg2;
+    
+    return Qnil;
+}
+
+
+static VALUE
+_wrap_PropValue_destroy_get(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    int result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    result = (int) ((arg1)->destroy);
+    
+    vresult = INT2NUM(result);
+    return vresult;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+static VALUE
+_wrap_PropValue_allocate(VALUE self) {
+#else
+    static VALUE
+    _wrap_PropValue_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+        
+        
+        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_PropValue);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+        rb_obj_call_init(vresult, argc, argv);
+#endif
+        return vresult;
+    }
+    
+
+static VALUE
+_wrap_new_PropValue(int argc, VALUE *argv, VALUE self) {
+    PropValue *result;
+    
+    if ((argc < 0) || (argc > 0))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+    result = (PropValue *)(PropValue *) calloc(1, sizeof(PropValue));
+    DATA_PTR(self) = result;
+    return self;
+}
+
+
+static void
+free_PropValue(PropValue *arg1) {
+    free((char *) arg1);
+}
+static VALUE
+_wrap_getResultPropValue(int argc, VALUE *argv, VALUE self) {
+    SW_RESULT arg1 = (SW_RESULT) 0 ;
+    char *arg2 = (char *) 0 ;
+    int arg3 ;
+    PropValue *result;
+    VALUE vresult = Qnil;
+    
+    if ((argc < 3) || (argc > 3))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, 0, 1);
+    arg2 = StringValuePtr(argv[1]);
+    arg3 = NUM2INT(argv[2]);
+    result = (PropValue *)getResultPropValue(arg1,arg2,arg3);
+    
+    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_PropValue,0);
+    return vresult;
+}
+
+
+static VALUE
+_wrap_freeResultPropValue(int argc, VALUE *argv, VALUE self) {
+    PropValue *arg1 = (PropValue *) 0 ;
+    
+    if ((argc < 1) || (argc > 1))
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
+    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_PropValue, 1);
+    freeResultPropValue(arg1);
+    
+    return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static swig_type_info _swigt__p_FILE[] = {{"_p_FILE", 0, "FILE *", 0, 0, 0, 0},{"_p_FILE", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_time_t[] = {{"_p_time_t", 0, "time_t *", 0, 0, 0, 0},{"_p_time_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|VALUE *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_u_PropValue1[] = {{"_p_u_PropValue1", 0, "u_PropValue1 *", 0, 0, 0, 0},{"_p_u_PropValue1", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_SWISH_HEADER_VALUE[] = {{"_p_SWISH_HEADER_VALUE", 0, "SWISH_HEADER_VALUE *", 0, 0, 0, 0},{"_p_SWISH_HEADER_VALUE", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0, 0, 0, 0},{"_p_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_PropType[] = {{"_p_PropType", 0, "enum PropType *|PropType *", 0, 0, 0, 0},{"_p_PropType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_SWISH_HEADER_TYPE[] = {{"_p_SWISH_HEADER_TYPE", 0, "enum SWISH_HEADER_TYPE *|SWISH_HEADER_TYPE *", 0, 0, 0, 0},{"_p_SWISH_HEADER_TYPE", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_p_void[] = {{"_p_p_void", 0, "void **|SWISH_META_LIST", 0, 0, 0, 0},{"_p_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *|SW_FUZZYWORD", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+static swig_type_info _swigt__p_PropValue[] = {{"_p_PropValue", 0, "PropValue *", 0, 0, 0, 0},{"_p_PropValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
+
+static swig_type_info *swig_types_initial[] = {
+_swigt__p_FILE, 
+_swigt__p_time_t, 
+_swigt__p_unsigned_long, 
+_swigt__p_u_PropValue1, 
+_swigt__p_SWISH_HEADER_VALUE, 
+_swigt__p_p_char, 
+_swigt__p_PropType, 
+_swigt__p_SWISH_HEADER_TYPE, 
+_swigt__p_p_void, 
+_swigt__p_void, 
+_swigt__p_PropValue, 
+0
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT(void) Init_swishe_base(void) {
+    int i;
+    
+    SWIG_InitRuntime();
+    mSwishe_base = rb_define_module("Swishe_base");
+    
+    for (i = 0; swig_types_initial[i]; i++) {
+        swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
+        SWIG_define_class(swig_types[i]);
+    }
+    
+    rb_define_const(mSwishe_base,"SWISH_NUMBER", INT2NUM(SWISH_NUMBER));
+    rb_define_const(mSwishe_base,"SWISH_STRING", INT2NUM(SWISH_STRING));
+    rb_define_const(mSwishe_base,"SWISH_LIST", INT2NUM(SWISH_LIST));
+    rb_define_const(mSwishe_base,"SWISH_BOOL", INT2NUM(SWISH_BOOL));
+    rb_define_const(mSwishe_base,"SWISH_WORD_HASH", INT2NUM(SWISH_WORD_HASH));
+    rb_define_const(mSwishe_base,"SWISH_OTHER_DATA", INT2NUM(SWISH_OTHER_DATA));
+    rb_define_const(mSwishe_base,"SWISH_HEADER_ERROR", INT2NUM(SWISH_HEADER_ERROR));
+    
+    cSWISH_HEADER_VALUE.klass = rb_define_class_under(mSwishe_base, "SWISH_HEADER_VALUE", rb_cObject);
+    SWIG_TypeClientData(SWIGTYPE_p_SWISH_HEADER_VALUE, (void *) &cSWISH_HEADER_VALUE);
+    rb_define_alloc_func(cSWISH_HEADER_VALUE.klass, _wrap_SWISH_HEADER_VALUE_allocate);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "initialize", _wrap_new_SWISH_HEADER_VALUE, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "string=", _wrap_SWISH_HEADER_VALUE_string_set, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "string", _wrap_SWISH_HEADER_VALUE_string_get, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "string_list=", _wrap_SWISH_HEADER_VALUE_string_list_set, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "string_list", _wrap_SWISH_HEADER_VALUE_string_list_get, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "number=", _wrap_SWISH_HEADER_VALUE_number_set, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "number", _wrap_SWISH_HEADER_VALUE_number_get, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "boolean=", _wrap_SWISH_HEADER_VALUE_boolean_set, -1);
+    rb_define_method(cSWISH_HEADER_VALUE.klass, "boolean", _wrap_SWISH_HEADER_VALUE_boolean_get, -1);
+    cSWISH_HEADER_VALUE.mark = 0;
+    cSWISH_HEADER_VALUE.destroy = (void (*)(void *)) free_SWISH_HEADER_VALUE;
+    rb_define_module_function(mSwishe_base, "SwishHeaderNames", _wrap_SwishHeaderNames, -1);
+    rb_define_module_function(mSwishe_base, "SwishIndexNames", _wrap_SwishIndexNames, -1);
+    rb_define_module_function(mSwishe_base, "SwishHeaderValue", _wrap_SwishHeaderValue, -1);
+    rb_define_module_function(mSwishe_base, "SwishResultIndexValue", _wrap_SwishResultIndexValue, -1);
+    rb_define_const(mSwishe_base,"SW_META_TYPE_UNDEF", INT2NUM(0));
+    rb_define_const(mSwishe_base,"SW_META_TYPE_STRING", INT2NUM(4));
+    rb_define_const(mSwishe_base,"SW_META_TYPE_ULONG", INT2NUM(8));
+    rb_define_const(mSwishe_base,"SW_META_TYPE_DATE", INT2NUM(16));
+    rb_define_module_function(mSwishe_base, "SwishMetaList", _wrap_SwishMetaList, -1);
+    rb_define_module_function(mSwishe_base, "SwishPropertyList", _wrap_SwishPropertyList, -1);
+    rb_define_module_function(mSwishe_base, "SwishResultMetaList", _wrap_SwishResultMetaList, -1);
+    rb_define_module_function(mSwishe_base, "SwishResultPropertyList", _wrap_SwishResultPropertyList, -1);
+    rb_define_module_function(mSwishe_base, "SwishMetaName", _wrap_SwishMetaName, -1);
+    rb_define_module_function(mSwishe_base, "SwishMetaType", _wrap_SwishMetaType, -1);
+    rb_define_module_function(mSwishe_base, "SwishMetaID", _wrap_SwishMetaID, -1);
+    rb_define_const(mSwishe_base,"IN_FILE_BIT", INT2NUM(0));
+    rb_define_const(mSwishe_base,"IN_TITLE_BIT", INT2NUM(1));
+    rb_define_const(mSwishe_base,"IN_HEAD_BIT", INT2NUM(2));
+    rb_define_const(mSwishe_base,"IN_BODY_BIT", INT2NUM(3));
+    rb_define_const(mSwishe_base,"IN_COMMENTS_BIT", INT2NUM(4));
+    rb_define_const(mSwishe_base,"IN_HEADER_BIT", INT2NUM(5));
+    rb_define_const(mSwishe_base,"IN_EMPHASIZED_BIT", INT2NUM(6));
+    rb_define_const(mSwishe_base,"IN_META_BIT", INT2NUM(7));
+    rb_define_const(mSwishe_base,"IN_FILE", INT2NUM((1<<0)));
+    rb_define_const(mSwishe_base,"IN_TITLE", INT2NUM((1<<1)));
+    rb_define_const(mSwishe_base,"IN_HEAD", INT2NUM((1<<2)));
+    rb_define_const(mSwishe_base,"IN_BODY", INT2NUM((1<<3)));
+    rb_define_const(mSwishe_base,"IN_COMMENTS", INT2NUM((1<<4)));
+    rb_define_const(mSwishe_base,"IN_HEADER", INT2NUM((1<<5)));
+    rb_define_const(mSwishe_base,"IN_EMPHASIZED", INT2NUM((1<<6)));
+    rb_define_const(mSwishe_base,"IN_META", INT2NUM((1<<7)));
+    rb_define_const(mSwishe_base,"IN_ALL", INT2NUM(((1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7))));
+    rb_define_module_function(mSwishe_base, "SwishInit", _wrap_SwishInit, -1);
+    rb_define_module_function(mSwishe_base, "SwishQuery", _wrap_SwishQuery, -1);
+    rb_define_module_function(mSwishe_base, "New_Search_Object", _wrap_New_Search_Object, -1);
+    rb_define_module_function(mSwishe_base, "SwishRankScheme", _wrap_SwishRankScheme, -1);
+    rb_define_module_function(mSwishe_base, "SwishSetRefPtr", _wrap_SwishSetRefPtr, -1);
+    rb_define_module_function(mSwishe_base, "SwishGetRefPtr", _wrap_SwishGetRefPtr, -1);
+    rb_define_module_function(mSwishe_base, "SwishSearch_parent", _wrap_SwishSearch_parent, -1);
+    rb_define_module_function(mSwishe_base, "SwishResults_parent", _wrap_SwishResults_parent, -1);
+    rb_define_module_function(mSwishe_base, "SwishResult_parent", _wrap_SwishResult_parent, -1);
+    rb_define_module_function(mSwishe_base, "ResultsSetRefPtr", _wrap_ResultsSetRefPtr, -1);
+    rb_define_module_function(mSwishe_base, "SwishSetStructure", _wrap_SwishSetStructure, -1);
+    rb_define_module_function(mSwishe_base, "SwishPhraseDelimiter", _wrap_SwishPhraseDelimiter, -1);
+    rb_define_module_function(mSwishe_base, "SwishSetSort", _wrap_SwishSetSort, -1);
+    rb_define_module_function(mSwishe_base, "SwishSetQuery", _wrap_SwishSetQuery, -1);
+    rb_define_module_function(mSwishe_base, "SwishSetSearchLimit", _wrap_SwishSetSearchLimit, -1);
+    rb_define_module_function(mSwishe_base, "SwishResetSearchLimit", _wrap_SwishResetSearchLimit, -1);
+    rb_define_module_function(mSwishe_base, "SwishExecute", _wrap_SwishExecute, -1);
+    rb_define_module_function(mSwishe_base, "SwishHits", _wrap_SwishHits, -1);
+    rb_define_module_function(mSwishe_base, "SwishParsedWords", _wrap_SwishParsedWords, -1);
+    rb_define_module_function(mSwishe_base, "SwishRemovedStopwords", _wrap_SwishRemovedStopwords, -1);
+    rb_define_module_function(mSwishe_base, "SwishSeekResult", _wrap_SwishSeekResult, -1);
+    rb_define_module_function(mSwishe_base, "SwishNextResult", _wrap_SwishNextResult, -1);
+    rb_define_module_function(mSwishe_base, "SwishResultPropertyStr", _wrap_SwishResultPropertyStr, -1);
+    rb_define_module_function(mSwishe_base, "SwishResultPropertyULong", _wrap_SwishResultPropertyULong, -1);
+    rb_define_module_function(mSwishe_base, "SW_ResultToSW_HANDLE", _wrap_SW_ResultToSW_HANDLE, -1);
+    rb_define_module_function(mSwishe_base, "SW_ResultsToSW_HANDLE", _wrap_SW_ResultsToSW_HANDLE, -1);
+    rb_define_module_function(mSwishe_base, "Free_Search_Object", _wrap_Free_Search_Object, -1);
+    rb_define_module_function(mSwishe_base, "Free_Results_Object", _wrap_Free_Results_Object, -1);
+    rb_define_module_function(mSwishe_base, "SwishClose", _wrap_SwishClose, -1);
+    rb_define_module_function(mSwishe_base, "SwishError", _wrap_SwishError, -1);
+    rb_define_module_function(mSwishe_base, "SwishCriticalError", _wrap_SwishCriticalError, -1);
+    rb_define_module_function(mSwishe_base, "SwishAbortLastError", _wrap_SwishAbortLastError, -1);
+    rb_define_module_function(mSwishe_base, "SwishErrorString", _wrap_SwishErrorString, -1);
+    rb_define_module_function(mSwishe_base, "SwishLastErrorMsg", _wrap_SwishLastErrorMsg, -1);
+    rb_define_module_function(mSwishe_base, "set_error_handle", _wrap_set_error_handle, -1);
+    rb_define_module_function(mSwishe_base, "SwishErrorsToStderr", _wrap_SwishErrorsToStderr, -1);
+    rb_define_module_function(mSwishe_base, "SwishWordsByLetter", _wrap_SwishWordsByLetter, -1);
+    rb_define_module_function(mSwishe_base, "SwishStemWord", _wrap_SwishStemWord, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyWord", _wrap_SwishFuzzyWord, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzy", _wrap_SwishFuzzy, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyWordList", _wrap_SwishFuzzyWordList, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyWordCount", _wrap_SwishFuzzyWordCount, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyWordError", _wrap_SwishFuzzyWordError, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyWordFree", _wrap_SwishFuzzyWordFree, -1);
+    rb_define_module_function(mSwishe_base, "SwishFuzzyMode", _wrap_SwishFuzzyMode, -1);
+    rb_define_const(mSwishe_base,"PROP_UNDEFINED", INT2NUM(PROP_UNDEFINED));
+    rb_define_const(mSwishe_base,"PROP_UNKNOWN", INT2NUM(PROP_UNKNOWN));
+    rb_define_const(mSwishe_base,"PROP_STRING", INT2NUM(PROP_STRING));
+    rb_define_const(mSwishe_base,"PROP_INTEGER", INT2NUM(PROP_INTEGER));
+    rb_define_const(mSwishe_base,"PROP_FLOAT", INT2NUM(PROP_FLOAT));
+    rb_define_const(mSwishe_base,"PROP_DATE", INT2NUM(PROP_DATE));
+    rb_define_const(mSwishe_base,"PROP_ULONG", INT2NUM(PROP_ULONG));
+    
+    cU_PropValue1.klass = rb_define_class_under(mSwishe_base, "U_PropValue1", rb_cObject);
+    SWIG_TypeClientData(SWIGTYPE_p_u_PropValue1, (void *) &cU_PropValue1);
+    rb_define_alloc_func(cU_PropValue1.klass, _wrap_u_PropValue1_allocate);
+    rb_define_method(cU_PropValue1.klass, "initialize", _wrap_new_u_PropValue1, -1);
+    rb_define_method(cU_PropValue1.klass, "v_str=", _wrap_u_PropValue1_v_str_set, -1);
+    rb_define_method(cU_PropValue1.klass, "v_str", _wrap_u_PropValue1_v_str_get, -1);
+    rb_define_method(cU_PropValue1.klass, "v_int=", _wrap_u_PropValue1_v_int_set, -1);
+    rb_define_method(cU_PropValue1.klass, "v_int", _wrap_u_PropValue1_v_int_get, -1);
+    rb_define_method(cU_PropValue1.klass, "v_date=", _wrap_u_PropValue1_v_date_set, -1);
+    rb_define_method(cU_PropValue1.klass, "v_date", _wrap_u_PropValue1_v_date_get, -1);
+    rb_define_method(cU_PropValue1.klass, "v_float=", _wrap_u_PropValue1_v_float_set, -1);
+    rb_define_method(cU_PropValue1.klass, "v_float", _wrap_u_PropValue1_v_float_get, -1);
+    rb_define_method(cU_PropValue1.klass, "v_ulong=", _wrap_u_PropValue1_v_ulong_set, -1);
+    rb_define_method(cU_PropValue1.klass, "v_ulong", _wrap_u_PropValue1_v_ulong_get, -1);
+    cU_PropValue1.mark = 0;
+    cU_PropValue1.destroy = (void (*)(void *)) free_u_PropValue1;
+    
+    cPropValue.klass = rb_define_class_under(mSwishe_base, "PropValue", rb_cObject);
+    SWIG_TypeClientData(SWIGTYPE_p_PropValue, (void *) &cPropValue);
+    rb_define_alloc_func(cPropValue.klass, _wrap_PropValue_allocate);
+    rb_define_method(cPropValue.klass, "initialize", _wrap_new_PropValue, -1);
+    rb_define_method(cPropValue.klass, "datatype=", _wrap_PropValue_datatype_set, -1);
+    rb_define_method(cPropValue.klass, "datatype", _wrap_PropValue_datatype_get, -1);
+    rb_define_method(cPropValue.klass, "value=", _wrap_PropValue_value_set, -1);
+    rb_define_method(cPropValue.klass, "value", _wrap_PropValue_value_get, -1);
+    rb_define_method(cPropValue.klass, "destroy=", _wrap_PropValue_destroy_set, -1);
+    rb_define_method(cPropValue.klass, "destroy", _wrap_PropValue_destroy_get, -1);
+    cPropValue.mark = 0;
+    cPropValue.destroy = (void (*)(void *)) free_PropValue;
+    rb_define_module_function(mSwishe_base, "getResultPropValue", _wrap_getResultPropValue, -1);
+    rb_define_module_function(mSwishe_base, "freeResultPropValue", _wrap_freeResultPropValue, -1);
+}
+