isomorfeus-ferret 0.12.0

data/ext/isomorfeus_ferret_ext/frt_lang.c

@@ -0,0 +1,104 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include "frt_lang.h"
+#include "frt_except.h"
+#include "frt_global.h"
+
+/* emalloc: malloc and report if error */
+void *frt_emalloc(size_t size)
+{
+    void *p = malloc(size);
+
+    if (p == NULL) {
+        FRT_RAISE(FRT_MEM_ERROR, "failed to allocate %d bytes", (int)size);
+    }
+
+    return p;
+}
+
+/* frt_ecalloc: malloc, zeroset and report if error */
+void *frt_ecalloc(size_t size)
+{
+    void *p = calloc(1, size);
+
+    if (p == NULL) {
+        FRT_RAISE(FRT_MEM_ERROR, "failed to allocate %d bytes", (int)size);
+    }
+
+    return p;
+}
+
+/* frt_erealloc: realloc and report if error */
+void *frt_erealloc(void *ptr, size_t size)
+{
+    void *p = realloc(ptr, size);
+
+    if (p == NULL) {
+        FRT_RAISE(FRT_MEM_ERROR, "failed to reallocate %d bytes", (int)size);
+    }
+
+    return p;
+}
+
+/* void micro_sleep(const int micro_seconds)
+{
+#if (defined POSH_OS_WIN32 || defined POSH_OS_WIN64) && !defined __MINGW32__
+    Sleep(micro_seconds / 1000);
+#else
+    usleep(micro_seconds);
+#endif
+} */
+
+/* xexit: print error message and exit */
+# ifdef FRT_HAS_VARARGS
+void frt_vexit(const char *file, int line_num, const char *func,
+                      const char *err_type, const char *fmt, va_list args)
+# else
+void FRT_VEXIT(const char *err_type, const char *fmt, va_list args)
+# endif
+{
+    fflush(stdout);
+    fprintf(EXCEPTION_STREAM, "\n%s: ", frt_progname());
+
+# ifdef FRT_HAS_VARARGS
+    fprintf(EXCEPTION_STREAM, "%s occurred at <%s>:%d in %s\n",
+            err_type, file, line_num, func);
+# else
+    fprintf(EXCEPTION_STREAM, "%s occurred:\n", err_type);
+# endif
+    vfprintf(EXCEPTION_STREAM, fmt, args);
+
+    if (fmt[0] != '\0' && fmt[strlen(fmt) - 1] == ':') {
+        fprintf(EXCEPTION_STREAM, " %s", strerror(errno));
+    }
+
+    fprintf(EXCEPTION_STREAM, "\n");
+    frt_print_stacktrace();
+    if (frt_x_abort_on_exception) {
+        exit(2);                 /* conventional value for failed execution */
+    }
+    else {
+        frt_x_has_aborted = true;
+    }
+}
+
+
+# ifdef FRT_HAS_VARARGS
+void frt_xexit(const char *file, int line_num, const char *func,
+              const char *err_type, const char *fmt, ...)
+# else
+void FRT_XEXIT(const char *err_type, const char *fmt, ...)
+# endif
+{
+    va_list args;
+    va_start(args, fmt);
+# ifdef FRT_HAS_VARARGS
+    frt_vexit(file, line_num, func, err_type, fmt, args);
+# else
+    FRT_VEXIT(err_type, fmt, args);
+# endif
+    va_end(args);
+}

data/ext/isomorfeus_ferret_ext/frt_lang.h

@@ -0,0 +1,44 @@
+#ifndef FRT_LANG_H
+#define FRT_LANG_H
+
+#include <stdarg.h>
+#include <stddef.h>
+
+extern void *frt_emalloc(size_t n);
+extern void *frt_ecalloc(size_t n);
+extern void *frt_erealloc(void *ptr, size_t n);
+
+#define FRT_ALLOC(type) (type *)frt_emalloc(sizeof(type))
+#define FRT_ALLOC_N(type,n) (type *)frt_emalloc(sizeof(type)*(n))
+#define FRT_REALLOC_N(ptr, type, n)\
+    (ptr)=(type *)frt_erealloc((ptr),sizeof(type)*(n))
+
+#ifdef FRT_HAS_ISO_VARARGS
+  /* C99-compliant compiler */
+
+# define FRT_XEXIT(...) frt_xexit(__FILE__, __LINE__, __func__, __VA_ARGS__)
+extern void frt_xexit(const char *file, int line_num, const char *func,
+                      const char *err_type, const char *fmt, ...);
+
+# define FRT_VEXIT(err_type, fmt, args) \
+    frt_vexit(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void frt_vexit(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_XEXIT(args...) frt_xexit(__FILE__, __LINE__, __func__, ##args)
+extern void frt_xexit(const char *file, int line_num, const char *func,
+                      const char *err_type, const char *fmt, ...);
+
+# define FRT_VEXIT(err_type, fmt, args) \
+    frt_vexit(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void frt_vexit(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_XEXIT(const char *err_type, const char *fmt, ...);
+extern void FRT_VEXIT(const char *err_type, const char *fmt, va_list args);
+#endif
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_mempool.c

@@ -0,0 +1,87 @@
+#include "frt_global.h"
+#include "frt_mempool.h"
+#include <string.h>
+
+FrtMemoryPool *frt_mp_new_capa(int chuck_size, int init_buf_capa)
+{
+    FrtMemoryPool *mp = FRT_ALLOC(FrtMemoryPool);
+    mp->chunk_size = chuck_size;
+    mp->buf_capa = init_buf_capa;
+    mp->buffers = FRT_ALLOC_N(char *, init_buf_capa);
+
+    mp->buffers[0] = mp->curr_buffer = (char *)frt_emalloc(mp->chunk_size);
+    mp->buf_alloc = 1;
+    mp->buf_pointer = 0;
+    mp->pointer = 0;
+    return mp;
+}
+
+FrtMemoryPool *frt_mp_new()
+{
+    return frt_mp_new_capa(FRT_MP_BUF_SIZE, FRT_MP_INIT_CAPA);
+}
+
+void *frt_mp_alloc(FrtMemoryPool *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;
+                FRT_REALLOC_N(mp->buffers, char *, mp->buf_capa);
+            }
+            mp->buffers[mp->buf_pointer] = (char *)frt_emalloc(mp->chunk_size);
+        }
+        p = mp->curr_buffer = mp->buffers[mp->buf_pointer];
+        mp->pointer = size;
+    }
+    return p;
+}
+
+char *frt_mp_strdup(FrtMemoryPool *mp, const char *str)
+{
+    int len = strlen(str) + 1;
+    return (char *)memcpy(frt_mp_alloc(mp, len), str, len);
+}
+
+char *frt_mp_strndup(FrtMemoryPool *mp, const char *str, int len)
+{
+    char *s = (char *)memcpy(frt_mp_alloc(mp, len + 1), str, len);
+    s[len] = '\0';
+    return s;
+}
+
+void *frt_mp_memdup(FrtMemoryPool *mp, const void *p, int len)
+{
+    return memcpy(frt_mp_alloc(mp, len), p, len);
+}
+
+int frt_mp_used(FrtMemoryPool *mp)
+{
+    return mp->buf_pointer * mp->chunk_size + mp->pointer;
+}
+
+void frt_mp_reset(FrtMemoryPool *mp)
+{
+    mp->buf_pointer = 0;
+    mp->pointer = 0;
+    mp->curr_buffer = mp->buffers[0];
+}
+
+void frt_mp_destroy(FrtMemoryPool *mp)
+{
+    int i;
+    for (i = 0; i < mp->buf_alloc; i++) {
+        free(mp->buffers[i]);
+    }
+    free(mp->buffers);
+    free(mp);
+}

data/ext/isomorfeus_ferret_ext/frt_mempool.h

@@ -0,0 +1,33 @@
+#ifndef FRT_MEM_POOL_H
+#define FRT_MEM_POOL_H
+
+#define FRT_MP_BUF_SIZE 65536
+#define FRT_MP_INIT_CAPA 4
+
+typedef struct FrtMemoryPool {
+    int buf_alloc;
+    int buf_capa;
+    int buf_pointer;
+    int pointer;
+    int chunk_size;
+    char *curr_buffer;
+    char **buffers;
+} FrtMemoryPool;
+
+extern FrtMemoryPool *frt_mp_new();
+extern FrtMemoryPool *frt_mp_new_capa(int chunk_size, int init_capa);
+extern void *frt_mp_alloc(FrtMemoryPool *mp, int size);
+extern void frt_mp_reset(FrtMemoryPool *mp);
+extern void frt_mp_destroy(FrtMemoryPool *mp);
+extern char *frt_mp_strdup(FrtMemoryPool *mp, const char *str);
+extern char *frt_mp_strndup(FrtMemoryPool *mp, const char *str, int len);
+extern void *frt_mp_memdup(FrtMemoryPool *mp, const void *p, int len);
+extern int frt_mp_used(FrtMemoryPool *mp);
+
+#define FRT_MP_ALLOC_N(mp,type,n) (type *)frt_mp_alloc(mp, sizeof(type)*(n))
+#define FRT_MP_ALLOC(mp,type) (type *)frt_mp_alloc(mp, sizeof(type))
+
+#define FRT_MP_ALLOC_AND_ZERO_N(mp,type,n)\
+    (type*)FRT_ZEROSET_N(frt_mp_alloc(mp, sizeof(type)*(n)), type, n)
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_multimapper.c

@@ -0,0 +1,349 @@
+#include "frt_multimapper.h"
+#include "frt_array.h"
+#include "frt_bitvector.h"
+#include <string.h>
+
+#define St(state) ((FrtState *)(state))
+#define UCtoI(val) ((int)(unsigned char)(val))
+
+static void state_destroy(FrtState *state)
+{
+    state->destroy_i(state);
+}
+
+typedef struct LetterState
+{
+    FrtState 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   = FRT_ALLOC(LetterState);
+    self->c             = c;
+    self->val           = val;
+    self->mapping       = NULL;
+    St(self)->next      = (int (*)(FrtState *, int, int *))&lstate_next;
+    St(self)->destroy_i = (void (*)(FrtState *))&free;
+    St(self)->is_match  = (int (*)(FrtState *, char **))&lstate_is_match;
+    return self;
+}
+
+typedef struct NonDeterministicState
+{
+    FrtState 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;
+        }
+        FRT_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(FrtState *self, char **mapping)
+{
+    (void)self; (void)mapping;
+    return 0;
+}
+
+static NonDeterministicState *ndstate_new()
+{
+    NonDeterministicState *self = FRT_ALLOC_AND_ZERO(NonDeterministicState);
+    St(self)->next              = (int (*)(FrtState *, int, int *))&ndstate_next;
+    St(self)->destroy_i         = (void (*)(FrtState *))&ndstate_destroy_i;
+    St(self)->is_match          = &ndstate_is_match;
+    return self;
+}
+
+FrtMultiMapper *frt_mulmap_new()
+{
+    FrtMultiMapper *self = FRT_ALLOC_AND_ZERO(FrtMultiMapper);
+    self->capa = 128;
+    self->mappings = FRT_ALLOC_N(FrtMapping *, 128);
+    self->d_capa = 128;
+    self->dstates = FRT_ALLOC_N(FrtDeterministicState *, 128);
+    self->dstates_map = NULL;
+    self->nstates = NULL;
+    self->ref_cnt = 1;
+    return self;
+}
+
+static void mulmap_free_dstates(FrtMultiMapper *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 frt_mulmap_add_mapping(FrtMultiMapper *self, const char *pattern, const char *rep)
+{
+    if (pattern == NULL || pattern[0] == '\0') {
+        FRT_RAISE(FRT_ARG_ERROR, "Tried to add empty pattern to multi_mapper");
+    } else {
+        FrtMapping *mapping = FRT_ALLOC(FrtMapping);
+        if (self->size >= self->capa) {
+            self->capa <<= 1;
+            FRT_REALLOC_N(self->mappings, FrtMapping *, self->capa);
+        }
+        mapping->pattern = frt_estrdup(pattern);
+        mapping->replacement = frt_estrdup(rep);
+        self->mappings[self->size++] = mapping;
+        mulmap_free_dstates(self);
+    }
+}
+
+
+static void mulmap_bv_set_states(FrtBitVector *bv, int *states, int cnt)
+{
+    int i;
+    for (i = cnt - 1; i >= 0; i--) {
+        frt_bv_set(bv, states[i]);
+    }
+}
+
+static FrtDeterministicState *mulmap_process_state(FrtMultiMapper *self, FrtBitVector *bv)
+{
+    FrtDeterministicState *current_state
+        = (FrtDeterministicState *)frt_h_get(self->dstates_map, bv);
+    if (current_state == NULL) {
+        int bit, i;
+        int match_len = 0, max_match_len = 0;
+        FrtState *start = self->nstates[0];
+        FrtDeterministicState *start_ds;
+        current_state = FRT_ALLOC_AND_ZERO(FrtDeterministicState);
+        frt_h_set(self->dstates_map, bv, current_state);
+        if (self->d_size >= self->d_capa) {
+            self->d_capa <<= 1;
+            FRT_REALLOC_N(self->dstates, FrtDeterministicState *, 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 = frt_bv_scan_next(bv)) >= 0) {
+            char *mapping;
+            FrtState *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];
+            FrtBitVector *nxt_bv = frt_bv_new_capa(self->nsize);
+            mulmap_bv_set_states(nxt_bv, self->next_states,
+                                 start->next(start, (int)c, self->next_states));
+            frt_bv_scan_reset(bv);
+            while ((bit = frt_bv_scan_next(bv)) >= 0) {
+                FrtState *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 {
+        frt_bv_destroy(bv);
+    }
+    return current_state;
+}
+
+void frt_mulmap_compile(FrtMultiMapper *self)
+{
+    NonDeterministicState *start = ndstate_new();
+    int i, j;
+    int size = 1;
+    int capa = 128;
+    LetterState *ls;
+    FrtState **nstates = FRT_ALLOC_N(FrtState *, capa);
+    FrtMapping **mappings = self->mappings;
+    unsigned char alphabet[256];
+    nstates[0] = (FrtState *)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;
+            FRT_REALLOC_N(nstates, FrtState *, capa);
+        }
+        for (j = 0; j < plen; j++) {
+            alphabet[UCtoI(pattern[j])] = 1;
+            size += 1;
+            nstates[size-1] = (FrtState *)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 = FRT_ALLOC_N(int, size);
+    self->dstates_map = frt_h_new((frt_hash_ft)&frt_bv_hash, (frt_eq_ft)&frt_bv_eq,
+                              (frt_free_ft)&frt_bv_destroy, (frt_free_ft)NULL);
+    mulmap_process_state(self, frt_bv_new_capa(0));
+    frt_h_destroy(self->dstates_map);
+    for (i = size - 1; i >= 0; i--) {
+        state_destroy(nstates[i]);
+    }
+    free(self->next_states);
+    free(nstates);
+}
+
+int frt_mulmap_map_len(FrtMultiMapper *self, char *to, char *from, int capa)
+{
+    FrtDeterministicState *start = self->dstates[0];
+    FrtDeterministicState *state = start;
+    char *s = from, *d = to, *end = to + capa - 1;
+    if (self->d_size == 0) {
+        frt_mulmap_compile(self);
+    }
+    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 *frt_mulmap_map(FrtMultiMapper *self, char *to, char *from, int capa)
+{
+    frt_mulmap_map_len(self, to, from, capa);
+    return to;
+}
+
+/* Maps a string to a dynamically allocated string */
+char *frt_mulmap_dynamic_map(FrtMultiMapper *self, char *from)
+{
+    FrtDeterministicState *start = self->dstates[0];
+    FrtDeterministicState *state = start;
+    int capa = strlen(from);
+    char *to = (char *)frt_ecalloc(capa);
+    char *s = from, *d = to, *end = to + capa - 1;
+    if (self->d_size == 0) {
+        frt_mulmap_compile(self);
+    }
+    do {
+        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++;
+        }
+        if (*s) {
+            capa += 1024;
+            frt_erealloc(to, capa);
+            end = to + capa - 1;
+        }
+    } while(*s);
+    *d = '\0';
+    return to;
+}
+
+void frt_mulmap_destroy(FrtMultiMapper *self)
+{
+    if (--(self->ref_cnt) <= 0) {
+        int i;
+        mulmap_free_dstates(self);
+        for (i = self->size - 1; i >= 0; i--) {
+            FrtMapping *mapping = self->mappings[i];
+            free(mapping->pattern);
+            free(mapping->replacement);
+            free(mapping);
+        }
+        free(self->mappings);
+        free(self->dstates);
+        free(self);
+    }
+}

data/ext/isomorfeus_ferret_ext/frt_multimapper.h

@@ -0,0 +1,52 @@
+#ifndef FRT_MAPPER_H
+#define FRT_MAPPER_H
+
+#include "frt_hash.h"
+
+typedef struct FrtState
+{
+    int  (*next)(struct FrtState *self, int c, int *states);
+    void (*destroy_i)(struct FrtState *self);
+    int  (*is_match)(struct FrtState *self, char **mapping);
+} FrtState;
+
+typedef struct FrtDeterministicState
+{
+    struct FrtDeterministicState *next[256];
+    int longest_match;
+    char *mapping;
+    int mapping_len;
+} FrtDeterministicState;
+
+typedef struct FrtMapping
+{
+    char *pattern;
+    char *replacement;
+} FrtMapping;
+
+typedef struct FrtMultiMapper
+{
+    FrtMapping **mappings;
+    int size;
+    int capa;
+    FrtDeterministicState **dstates;
+    int d_size;
+    int d_capa;
+    unsigned char alphabet[256];
+    int a_size;
+    FrtHash *dstates_map;
+    FrtState **nstates;
+    int nsize;
+    int *next_states;
+    int ref_cnt;
+} FrtMultiMapper;
+
+extern FrtMultiMapper *frt_mulmap_new();
+extern void frt_mulmap_add_mapping(FrtMultiMapper *self, const char *p, const char *r);
+extern void frt_mulmap_compile(FrtMultiMapper *self);
+extern char *frt_mulmap_map(FrtMultiMapper *self, char *to, char *from, int capa);
+extern char *frt_mulmap_dynamic_map(FrtMultiMapper *self, char *from);
+extern int frt_mulmap_map_len(FrtMultiMapper *self, char *to, char *from, int capa);
+extern void frt_mulmap_destroy(FrtMultiMapper *self);
+
+#endif