middlemac 2.0.0 → 3.1.2

data/ext/trie/darray.h

@@ -0,0 +1,233 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * darray.h - Double-array trie structure
+ * Created: 2006-08-11
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#ifndef __DARRAY_H
+#define __DARRAY_H
+
+#include "triedefs.h"
+
+/**
+ * @file darray.h
+ * @brief Double-array trie structure
+ */
+
+/**
+ * @brief Double-array structure type
+ */
+typedef struct _DArray  DArray;
+
+/**
+ * @brief Double-array entry enumeration function
+ *
+ * @param key       : the key of the entry, up to @a sep_node
+ * @param sep_node  : the separate node of the entry
+ * @param user_data : user-supplied data
+ *
+ * @return TRUE to continue enumeration, FALSE to stop
+ */
+typedef Bool (*DAEnumFunc) (const TrieChar   *key,
+                            TrieIndex         sep_node,
+                            void             *user_data);
+
+
+/**
+ * @brief Create a new double-array object
+ *
+ * Create a new empty doubla-array object.
+ */
+DArray * da_new ();
+
+/**
+ * @brief Read double-array data from file
+ *
+ * @param file : the file to read
+ *
+ * @return a pointer to the openned double-array, NULL on failure
+ *
+ * Read double-array data from the opened file, starting from the current
+ * file pointer until the end of double array data block. On return, the
+ * file pointer is left at the position after the read block.
+ */
+DArray * da_read (FILE *file);
+
+/**
+ * @brief Free double-array data
+ *
+ * @param d : the double-array data
+ *
+ * Free the given double-array data.
+ */
+void     da_free (DArray *d);
+
+/**
+ * @brief Write double-array data
+ *
+ * @param d     : the double-array data
+ * @param file  : the file to write to
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * Write double-array data to the given @a file, starting from the current
+ * file pointer. On return, the file pointer is left after the double-array
+ * data block.
+ */
+int      da_write (const DArray *d, FILE *file);
+
+
+/**
+ * @brief Get root state
+ *
+ * @param d     : the double-array data
+ *
+ * @return root state of the @a index set, or TRIE_INDEX_ERROR on failure
+ *
+ * Get root state for stepwise walking.
+ */
+TrieIndex  da_get_root (const DArray *d);
+
+
+/**
+ * @brief Get BASE cell
+ *
+ * @param d : the double-array data
+ * @param s : the double-array state to get data
+ *
+ * @return the BASE cell value for the given state
+ *
+ * Get BASE cell value for the given state.
+ */
+TrieIndex  da_get_base (const DArray *d, TrieIndex s);
+
+/**
+ * @brief Get CHECK cell
+ *
+ * @param d : the double-array data
+ * @param s : the double-array state to get data
+ *
+ * @return the CHECK cell value for the given state
+ *
+ * Get CHECK cell value for the given state.
+ */
+TrieIndex  da_get_check (const DArray *d, TrieIndex s);
+
+
+/**
+ * @brief Set BASE cell
+ *
+ * @param d   : the double-array data
+ * @param s   : the double-array state to get data
+ * @param val : the value to set
+ *
+ * Set BASE cell for the given state to the given value.
+ */
+void       da_set_base (DArray *d, TrieIndex s, TrieIndex val);
+
+/**
+ * @brief Set CHECK cell
+ *
+ * @param d   : the double-array data
+ * @param s   : the double-array state to get data
+ * @param val : the value to set
+ *
+ * Set CHECK cell for the given state to the given value.
+ */
+void       da_set_check (DArray *d, TrieIndex s, TrieIndex val);
+
+/**
+ * @brief Walk in double-array structure
+ *
+ * @param d : the double-array structure
+ * @param s : current state
+ * @param c : the input character
+ *
+ * @return boolean indicating success
+ *
+ * Walk the double-array trie from state @a *s, using input character @a c.
+ * If there exists an edge from @a *s with arc labeled @a c, this function
+ * returns TRUE and @a *s is updated to the new state. Otherwise, it returns
+ * FALSE and @a *s is left unchanged.
+ */
+Bool       da_walk (const DArray *d, TrieIndex *s, TrieChar c);
+
+/**
+ * @brief Test walkability in double-array structure
+ *
+ * @param d : the double-array structure
+ * @param s : current state
+ * @param c : the input character
+ *
+ * @return boolean indicating walkability
+ *
+ * Test if there is a transition from state @a s with input character @a c.
+ */
+/*
+Bool       da_is_walkable (DArray *d, TrieIndex s, TrieChar c);
+*/
+#define    da_is_walkable(d,s,c) \
+    (da_get_check ((d), da_get_base ((d), (s)) + (c)) == (s))
+
+/**
+ * @brief Insert a branch from trie node
+ *
+ * @param d : the double-array structure
+ * @param s : the state to add branch to
+ * @param c : the character for the branch label
+ *
+ * @return the index of the new node
+ *
+ * Insert a new arc labelled with character @a c from the trie node 
+ * represented by index @a s in double-array structure @a d.
+ * Note that it assumes that no such arc exists before inserting.
+ */
+TrieIndex  da_insert_branch (DArray *d, TrieIndex s, TrieChar c);
+
+/**
+ * @brief Prune the single branch
+ *
+ * @param d : the double-array structure
+ * @param s : the dangling state to prune off
+ *
+ * Prune off a non-separate path up from the final state @a s.
+ * If @a s still has some children states, it does nothing. Otherwise, 
+ * it deletes the node and all its parents which become non-separate.
+ */
+void       da_prune (DArray *d, TrieIndex s);
+
+/**
+ * @brief Prune the single branch up to given parent
+ *
+ * @param d : the double-array structure
+ * @param p : the parent up to which to be pruned
+ * @param s : the dangling state to prune off
+ *
+ * Prune off a non-separate path up from the final state @a s to the
+ * given parent @a p. The prunning stop when either the parent @a p
+ * is met, or a first non-separate node is found.
+ */
+void       da_prune_upto (DArray *d, TrieIndex p, TrieIndex s);
+
+/**
+ * @brief Enumerate entries stored in double-array structure
+ *
+ * @param d          : the double-array structure
+ * @param enum_func  : the callback function to be called on each separate node
+ * @param user_data  : user-supplied data to send as an argument to @a enum_func
+ *
+ * @return boolean value indicating whether all the keys are visited
+ *
+ * Enumerate all keys stored in double-array structure. For each entry, the 
+ * user-supplied @a enum_func callback function is called, with the entry key,
+ * the separate node, and user-supplied data. Returning FALSE from such
+ * callback will stop enumeration and return FALSE.
+ */
+Bool    da_enumerate (const DArray *d, DAEnumFunc enum_func, void *user_data);
+
+#endif  /* __DARRAY_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/trie/extconf.rb

@@ -0,0 +1,23 @@
+require 'mkmf'
+
+##
+## Avoid warnings, since newer versions of Xcode by default try to make more and more
+## warnings.
+##
+append_cflags("-Wno-missing-noreturn")
+append_cflags("-Wno-shorten-64-to-32")
+append_cflags("-Wno-return-type")
+append_cflags("-Wno-sign-compare")
+append_cflags("-Wno-unused-function")
+append_cflags("-Wno-incompatible-pointer-types")
+puts "=-=-=-=-=-=-"
+puts $CFLAGS
+puts "=-=-=-=-=-=-"
+
+
+##
+## If we want it to be installed in lib/trie, then we have to create the makefile
+## in this nested format, too, otherwise lib_dir works for rake compile, but not
+## for rake install.
+##
+create_makefile 'trie/trie'

data/ext/trie/fileutils.c

@@ -0,0 +1,151 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * fileutils.h - File utility functions
+ * Created: 2006-08-15
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "fileutils.h"
+
+/*--------------------------------------*
+ *    INTERNAL FUNCTIONS DECLARATIONS   *
+ *--------------------------------------*/
+
+static char *   make_full_path (const char *dir,
+                                const char *name,
+                                const char *ext);
+
+/* ==================== BEGIN IMPLEMENTATION PART ====================  */
+
+/*--------------------------------*
+ *    FUNCTIONS IMPLEMENTATIONS   *
+ *--------------------------------*/
+
+static char *
+make_full_path (const char *dir, const char *name, const char *ext)
+{
+    char   *path;
+
+    path = (char *) malloc (strlen (dir) + strlen (name) + strlen (ext) + 2);
+    sprintf (path, "%s/%s%s", dir, name, ext);
+
+    return path;
+}
+
+FILE *
+file_open (const char *dir, const char *name, const char *ext, TrieIOMode mode)
+{
+    const char *std_mode;
+    char       *full_path;
+    FILE       *file;
+
+    if (mode & TRIE_IO_WRITE)
+        std_mode = "r+";
+    else
+        std_mode = "r";
+
+    full_path = make_full_path (dir, name, ext);
+    file = fopen (full_path, std_mode);
+    if (!file && mode & TRIE_IO_CREATE)
+        file = fopen (full_path, "w+");
+    free (full_path);
+
+    return file;
+}
+
+long
+file_length (FILE *file)
+{
+    long    cur_pos;
+    long    size;
+
+    cur_pos = ftell (file);
+
+    fseek (file, 0L, SEEK_END);
+    size = ftell (file);
+
+    fseek (file, cur_pos, SEEK_SET);
+
+    return size;
+}
+
+Bool
+file_read_int32 (FILE *file, int32 *o_val)
+{
+    unsigned char   buff[4];
+
+    if (fread (buff, 4, 1, file) == 1) {
+        *o_val = (buff[0] << 24) | (buff[1] << 16) |  (buff[2] << 8) | buff[3];
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+Bool
+file_write_int32 (FILE *file, int32 val)
+{
+    unsigned char   buff[4];
+
+    buff[0] = (val >> 24) & 0xff;
+    buff[1] = (val >> 16) & 0xff;
+    buff[2] = (val >> 8) & 0xff;
+    buff[3] = val & 0xff;
+
+    return (fwrite (buff, 4, 1, file) == 1);
+}
+
+Bool
+file_read_int16 (FILE *file, int16 *o_val)
+{
+    unsigned char   buff[2];
+
+    if (fread (buff, 2, 1, file) == 1) {
+        *o_val = (buff[0] << 8) | buff[1];
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+Bool
+file_write_int16 (FILE *file, int16 val)
+{
+    unsigned char   buff[2];
+
+    buff[0] = val >> 8;
+    buff[1] = val & 0xff;
+
+    return (fwrite (buff, 2, 1, file) == 1);
+}
+
+Bool
+file_read_int8 (FILE *file, int8 *o_val)
+{
+    return (fread (o_val, sizeof (int8), 1, file) == 1);
+}
+
+Bool
+file_write_int8 (FILE *file, int8 val)
+{
+    return (fwrite (&val, sizeof (int8), 1, file) == 1);
+}
+
+Bool
+file_read_chars (FILE *file, char *buff, int len)
+{
+    return (fread (buff, sizeof (char), len, file) == len);
+}
+
+Bool
+file_write_chars (FILE *file, const char *buff, int len)
+{
+    return (fwrite (buff, sizeof (char), len, file) == len);
+}
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/trie/fileutils.h

@@ -0,0 +1,36 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * fileutils.h - File utility functions
+ * Created: 2006-08-14
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#ifndef __FILEUTILS_H
+#define __FILEUTILS_H
+
+#include <stdio.h>
+
+#include "triedefs.h"
+
+FILE * file_open (const char *dir, const char *name, const char *ext,
+                  TrieIOMode mode);
+
+long   file_length (FILE *file);
+
+Bool   file_read_int32 (FILE *file, int32 *o_val);
+Bool   file_write_int32 (FILE *file, int32 val);
+
+Bool   file_read_int16 (FILE *file, int16 *o_val);
+Bool   file_write_int16 (FILE *file, int16 val);
+
+Bool   file_read_int8 (FILE *file, int8 *o_val);
+Bool   file_write_int8 (FILE *file, int8 val);
+
+Bool   file_read_chars (FILE *file, char *buff, int len);
+Bool   file_write_chars (FILE *file, const char *buff, int len);
+
+#endif /* __FILEUTILS_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/trie/tail.c

@@ -0,0 +1,340 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * tail.c - trie tail for keeping suffixes
+ * Created: 2006-08-15
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "tail.h"
+#include "fileutils.h"
+
+/*----------------------------------*
+ *    INTERNAL TYPES DECLARATIONS   *
+ *----------------------------------*/
+
+/*-----------------------------------*
+ *    PRIVATE METHODS DECLARATIONS   *
+ *-----------------------------------*/
+
+static TrieIndex    tail_alloc_block (Tail *t);
+static void         tail_free_block (Tail *t, TrieIndex block);
+
+/* ==================== BEGIN IMPLEMENTATION PART ====================  */
+
+/*------------------------------------*
+ *   INTERNAL TYPES IMPLEMENTATIONS   *
+ *------------------------------------*/
+
+/*------------------------------*
+ *    PRIVATE DATA DEFINITONS   *
+ *------------------------------*/
+
+typedef struct {
+    TrieIndex   next_free;
+    TrieData    data;
+    TrieChar   *suffix;
+} TailBlock;
+
+struct _Tail {
+    TrieIndex   num_tails;
+    TailBlock  *tails;
+    TrieIndex   first_free;
+};
+
+/*-----------------------------*
+ *    METHODS IMPLEMENTAIONS   *
+ *-----------------------------*/
+
+#define TAIL_SIGNATURE      0xDFFCDFFC
+#define TAIL_START_BLOCKNO  1
+
+/* Tail Header:
+ * INT32: signature
+ * INT32: pointer to first free slot
+ * INT32: number of tail blocks
+ *
+ * Tail Blocks:
+ * INT32: pointer to next free block (-1 for allocated blocks)
+ * INT32: data for the key
+ * INT16: length
+ * BYTES[length]: suffix string (no terminating '\0')
+ */
+
+Tail *
+tail_new ()
+{
+    Tail       *t;
+
+    t = (Tail *) malloc (sizeof (Tail));
+    if (!t)
+        return NULL;
+
+    t->first_free = 0;
+    t->num_tails  = 0;
+    t->tails      = NULL;
+
+    return t;
+}
+
+Tail *
+tail_read (FILE *file)
+{
+    long        save_pos;
+    Tail       *t;
+    TrieIndex   i;
+    uint32      sig;
+
+    /* check signature */
+    save_pos = ftell (file);
+    if (!file_read_int32 (file, (int32 *) &sig) || TAIL_SIGNATURE != sig) {
+        fseek (file, save_pos, SEEK_SET);
+        return NULL;
+    }
+
+    t = (Tail *) malloc (sizeof (Tail));
+    if (!t)
+        return NULL;
+
+    file_read_int32 (file, &t->first_free);
+    file_read_int32 (file, &t->num_tails);
+    t->tails = (TailBlock *) malloc (t->num_tails * sizeof (TailBlock));
+    if (!t->tails)
+        goto exit_tail_created;
+    for (i = 0; i < t->num_tails; i++) {
+        int16   length;
+
+        file_read_int32 (file, &t->tails[i].next_free);
+        file_read_int32 (file, &t->tails[i].data);
+
+        file_read_int16 (file, &length);
+        t->tails[i].suffix    = (TrieChar *) malloc (length + 1);
+        if (length > 0)
+            file_read_chars (file, (char *)t->tails[i].suffix, length);
+        t->tails[i].suffix[length] = '\0';
+    }
+
+    return t;
+
+exit_tail_created:
+    free (t);
+    return NULL;
+}
+
+void
+tail_free (Tail *t)
+{
+    TrieIndex   i;
+
+    if (t->tails) {
+        for (i = 0; i < t->num_tails; i++)
+            if (t->tails[i].suffix)
+                free (t->tails[i].suffix);
+        free (t->tails);
+    }
+    free (t);
+}
+
+int
+tail_write (const Tail *t, FILE *file)
+{
+    TrieIndex   i;
+
+    if (!file_write_int32 (file, TAIL_SIGNATURE) ||
+        !file_write_int32 (file, t->first_free)  ||
+        !file_write_int32 (file, t->num_tails))
+    {
+        return -1;
+    }
+    for (i = 0; i < t->num_tails; i++) {
+        int16   length;
+
+        if (!file_write_int32 (file, t->tails[i].next_free) ||
+            !file_write_int32 (file, t->tails[i].data))
+        {
+            return -1;
+        }
+
+        length = t->tails[i].suffix ? strlen ((const char *)t->tails[i].suffix)
+                                    : 0;
+        if (!file_write_int16 (file, length))
+            return -1;
+        if (length > 0 &&
+            !file_write_chars (file, (char *)t->tails[i].suffix, length))
+        {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+const TrieChar *
+tail_get_suffix (const Tail *t, TrieIndex index)
+{
+    index -= TAIL_START_BLOCKNO;
+    return (index < t->num_tails) ? t->tails[index].suffix : NULL;
+}
+
+Bool
+tail_set_suffix (Tail *t, TrieIndex index, const TrieChar *suffix)
+{
+    index -= TAIL_START_BLOCKNO;
+    if (index < t->num_tails) {
+        /* suffix and t->tails[index].suffix may overlap;
+         * so, dup it before it's overwritten
+         */
+        TrieChar *tmp = NULL;
+        if (suffix)
+            tmp = (TrieChar *) strdup ((const char *)suffix);
+        if (t->tails[index].suffix)
+            free (t->tails[index].suffix);
+        t->tails[index].suffix = tmp;
+
+        return TRUE;
+    }
+    return FALSE;
+}
+
+TrieIndex
+tail_add_suffix (Tail *t, const TrieChar *suffix)
+{
+    TrieIndex   new_block;
+
+    new_block = tail_alloc_block (t);
+    tail_set_suffix (t, new_block, suffix);
+
+    return new_block;
+}
+
+static TrieIndex
+tail_alloc_block (Tail *t)
+{
+    TrieIndex   block;
+
+    if (0 != t->first_free) {
+        block = t->first_free;
+        t->first_free = t->tails[block].next_free;
+    } else {
+        block = t->num_tails;
+        t->tails = (TailBlock *) realloc (t->tails,
+                                          ++t->num_tails * sizeof (TailBlock));
+    }
+    t->tails[block].next_free = -1;
+    t->tails[block].data = TRIE_DATA_ERROR;
+    t->tails[block].suffix = NULL;
+    
+    return block + TAIL_START_BLOCKNO;
+}
+
+static void
+tail_free_block (Tail *t, TrieIndex block)
+{
+    TrieIndex   i, j;
+
+    block -= TAIL_START_BLOCKNO;
+
+    if (block >= t->num_tails)
+        return;
+
+    t->tails[block].data = TRIE_DATA_ERROR;
+    if (NULL != t->tails[block].suffix) {
+        free (t->tails[block].suffix);
+        t->tails[block].suffix = NULL;
+    }
+
+    /* find insertion point */
+    j = 0;
+    for (i = t->first_free; i != 0 && i < block; i = t->tails[i].next_free)
+        j = i;
+
+    /* insert free block between j and i */
+    t->tails[block].next_free = i;
+    if (0 != j)
+        t->tails[j].next_free = block;
+    else
+        t->first_free = block;
+}
+
+TrieData
+tail_get_data (const Tail *t, TrieIndex index)
+{
+    index -= TAIL_START_BLOCKNO;
+    return (index < t->num_tails) ? t->tails[index].data : TRIE_DATA_ERROR;
+}
+
+Bool
+tail_set_data (Tail *t, TrieIndex index, TrieData data)
+{
+    index -= TAIL_START_BLOCKNO;
+    if (index < t->num_tails) {
+        t->tails[index].data = data;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void
+tail_delete (Tail *t, TrieIndex index)
+{
+    tail_free_block (t, index);
+}
+
+int
+tail_walk_str  (const Tail      *t,
+                TrieIndex        s,
+                short           *suffix_idx,
+                const TrieChar  *str,
+                int              len)
+{
+    const TrieChar *suffix;
+    int             i;
+    short           j;
+
+    suffix = tail_get_suffix (t, s);
+    if (!suffix)
+        return FALSE;
+
+    i = 0; j = *suffix_idx;
+    while (i < len) {
+        if (str[i] != suffix[j])
+            break;
+        ++i;
+        /* stop and stay at null-terminator */
+        if (0 == suffix[j])
+            break;
+        ++j;
+    }
+    *suffix_idx = j;
+    return i;
+}
+
+Bool
+tail_walk_char (const Tail      *t,
+                TrieIndex        s,
+                short           *suffix_idx,
+                TrieChar         c)
+{
+    const TrieChar *suffix;
+    TrieChar        suffix_char;
+
+    suffix = tail_get_suffix (t, s);
+    if (!suffix)
+        return FALSE;
+
+    suffix_char = suffix[*suffix_idx];
+    if (suffix_char == c) {
+        if (0 != suffix_char)
+            ++*suffix_idx;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+/*
+vi:ts=4:ai:expandtab
+*/