sdsykes-ferret 0.11.6.19

data/ext/lang.h

@@ -0,0 +1,66 @@
+#ifndef FRT_LANG_H
+#define FRT_LANG_H
+
+#define RUBY_BINDINGS 1
+
+#include <stdarg.h>
+#include <ruby.h>
+
+#undef close
+#undef rename
+#undef read
+
+#define frt_malloc xmalloc
+#define frt_calloc(n) xcalloc(n, 1)
+#define frt_realloc xrealloc
+
+
+#ifdef FRT_HAS_ISO_VARARGS
+/* C99-compliant compiler */
+
+# define FRT_EXIT(...) frt_rb_raise(__FILE__, __LINE__, __func__, __VA_ARGS__)
+extern void frt_rb_raise(const char *file, int line_num, const char *func,
+                         const char *err_type, const char *fmt, ...);
+
+# define V_FRT_EXIT(err_type, fmt, args) \
+    vfrt_rb_raise(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void vfrt_rb_raise(const char *file, int line_num, const char *func,
+                          const char *err_type, const char *fmt, va_list args);
+
+#elif defined(FRT_HAS_GNUC_VARARGS)
+/* gcc has an extension */
+
+# define FRT_EXIT(args...) frt_rb_raise(__FILE__, __LINE__, __func__, ##args)
+extern void frt_rb_raise(const char *file, int line_num, const char *func,
+                         const char *err_type, const char *fmt, ...);
+
+# define V_FRT_EXIT(err_type, fmt, args) \
+    vfrt_rb_raise(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void vfrt_rb_raise(const char *file, int line_num, const char *func,
+                          const char *err_type, const char *fmt, va_list args);
+#else
+/* Can't do VARARGS */
+
+extern void FRT_EXIT(const char *err_type, const char *fmt, ...);
+extern void V_FRT_EXIT(const char *err_type, const char *fmt, va_list args);
+#endif
+
+#ifdef RUBY_RUBY_H
+#  define FRT_RUBY_VERSION_1_9
+#endif
+
+// ruby 1.8 compat with 1.9 to avoid ifdefs
+#if !defined RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+#if !defined RSTRING_PTR
+#define RSTRING_PTR(a) RSTRING(a)->ptr
+#endif
+#if !defined RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+#if !defined RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+#endif

data/ext/libstemmer.c

@@ -0,0 +1,92 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include "libstemmer.h"
+#include "api.h"
+#include "modules.h"
+
+struct sb_stemmer {
+    struct SN_env * (*create)(void);
+    void (*close)(struct SN_env *);
+    int (*stem)(struct SN_env *);
+
+    struct SN_env * env;
+};
+
+extern const char **
+sb_stemmer_list(void)
+{
+    return algorithm_names;
+}
+
+static stemmer_encoding sb_getenc(const char * charenc)
+{
+    struct stemmer_encoding * encoding;
+    if (charenc == NULL) return ENC_UTF_8;
+    for (encoding = encodings; encoding->name != 0; encoding++) {
+	if (strcmp(encoding->name, charenc) == 0) break;
+    }
+    if (encoding->name == NULL) return ENC_UNKNOWN;
+    return encoding->enc;
+}
+
+extern struct sb_stemmer *
+sb_stemmer_new(const char * algorithm, const char * charenc)
+{
+    stemmer_encoding enc;
+    struct stemmer_modules * module;
+    struct sb_stemmer * stemmer =
+	    (struct sb_stemmer *) malloc(sizeof(struct sb_stemmer));
+    if (stemmer == NULL) return NULL;
+    enc = sb_getenc(charenc);
+    if (enc == ENC_UNKNOWN) return NULL;
+
+    for (module = modules; module->name != 0; module++) {
+	if (strcmp(module->name, algorithm) == 0 && module->enc == enc) break;
+    }
+    if (module->name == NULL) return NULL;
+    
+    stemmer->create = module->create;
+    stemmer->close = module->close;
+    stemmer->stem = module->stem;
+
+    stemmer->env = stemmer->create();
+    if (stemmer->env == NULL)
+    {
+        sb_stemmer_delete(stemmer);
+        return NULL;
+    }
+
+    return stemmer;
+}
+
+void
+sb_stemmer_delete(struct sb_stemmer * stemmer)
+{
+    if (stemmer == 0) return;
+    if (stemmer->close == 0) return;
+    stemmer->close(stemmer->env);
+    stemmer->close = 0;
+    free(stemmer);
+}
+
+const sb_symbol *
+sb_stemmer_stem(struct sb_stemmer * stemmer, const sb_symbol * word, int size)
+{
+    int ret;
+    if (SN_set_current(stemmer->env, size, (const symbol *)(word)))
+    {
+        stemmer->env->l = 0;
+        return NULL;
+    }
+    ret = stemmer->stem(stemmer->env);
+    if (ret < 0) return NULL;
+    stemmer->env->p[stemmer->env->l] = 0;
+    return (const sb_symbol *)(stemmer->env->p);
+}
+
+int
+sb_stemmer_length(struct sb_stemmer * stemmer)
+{
+    return stemmer->env->l;
+}

data/ext/libstemmer.h

@@ -0,0 +1,79 @@
+
+/* Make header file work when included from C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct sb_stemmer;
+typedef unsigned char sb_symbol;
+
+/* FIXME - should be able to get a version number for each stemming
+ * algorithm (which will be incremented each time the output changes). */
+
+/** Returns an array of the names of the available stemming algorithms.
+ *  Note that these are the canonical names - aliases (ie, other names for
+ *  the same algorithm) will not be included in the list.
+ *  The list is terminated with a null pointer.
+ *
+ *  The list must not be modified in any way.
+ */
+const char ** sb_stemmer_list(void);
+
+/** Create a new stemmer object, using the specified algorithm, for the
+ *  specified character encoding.
+ *
+ *  All algorithms will usually be available in UTF-8, but may also be
+ *  available in other character encodings.
+ *
+ *  @param algorithm The algorithm name.  This is either the english
+ *  name of the algorithm, or the 2 or 3 letter ISO 639 codes for the
+ *  language.  Note that case is significant in this parameter - the
+ *  value should be supplied in lower case.
+ *
+ *  @param charenc The character encoding.  NULL may be passed as
+ *  this value, in which case UTF-8 encoding will be assumed. Otherwise,
+ *  the argument may be one of "UTF_8", "ISO_8859_1" (ie, Latin 1),
+ *  "CP850" (ie, MS-DOS Latin 1) or "KOI8_R" (Russian).  Note that
+ *  case is significant in this parameter.
+ *
+ *  @return NULL if the specified algorithm is not recognised, or the
+ *  algorithm is not available for the requested encoding.  Otherwise,
+ *  returns a pointer to a newly created stemmer for the requested algorithm.
+ *  The returned pointer must be deleted by calling sb_stemmer_delete().
+ *
+ *  @note NULL will also be returned if an out of memory error occurs.
+ */
+struct sb_stemmer * sb_stemmer_new(const char * algorithm, const char * charenc);
+
+/** Delete a stemmer object.
+ *
+ *  This frees all resources allocated for the stemmer.  After calling
+ *  this function, the supplied stemmer may no longer be used in any way.
+ *
+ *  It is safe to pass a null pointer to this function - this will have
+ *  no effect.
+ */
+void                sb_stemmer_delete(struct sb_stemmer * stemmer);
+
+/** Stem a word.
+ *
+ *  The return value is owned by the stemmer - it must not be freed or
+ *  modified, and it will become invalid when the stemmer is called again,
+ *  or if the stemmer is freed.
+ *
+ *  The length of the return value can be obtained using sb_stemmer_length().
+ *
+ *  If an out-of-memory error occurs, this will return NULL.
+ */
+const sb_symbol *   sb_stemmer_stem(struct sb_stemmer * stemmer,
+				    const sb_symbol * word, int size);
+
+/** Get the length of the result of the last stemmed word.
+ *  This should not be called before sb_stemmer_stem() has been called.
+ */
+int                 sb_stemmer_length(struct sb_stemmer * stemmer);
+
+#ifdef __cplusplus
+}
+#endif
+

data/ext/mempool.c

@@ -0,0 +1,87 @@
+#include "global.h"
+#include "mempool.h"
+#include <string.h>
+
+MemoryPool *mp_new_capa(int chuck_size, int init_buf_capa)
+{
+    MemoryPool *mp = ALLOC(MemoryPool);
+    mp->chunk_size = chuck_size;
+    mp->buf_capa = init_buf_capa;
+    mp->buffers = ALLOC_N(char *, init_buf_capa);
+
+    mp->buffers[0] = mp->curr_buffer = emalloc(mp->chunk_size);
+    mp->buf_alloc = 1;
+    mp->buf_pointer = 0;
+    mp->pointer = 0;
+    return mp;
+}
+
+MemoryPool *mp_new()
+{
+    return mp_new_capa(MP_BUF_SIZE, MP_INIT_CAPA);
+}
+
+INLINE void *mp_alloc(MemoryPool *mp, int size)
+{
+    char *p;
+    p = mp->curr_buffer + mp->pointer;
+#if defined POSH_OS_SOLARIS || defined POSH_OS_SUNOS
+    size = (((size - 1) >> 3) + 1) << 3;
+#endif
+    mp->pointer += size;
+
+    if (mp->pointer > mp->chunk_size) {
+        mp->buf_pointer++;
+        if (mp->buf_pointer >= mp->buf_alloc) {
+            mp->buf_alloc++;
+            if (mp->buf_alloc >= mp->buf_capa) {
+                mp->buf_capa <<= 1;
+                REALLOC_N(mp->buffers, char *, mp->buf_capa);
+            }
+            mp->buffers[mp->buf_pointer] = emalloc(mp->chunk_size);
+        }
+        p = mp->curr_buffer = mp->buffers[mp->buf_pointer];
+        mp->pointer = size;
+    }
+    return p;
+}
+
+char *mp_strdup(MemoryPool *mp, const char *str)
+{
+    int len = strlen(str) + 1;
+    return memcpy(mp_alloc(mp, len), str, len);
+}
+
+char *mp_strndup(MemoryPool *mp, const char *str, int len)
+{
+    char *s = memcpy(mp_alloc(mp, len + 1), str, len);
+    s[len] = '\0';
+    return s;
+}
+
+void *mp_memdup(MemoryPool *mp, const void *p, int len)
+{
+    return memcpy(mp_alloc(mp, len), p, len);
+}
+
+int mp_used(MemoryPool *mp)
+{
+    return mp->buf_pointer * mp->chunk_size + mp->pointer;
+}
+
+void mp_reset(MemoryPool *mp)
+{
+    mp->buf_pointer = 0;
+    mp->pointer = 0;
+    mp->curr_buffer = mp->buffers[0];
+}
+
+void mp_destroy(MemoryPool *mp)
+{
+    int i;
+    for (i = 0; i < mp->buf_alloc; i++) {
+        free(mp->buffers[i]);
+    }
+    free(mp->buffers);
+    free(mp);
+}

data/ext/mempool.h

@@ -0,0 +1,35 @@
+#ifndef FRT_MEM_POOL_H
+#define FRT_MEM_POOL_H
+
+#define MP_BUF_SIZE 65536
+#define MP_INIT_CAPA 4
+
+typedef struct MemoryPool {
+    int buf_alloc;
+    int buf_capa;
+    int buf_pointer;
+    int pointer;
+    int chunk_size;
+    char *curr_buffer;
+    char **buffers;
+} MemoryPool;
+
+extern MemoryPool *mp_new();
+extern MemoryPool *mp_new_capa(int chunk_size, int init_capa);
+extern INLINE void *mp_alloc(MemoryPool *mp, int size);
+extern void mp_reset(MemoryPool *mp);
+extern void mp_destroy(MemoryPool *mp);
+extern char *mp_strdup(MemoryPool *mp, const char *str);
+extern char *mp_strndup(MemoryPool *mp, const char *str, int len);
+extern void *mp_memdup(MemoryPool *mp, const void *p, int len);
+extern int mp_used(MemoryPool *mp);
+
+#define MP_ALLOC_N(mp,type,n) (type *)mp_alloc(mp, sizeof(type)*(n))
+#define MP_ALLOC(mp,type) (type *)mp_alloc(mp, sizeof(type))
+
+#define MP_ALLOC_AND_ZERO(mp,type)\
+    (type*)memset(mp_alloc(mp, sizeof(type)), 0, sizeof(type))
+#define MP_ALLOC_AND_ZERO_N(mp,type,n)\
+    (type*)ZEROSET_N(mp_alloc(mp, sizeof(type)*(n)), type, n)
+
+#endif

data/ext/modules.h

@@ -0,0 +1,162 @@
+/* libstemmer/modules.h: List of stemming modules.
+ *
+ * This file is generated by mkmodules.pl from a list of module names.
+ * Do not edit manually.
+ *
+ * Modules included by this file are: danish, dutch, english, finnish, french,
+ * german, italian, norwegian, porter, portuguese, russian, spanish, swedish
+ */
+
+#include "stem_ISO_8859_1_danish.h"
+#include "stem_UTF_8_danish.h"
+#include "stem_ISO_8859_1_dutch.h"
+#include "stem_UTF_8_dutch.h"
+#include "stem_ISO_8859_1_english.h"
+#include "stem_UTF_8_english.h"
+#include "stem_ISO_8859_1_finnish.h"
+#include "stem_UTF_8_finnish.h"
+#include "stem_ISO_8859_1_french.h"
+#include "stem_UTF_8_french.h"
+#include "stem_ISO_8859_1_german.h"
+#include "stem_UTF_8_german.h"
+#include "stem_ISO_8859_1_italian.h"
+#include "stem_UTF_8_italian.h"
+#include "stem_ISO_8859_1_norwegian.h"
+#include "stem_UTF_8_norwegian.h"
+#include "stem_ISO_8859_1_porter.h"
+#include "stem_UTF_8_porter.h"
+#include "stem_ISO_8859_1_portuguese.h"
+#include "stem_UTF_8_portuguese.h"
+#include "stem_KOI8_R_russian.h"
+#include "stem_UTF_8_russian.h"
+#include "stem_ISO_8859_1_spanish.h"
+#include "stem_UTF_8_spanish.h"
+#include "stem_ISO_8859_1_swedish.h"
+#include "stem_UTF_8_swedish.h"
+
+typedef enum {
+  ENC_UNKNOWN,
+  ENC_ISO_8859_1,
+  ENC_KOI8_R,
+  ENC_UTF_8
+} stemmer_encoding;
+
+struct stemmer_encoding {
+  const char * name;
+  stemmer_encoding enc;
+};
+static struct stemmer_encoding encodings[] = {
+  {"ISO_8859_1", ENC_ISO_8859_1},
+  {"KOI8_R", ENC_KOI8_R},
+  {"UTF_8", ENC_UTF_8},
+  {0,0}
+};
+
+struct stemmer_modules {
+  const char * name;
+  stemmer_encoding enc; 
+  struct SN_env * (*create)(void);
+  void (*close)(struct SN_env *);
+  int (*stem)(struct SN_env *);
+};
+static struct stemmer_modules modules[] = {
+  {"da", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"da", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"dan", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"dan", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"danish", ENC_ISO_8859_1, danish_ISO_8859_1_create_env, danish_ISO_8859_1_close_env, danish_ISO_8859_1_stem},
+  {"danish", ENC_UTF_8, danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem},
+  {"de", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"de", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"deu", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"deu", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"dut", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"dut", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"dutch", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"dutch", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"en", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"en", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"eng", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"eng", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"english", ENC_ISO_8859_1, english_ISO_8859_1_create_env, english_ISO_8859_1_close_env, english_ISO_8859_1_stem},
+  {"english", ENC_UTF_8, english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem},
+  {"es", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"es", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"esl", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"esl", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"fi", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"fi", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"fin", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"fin", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"finnish", ENC_ISO_8859_1, finnish_ISO_8859_1_create_env, finnish_ISO_8859_1_close_env, finnish_ISO_8859_1_stem},
+  {"finnish", ENC_UTF_8, finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem},
+  {"fr", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fr", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"fra", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fra", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"fre", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"fre", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"french", ENC_ISO_8859_1, french_ISO_8859_1_create_env, french_ISO_8859_1_close_env, french_ISO_8859_1_stem},
+  {"french", ENC_UTF_8, french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem},
+  {"ger", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"ger", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"german", ENC_ISO_8859_1, german_ISO_8859_1_create_env, german_ISO_8859_1_close_env, german_ISO_8859_1_stem},
+  {"german", ENC_UTF_8, german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem},
+  {"it", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"it", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"ita", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"ita", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"italian", ENC_ISO_8859_1, italian_ISO_8859_1_create_env, italian_ISO_8859_1_close_env, italian_ISO_8859_1_stem},
+  {"italian", ENC_UTF_8, italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem},
+  {"nl", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"nl", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"nld", ENC_ISO_8859_1, dutch_ISO_8859_1_create_env, dutch_ISO_8859_1_close_env, dutch_ISO_8859_1_stem},
+  {"nld", ENC_UTF_8, dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem},
+  {"no", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"no", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"nor", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"nor", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"norwegian", ENC_ISO_8859_1, norwegian_ISO_8859_1_create_env, norwegian_ISO_8859_1_close_env, norwegian_ISO_8859_1_stem},
+  {"norwegian", ENC_UTF_8, norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem},
+  {"por", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"por", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"porter", ENC_ISO_8859_1, porter_ISO_8859_1_create_env, porter_ISO_8859_1_close_env, porter_ISO_8859_1_stem},
+  {"porter", ENC_UTF_8, porter_UTF_8_create_env, porter_UTF_8_close_env, porter_UTF_8_stem},
+  {"portuguese", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"portuguese", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"pt", ENC_ISO_8859_1, portuguese_ISO_8859_1_create_env, portuguese_ISO_8859_1_close_env, portuguese_ISO_8859_1_stem},
+  {"pt", ENC_UTF_8, portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem},
+  {"ru", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"ru", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"rus", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"rus", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"russian", ENC_KOI8_R, russian_KOI8_R_create_env, russian_KOI8_R_close_env, russian_KOI8_R_stem},
+  {"russian", ENC_UTF_8, russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem},
+  {"spa", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"spa", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"spanish", ENC_ISO_8859_1, spanish_ISO_8859_1_create_env, spanish_ISO_8859_1_close_env, spanish_ISO_8859_1_stem},
+  {"spanish", ENC_UTF_8, spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem},
+  {"sv", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"sv", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {"swe", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"swe", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {"swedish", ENC_ISO_8859_1, swedish_ISO_8859_1_create_env, swedish_ISO_8859_1_close_env, swedish_ISO_8859_1_stem},
+  {"swedish", ENC_UTF_8, swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem},
+  {0,0,0,0,0}
+};
+static const char * algorithm_names[] = {
+  "danish", 
+  "dutch", 
+  "english", 
+  "finnish", 
+  "french", 
+  "german", 
+  "italian", 
+  "norwegian", 
+  "porter", 
+  "portuguese", 
+  "russian", 
+  "spanish", 
+  "swedish", 
+  0
+};