tyler-trie 0.1.0

data/ext/libdatrie/datrie/darray.h

@@ -0,0 +1,229 @@
+/* -*- 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 Open double-array from file
+ *
+ * @param path : the path that stores the double-array files
+ * @param name : the name of the double-array (not actual file name)
+ * @param mode : openning mode, read or write
+ *
+ * @return a pointer to the openned double-array, NULL on failure
+ *
+ * Open a double-array structure of given name. Note that @a name here does 
+ * not mean the actual file name. Rather, the file name will be inferred by 
+ * the name.
+ */
+DArray * da_open (const char *path, const char *name, TrieIOMode mode);
+
+/**
+ * @brief Close double-array data
+ *
+ * @param d : the double-array data
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * Close the given double-array data. If @a d was openned for writing, all 
+ * pending changes will be saved to file.
+ */
+int      da_close (DArray *d);
+
+/**
+ * @brief Save double-array data
+ *
+ * @param d : the double-array data
+ *
+ * @return 0 on success, non-zero on failure
+ *
+ * If @a double-array data was openned for writing, save all pending changes 
+ * to file.
+ */
+int      da_save (DArray *d);
+
+
+/**
+ * @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 (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 (DArray *d, DAEnumFunc enum_func, void *user_data);
+
+#endif  /* __DARRAY_H */
+
+/*
+vi:ts=4:ai:expandtab
+*/

data/ext/libdatrie/datrie/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/libdatrie/datrie/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/libdatrie/datrie/libdatrie.def

@@ -0,0 +1,31 @@
+sb_trie_open
+sb_trie_close
+sb_trie_save
+sb_trie_retrieve
+sb_trie_store
+sb_trie_delete
+sb_trie_enumerate
+sb_trie_root
+sb_trie_state_clone
+sb_trie_state_free
+sb_trie_state_rewind
+sb_trie_state_walk
+sb_trie_state_is_walkable
+sb_trie_state_is_terminal
+sb_trie_state_is_leaf
+sb_trie_state_get_data
+trie_open
+trie_close
+trie_save
+trie_retrieve
+trie_store
+trie_delete
+trie_enumerate
+trie_root
+trie_state_clone
+trie_state_free
+trie_state_rewind
+trie_state_walk
+trie_state_is_walkable
+trie_state_is_leaf
+trie_state_get_data