ferret 0.10.11 → 0.10.12

data/CHANGELOG

@@ -1,3 +1,16 @@
+
+Fri Oct 13 09:18:31 JST 2006
+  * Changed documentation to state truthfully that FULL_ENGLISH_STOP_WORDS is
+    being used by default in StandardAnalyzer and StopwordFilter.
+  * Removed 'will', 's' and 't' from ENGLISH_STOP_WORDS so that all words in
+    ENGLISH_STOP_WORDS can be found in FULL_ENGLISH_STOP_WORDS, that is
+    ENGLISH_STOP_WORDS is a subset of FULL_ENGLISH_STOP_WORDS.
+
+Thu Oct 12 23:04:19 JST 2006
+  * Fixed adding SortField to Sort object in Ruby. Garbage collection wasn't 
+    working.
+  * Can now set :sort => SortField#new
+
 Tue Oct 10 14:42:17 JST 2006
   * Fixed MultiTermDocEnum bug introduced in version 0.10.10 during
     performance enhancements. 

data/Rakefile

@@ -41,7 +41,7 @@ SRC = (FileList["ext/*.[ch]"] + EXT_SRC_DEST).uniq
 
 CLEAN.include(FileList['**/*.o', '**/*.obj', 'InstalledFiles',
                        '.config', 'ext/cferret.c'])
-CLOBBER.include(FileList['**/*.so'], 'ext/Makefile', EXT_SRC_DEST)
+CLOBBER.include(FileList['**/*.so'], 'ext/Makefile', 'ext/mem_pool.*', 'ext/defines.h', EXT_SRC_DEST)
 POLISH = Rake::FileList.new.include(FileList['**/*.so'], 'ext/Makefile')
 
 desc "Clean specifically for the release."

data/ext/analysis.c

@@ -1078,19 +1078,10 @@ static void sf_destroy_i(TokenStream *ts)
     filter_destroy_i(ts);
 }
 
-static void sf_clone_i_i(void *key, void *value, void *arg)
-{
-    HashTable *word_table = (HashTable *)arg;
-    char *word = estrdup(key);
-    (void)value;
-    h_set(word_table, word, word);
-}
-
 static TokenStream *sf_clone_i(TokenStream *orig_ts)
 {
-    TokenStream *new_ts = filter_clone_size(orig_ts, sizeof(StopFilter));
-    StopFilt(new_ts)->words = h_new_str(&free, NULL);
-    h_each(StopFilt(orig_ts)->words, &sf_clone_i_i, StopFilt(new_ts)->words);
+    TokenStream *new_ts = filter_clone_size(orig_ts, sizeof(MappingFilter));
+    REF(StopFilt(new_ts)->words);
     return new_ts;
 }
 
@@ -1157,6 +1148,66 @@ TokenStream *stop_filter_new(TokenStream *ts)
     return stop_filter_new_with_words(ts, FULL_ENGLISH_STOP_WORDS);
 }
 
+/****************************************************************************
+ * MappingFilter
+ ****************************************************************************/
+
+#define MFilt(filter) ((MappingFilter *)(filter))
+
+static void mf_destroy_i(TokenStream *ts)
+{
+    mulmap_destroy(MFilt(ts)->mapper);
+    filter_destroy_i(ts);
+}
+
+static TokenStream *mf_clone_i(TokenStream *orig_ts)
+{
+    TokenStream *new_ts = filter_clone_size(orig_ts, sizeof(MappingFilter));
+    REF(MFilt(new_ts)->mapper);
+    return new_ts;
+}
+
+static Token *mf_next(TokenStream *ts)
+{
+    char buf[MAX_WORD_SIZE];
+    MultiMapper *mapper = MFilt(ts)->mapper;
+    TokenFilter *tf = TkFilt(ts);
+    Token *tk = tf->sub_ts->next(tf->sub_ts);
+    if (tk != NULL) {
+        tk->len = mulmap_map_len(mapper, buf, tk->text, MAX_WORD_SIZE);
+        memcpy(tk->text, buf, tk->len + 1);
+    }
+    return tk;
+}
+
+static TokenStream *mf_reset(TokenStream *ts, char *text)
+{
+    MultiMapper *mm = MFilt(ts)->mapper;
+    if (mm->d_size == 0) {
+        mulmap_compile(MFilt(ts)->mapper);
+    }
+    filter_reset(ts, text);
+    return ts;
+}
+
+TokenStream *mapping_filter_new(TokenStream *sub_ts)
+{
+    TokenStream *ts   = tf_new(MappingFilter, sub_ts);
+    MFilt(ts)->mapper = mulmap_new();
+    ts->next          = &mf_next;
+    ts->destroy_i     = &mf_destroy_i;
+    ts->clone_i       = &mf_clone_i;
+    ts->reset         = &mf_reset;
+    return ts;
+}
+
+TokenStream *mapping_filter_add(TokenStream *ts, const char *pattern,
+                                const char *replacement)
+{
+    mulmap_add_mapping(MFilt(ts)->mapper, pattern, replacement);
+    return ts;
+}
+
 /****************************************************************************
  * HyphenFilter
  ****************************************************************************/

data/ext/analysis.h

@@ -3,6 +3,7 @@
 
 #include "global.h"
 #include "hash.h"
+#include "multimapper.h"
 #include <wchar.h>
 
 /****************************************************************************
@@ -89,6 +90,12 @@ typedef struct StopFilter
     HashTable  *words;
 } StopFilter;
 
+typedef struct MappingFilter 
+{
+    TokenFilter  super;
+    MultiMapper *mapper;
+} MappingFilter;
+
 typedef struct HyphenFilter 
 {
     TokenFilter super;
@@ -150,6 +157,10 @@ extern TokenStream *stop_filter_new(TokenStream *ts);
 extern TokenStream *stem_filter_new(TokenStream *ts, const char *algorithm,
                                     const char *charenc);
 
+extern TokenStream *mapping_filter_new(TokenStream *ts);
+extern TokenStream *mapping_filter_add(TokenStream *ts, const char *pattern,
+                                       const char *replacement);
+
 /****************************************************************************
  *
  * Analyzer

data/ext/bitvector.c

@@ -360,32 +360,53 @@ unsigned long bv_hash(BitVector *bv)
     return hash;
 }
 
+static __inline void bv_recapa(BitVector *bv, int new_capa)
+{
+    if (bv->capa < new_capa) {
+        REALLOC_N(bv->bits, f_u32, new_capa);
+        memset(bv->bits + bv->capa, (bv->extends_as_ones ? 0xFF : 0),
+               sizeof(f_u32) * (new_capa - bv->capa)); 
+        bv->capa = new_capa;
+    }
+}
+
 static BitVector *bv_and_i(BitVector *bv, BitVector *bv1, BitVector *bv2)
 {
     int i;
-    int min_size = min2(bv1->size, bv2->size);
-    int word_size = (min_size >> 5) + 1;
+    int size;
+    int word_size;
     int capa = 4;
-    while (capa < word_size) {
-        capa <<= 1;
-    }
-    REALLOC_N(bv->bits, f_u32, capa);
-    bv->capa = capa;
-    bv->size = min_size;
 
     if (bv1->extends_as_ones && bv2->extends_as_ones) {
+        size = max2(bv1->size, bv2->size);
         bv->extends_as_ones = true;
     }
+    else if (bv1->extends_as_ones || bv2->extends_as_ones) {
+        size = max2(bv1->size, bv2->size);
+        bv->extends_as_ones = false;
+    }
     else {
+        size = min2(bv1->size, bv2->size);
         bv->extends_as_ones = false;
     }
 
+    word_size = (size >> 5) + 1;
+    while (capa < word_size) {
+        capa <<= 1;
+    }
+    bv_recapa(bv1, capa);
+    bv_recapa(bv2, capa);
+    REALLOC_N(bv->bits, f_u32, capa);
+    bv->capa = capa;
+    bv->size = size;
+
     memset(bv->bits + word_size, (bv->extends_as_ones ? 0xFF : 0),
            sizeof(f_u32) * (capa - word_size)); 
 
     for (i = 0; i < word_size; i++) {
         bv->bits[i] = bv1->bits[i] & bv2->bits[i];
     }
+
     bv_recount(bv);
     return bv;
 }
@@ -400,16 +421,6 @@ BitVector *bv_and_x(BitVector *bv1, BitVector *bv2)
     return bv_and_i(bv1, bv1, bv2);
 }
 
-static __inline void bv_recapa(BitVector *bv, int new_capa)
-{
-    if (bv->capa < new_capa) {
-        REALLOC_N(bv->bits, f_u32, new_capa);
-        memset(bv->bits + bv->capa, (bv->extends_as_ones ? 0xFF : 0),
-               sizeof(f_u32) * (new_capa - bv->capa)); 
-        bv->capa = new_capa;
-    }
-}
-
 static BitVector *bv_or_i(BitVector *bv, BitVector *bv1, BitVector *bv2)
 {
     int i;

data/ext/except.h

@@ -63,7 +63,7 @@
 #define FRT_EXCEPT_H
 
 #include <setjmp.h>
-#include "defines.h"
+#include "config.h"
 
 #define BODY 0
 #define FINALLY 1

data/ext/extconf.rb

@@ -5,6 +5,7 @@ if (/mswin/ =~ RUBY_PLATFORM) and ENV['make'].nil?
   create_makefile("ferret_ext")
 else
   require 'mkmf'
-  $CFLAGS += " -fno-common"
+  #$CFLAGS += " -fno-common"
+  $CFLAGS += " -fno-common -D_FILE_OFFSET_BITS=64"
   create_makefile("ferret_ext")
 end

data/ext/fs_store.c

@@ -223,7 +223,8 @@ static off_t fs_length(Store *store, char *filename)
 static void fso_flush_i(OutStream *os, uchar *src, int len)
 {
     if (len != write(os->file.fd, src, len)) {
-        RAISE(IO_ERROR, "flushing src of length %d", len);
+        RAISE(IO_ERROR, "flushing src of length %d, <%s>", len,
+              strerror(errno));
     }
 }
 
@@ -268,7 +269,7 @@ static OutStream *fs_new_output(Store *store, const char *filename)
 static void fsi_read_i(InStream *is, uchar *path, int len)
 {
     int fd = is->file.fd;
-    int pos = is_pos(is);
+    off_t pos = is_pos(is);
     if (pos != lseek(fd, 0, SEEK_CUR)) {
         lseek(fd, pos, SEEK_SET);
     }
@@ -409,6 +410,7 @@ static HashTable stores = {
     /* fill */       0,
     /* used */       0,
     /* mask */       HASH_MINSIZE - 1,
+    /* ref_cnt */    1,
     /* table */      stores.smalltable,
     /* smalltable */ {{0, NULL, NULL}},
     /* lookup */     (h_lookup_ft)&h_lookup_str,

data/ext/global.h

@@ -1,7 +1,7 @@
 #ifndef FRT_GLOBAL_H
 #define FRT_GLOBAL_H
 
-#include "defines.h"
+#include "config.h"
 #include "except.h"
 #include "lang.h"
 #include <stdlib.h>

data/ext/hash.c

@@ -238,6 +238,7 @@ HashTable *h_new_str(free_ft free_key, free_ft free_value)
 
     ht->free_key_i = free_key != NULL ? free_key : &dummy_free;
     ht->free_value_i = free_value != NULL ? free_value : &dummy_free;
+    ht->ref_cnt = 1;
     return ht;
 }
 
@@ -285,23 +286,25 @@ void h_clear(HashTable *ht)
 
 void h_destroy(HashTable *ht)
 {
-    h_clear(ht);
+    if (--(ht->ref_cnt) <= 0) {
+        h_clear(ht);
 
-    /* if a new table was created, be sure to free it */
-    if (ht->table != ht->smalltable) {
-        free(ht->table);
-    }
+        /* if a new table was created, be sure to free it */
+        if (ht->table != ht->smalltable) {
+            free(ht->table);
+        }
 
 #ifdef DEBUG
-    free(ht);
-#else
-    if (num_free_hts < MAX_FREE_HASH_TABLES) {
-        free_hts[num_free_hts++] = ht;
-    }
-    else {
         free(ht);
-    }
+#else
+        if (num_free_hts < MAX_FREE_HASH_TABLES) {
+            free_hts[num_free_hts++] = ht;
+        }
+        else {
+            free(ht);
+        }
 #endif
+    }
 }
 
 void *h_get(HashTable *ht, const void *key)

data/ext/hash.h

@@ -46,6 +46,7 @@ typedef struct HashTable
     int fill;                   /* num Active + num Dummy */
     int size;                   /* num Active ie, num keys set */
     int mask;                   /* capacity_of_table - 1 */
+    int ref_cnt;
 
     /* table points to smalltable initially. If the table grows beyond 2/3 of
      * HASH_MINSIZE it will point to newly malloced memory as it grows. */

data/ext/helper.c

@@ -14,13 +14,13 @@ f_i32 float2int(float f)
 {
     union { f_i32 i; float f; } tmp;
     tmp.f = f;
-    return POSH_LittleU32(tmp.i);
+    return tmp.i;
 }
 
 float int2float(f_i32 i32)
 {
     union { f_i32 i; float f; } tmp;
-    tmp.i = POSH_LittleU32(i32);
+    tmp.i = i32;
     return tmp.f;
 }
 

data/ext/helper.h

@@ -1,7 +1,7 @@
 #ifndef FRT_HELPER_H
 #define FRT_HELPER_H
 
-#include "defines.h"
+#include "config.h"
 
 extern __inline int hlp_string_diff(register const char *const s1,
                                   register const char *const s2);

data/ext/index.c

@@ -5350,7 +5350,8 @@ void iw_close(IndexWriter *iw)
     free(iw);
 }
 
-IndexWriter *iw_open(Store *store, Analyzer *analyzer, const Config *config)
+IndexWriter *iw_open(Store *store, volatile Analyzer *analyzer,
+                     const Config *config)
 {
     IndexWriter *iw = ALLOC_AND_ZERO(IndexWriter);
     mutex_init(&iw->mutex, NULL);
@@ -5381,7 +5382,8 @@ IndexWriter *iw_open(Store *store, Analyzer *analyzer, const Config *config)
     XENDTRY
 
     iw->similarity = sim_create_default();
-    iw->analyzer = analyzer ? analyzer : mb_standard_analyzer_new(true);
+    iw->analyzer = analyzer ? (Analyzer *)analyzer
+                            : mb_standard_analyzer_new(true);
 
     REF(store);
     return iw;

data/ext/index.h

@@ -7,7 +7,7 @@
 #include "hash.h"
 #include "hashset.h"
 #include "store.h"
-#include "mem_pool.h"
+#include "mempool.h"
 #include "similarity.h"
 #include "bitvector.h"
 #include "priorityqueue.h"
@@ -874,7 +874,7 @@ struct IndexWriter
 };
 
 extern void index_create(Store *store, FieldInfos *fis);
-extern IndexWriter *iw_open(Store *store, Analyzer *analyzer,
+extern IndexWriter *iw_open(Store *store, volatile Analyzer *analyzer,
                             const Config *config);
 extern void iw_delete_term(IndexWriter *iw, const char *field,
                            const char *term);

data/ext/{mem_pool.c → mempool.c}

@@ -1,5 +1,5 @@
 #include "global.h"
-#include "mem_pool.h"
+#include "mempool.h"
 #include <string.h>
 
 MemoryPool *mp_new_capa(int chuck_size, int init_buf_capa)

data/ext/multimapper.c

@@ -0,0 +1,310 @@
+#include "multimapper.h"
+#include "array.h"
+#include "bitvector.h"
+#include <string.h>
+
+#define St(state) ((State *)(state))
+#define UCtoI(val) ((int)(unsigned char)(val))
+
+static void state_destroy(State *state)
+{
+    state->destroy_i(state);
+}
+
+typedef struct LetterState
+{
+    State super;
+    int c;
+    int val;
+    char *mapping;
+} LetterState;
+#define LSt(state) ((LetterState *)(state))
+
+
+static int lstate_next(LetterState *self, int c, int *states)
+{
+    if (c == self->c) {
+        states[0] = self->val;
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+static int lstate_is_match(LetterState *self, char **mapping)
+{
+    if (self->val < 0) {
+        *mapping = self->mapping;
+        return self->val;
+    }
+    else {
+        return 0;
+    }
+}
+
+static LetterState *lstate_new(int c, int val)
+{
+    LetterState *self   = ALLOC(LetterState);
+    self->c             = c;
+    self->val           = val;
+    self->mapping       = NULL;
+    St(self)->next      = (int (*)(State *, int, int *))&lstate_next;
+    St(self)->destroy_i = (void (*)(State *))&free;
+    St(self)->is_match  = (int (*)(State *, char **))&lstate_is_match;
+    return self;
+}
+
+typedef struct NonDeterministicState
+{
+    State super;
+    int *states[256];
+    int size[256];
+    int capa[256];
+} NonDeterministicState;
+
+static int ndstate_next(NonDeterministicState *self, int c, int *states)
+{
+    int size = self->size[c];
+    memcpy(states, self->states[c], size * sizeof(int));
+    return size;
+}
+
+static void ndstate_add(NonDeterministicState *self, int c, int state)
+{
+    if (self->capa[c] <= self->size[c]) {
+        if (self->capa[c] == 0) {
+            self->capa[c] = 4;
+        }
+        else {
+            self->capa[c] <<= 1;
+        }
+        REALLOC_N(self->states[c], int, self->capa[c]);
+    }
+    self->states[c][self->size[c]++] = state;
+}
+
+static void ndstate_destroy_i(NonDeterministicState *self)
+{
+    int i;
+    for (i = 0; i < 256; i++) {
+        free(self->states[i]);
+    }
+    free(self);
+}
+
+static int ndstate_is_match(State *self, char **mapping)
+{
+    (void)self; (void)mapping;
+    return 0;
+}
+
+static NonDeterministicState *ndstate_new()
+{
+    NonDeterministicState *self = ALLOC_AND_ZERO(NonDeterministicState);
+    St(self)->next              = (int (*)(State *, int, int *))&ndstate_next;
+    St(self)->destroy_i         = (void (*)(State *))&ndstate_destroy_i;
+    St(self)->is_match          = &ndstate_is_match;
+    return self;
+}
+
+MultiMapper *mulmap_new()
+{
+    MultiMapper *self = ALLOC_AND_ZERO(MultiMapper);
+    self->capa = 128;
+    self->mappings = ALLOC_N(Mapping *, 128);
+    self->d_capa = 128;
+    self->dstates = ALLOC_N(DeterministicState *, 128);
+    self->dstates_map = NULL;
+    self->nstates = NULL;
+    self->ref_cnt = 1;
+    return self;
+}
+
+static __inline void mulmap_free_dstates(MultiMapper *self)
+{
+    if (self->d_size > 0) {
+        int i;
+        for (i = self->d_size - 1; i >= 0; i--) {
+            free(self->dstates[i]);
+        }
+        self->d_size = 0;
+    }
+}
+
+void mulmap_add_mapping(MultiMapper *self, const char *pattern, const char *rep)
+{
+    if (pattern == NULL || pattern[0] == '\0') {
+        RAISE(ARG_ERROR, "Tried to add empty pattern to multi_mapper");
+    }
+    else {
+        Mapping *mapping = ALLOC(Mapping);
+        if (self->size >= self->capa) {
+            self->capa <<= 1;
+            REALLOC_N(self->mappings, Mapping *, self->capa);
+        }
+        mapping->pattern = estrdup(pattern);
+        mapping->replacement = estrdup(rep);
+        self->mappings[self->size++] = mapping;
+        mulmap_free_dstates(self);
+    }
+}
+
+
+static __inline void mulmap_bv_set_states(BitVector *bv, int *states, int cnt)
+{
+    int i;
+    for (i = cnt - 1; i >= 0; i--) {
+        bv_set(bv, states[i]);
+    }
+}
+
+static DeterministicState *mulmap_process_state(MultiMapper *self, BitVector *bv)
+{
+    DeterministicState *current_state = h_get(self->dstates_map, bv);
+    if (current_state == NULL) {
+        int bit, i;
+        int match_len = 0, max_match_len = 0;
+        State *start = self->nstates[0];
+        DeterministicState *start_ds;
+        current_state = ALLOC_AND_ZERO(DeterministicState);
+        h_set(self->dstates_map, bv, current_state);
+        if (self->d_size >= self->d_capa) {
+            self->d_capa <<= 1;
+            REALLOC_N(self->dstates, DeterministicState *, self->d_capa);
+        }
+        self->dstates[self->d_size++] = current_state;
+        start_ds = self->dstates[0];
+        for (i = 0; i <= 256; i++) {
+            current_state->next[i] = start_ds;
+        }
+        while ((bit = bv_scan_next(bv)) >= 0) {
+            char *mapping;
+            State *st = self->nstates[bit];
+            if ((match_len = -st->is_match(st, &mapping)) > max_match_len) {
+                current_state->longest_match = max_match_len = match_len;
+                current_state->mapping = mapping;
+                current_state->mapping_len = strlen(mapping);
+            }
+        }
+        for (i = self->a_size - 1; i >= 0; i--) {
+            unsigned char c = self->alphabet[i];
+            BitVector *nxt_bv = bv_new_capa(self->nsize);
+            mulmap_bv_set_states(nxt_bv, self->next_states,
+                                 start->next(start, (int)c, self->next_states));
+            bv_scan_reset(bv);
+            while ((bit = bv_scan_next(bv)) >= 0) {
+                State *state = self->nstates[bit];
+                mulmap_bv_set_states(nxt_bv, self->next_states,
+                                     state->next(state, (int)c, self->next_states));
+            }
+            current_state->next[(int)c] = mulmap_process_state(self, nxt_bv);
+        }
+    }
+    else {
+        bv_destroy(bv);
+    }
+    return current_state;
+}
+
+void mulmap_compile(MultiMapper *self)
+{
+    NonDeterministicState *start = ndstate_new();
+    int i, j;
+    int size = 1;
+    int capa = 128;
+    LetterState *ls;
+    State **nstates = ALLOC_N(State *, capa);
+    Mapping **mappings = self->mappings;
+    unsigned char alphabet[256];
+    nstates[0] = (State *)start;
+    memset(alphabet, 0, 256);
+
+    for (i = self->size - 1; i >= 0; i--) {
+        const char *pattern = mappings[i]->pattern;
+        const int plen = (int)strlen(pattern);
+        ndstate_add(start, UCtoI(pattern[0]), size);
+        if (size + plen + 1 >= capa) {
+            capa <<= 2;
+            REALLOC_N(nstates, State *, capa);
+        }
+        for (j = 0; j < plen; j++) {
+            alphabet[UCtoI(pattern[j])] = 1;
+            size += 1;
+            nstates[size-1] = (State *)lstate_new(UCtoI(pattern[j+1]), size);
+        }
+        ls = LSt(nstates[size-1]);
+        ls->mapping = mappings[i]->replacement;
+        ls->val = -plen;
+        ls->c = -1;
+    }
+    for (i = j = 0; i < 256; i++) {
+        if (alphabet[i]) self->alphabet[j++] = i;
+    }
+    self->a_size = j;
+    mulmap_free_dstates(self);
+    self->nstates = nstates;
+    self->nsize = size;
+    self->next_states = ALLOC_N(int, size);
+    self->dstates_map = h_new((hash_ft)&bv_hash, (eq_ft)&bv_eq,
+                              (free_ft)&bv_destroy, (free_ft)NULL);
+    mulmap_process_state(self, bv_new_capa(0));
+    h_destroy(self->dstates_map);
+    for (i = size - 1; i >= 0; i--) {
+        state_destroy(nstates[i]);
+    }
+    free(self->next_states);
+    free(nstates);
+}
+
+int mulmap_map_len(MultiMapper *self, char *to, char *from, int capa)
+{
+    DeterministicState *start = self->dstates[0];
+    DeterministicState *state = start;
+    char *s = from, *d = to, *end = to + capa - 1;
+    if (self->d_size == 0) {
+        RAISE(STATE_ERROR, "You forgot to compile your MultiMapper");
+    }
+    while (*s && d < end) {
+        state = state->next[UCtoI(*s)];
+        if (state->mapping) {
+            int len = state->mapping_len;
+            d -= (state->longest_match - 1);
+            if ((d + len) > end) {
+                len = end - d;
+            }
+            memcpy(d, state->mapping, len);
+            d += len;
+            state = start;
+        }
+        else {
+            *(d++) = *s;
+        }
+        s++;
+    }
+    *d = '\0';
+    return d - to;
+}
+
+char *mulmap_map(MultiMapper *self, char *to, char *from, int capa)
+{
+    mulmap_map_len(self, to, from, capa);
+    return to;
+}
+
+void mulmap_destroy(MultiMapper *self)
+{
+    if (--(self->ref_cnt) <= 0) {
+        int i;
+        mulmap_free_dstates(self);
+        for (i = self->size - 1; i >= 0; i--) {
+            Mapping *mapping = self->mappings[i];
+            free(mapping->pattern);
+            free(mapping->replacement);
+            free(mapping);
+        }
+        free(self->mappings);
+        free(self->dstates);
+        free(self);
+    }
+}