triez 0.3 → 1.0

data/ext/hat-trie/misc.c

@@ -0,0 +1,46 @@
+/*
+ * This file is part of hat-trie.
+ *
+ * Copyright (c) 2011 by Daniel C. Jones <dcjones@cs.washington.edu>
+ *
+ */
+
+#include "misc.h"
+#include <stdlib.h>
+
+
+void* malloc_or_die(size_t n)
+{
+    void* p = malloc(n);
+    if (p == NULL && n != 0) {
+        fprintf(stderr, "Cannot allocate %zu bytes.\n", n);
+        exit(EXIT_FAILURE);
+    }
+    return p;
+}
+
+
+void* realloc_or_die(void* ptr, size_t n)
+{
+    void* p = realloc(ptr, n);
+    if (p == NULL && n != 0) {
+        fprintf(stderr, "Cannot allocate %zu bytes.\n", n);
+        exit(EXIT_FAILURE);
+    }
+    return p;
+}
+
+
+FILE* fopen_or_die(const char* path, const char* mode)
+{
+    FILE* f = fopen(path, mode);
+    if (f == NULL) {
+        fprintf(stderr, "Cannot open file %s with mode %s.\n", path, mode);
+        exit(EXIT_FAILURE);
+    }
+    return f;
+}
+
+
+
+

data/ext/triez.cc

@@ -29,11 +29,11 @@ static inline VALUE LL2V(long long l) {
 
 struct HatTrie {
     hattrie_t* p;
+    VALUE default_value;
     bool obj_value;
-    bool suffix;
     bool initialized;
 
-    HatTrie() : obj_value(false), suffix(false), initialized(false) {
+    HatTrie() : default_value(Qnil), obj_value(false), initialized(false) {
         p = hattrie_create();
     }
 
@@ -44,6 +44,9 @@ struct HatTrie {
 
 static void hat_mark(void* p_ht) {
     HatTrie* ht = (HatTrie*)p_ht;
+    if (!IMMEDIATE_P(ht->default_value)) {
+        rb_gc_mark(ht->default_value);
+    }
     if (!ht->obj_value) {
         return;
     }
@@ -75,29 +78,23 @@ static VALUE hat_alloc(VALUE self) {
     Check_Type(key, T_STRING);\
     key = unify_key(key);
 
-static VALUE hat_set_type(VALUE self, VALUE obj_value, VALUE suffix) {
+static VALUE hat_set_type(VALUE self, VALUE obj_value, VALUE default_value) {
     HatTrie* ht;
     Data_Get_Struct(self, HatTrie, ht);
     if (ht->initialized) {
         rb_raise(rb_eRuntimeError, "Already initialized");
         return self;
     }
+    ht->default_value = default_value;
     ht->obj_value = RTEST(obj_value);
-    ht->suffix = RTEST(suffix);
     ht->initialized = true;
     return self;
 }
 
-static VALUE hat_obj_value_p(VALUE self) {
-    HatTrie* ht;
-    Data_Get_Struct(self, HatTrie, ht);
-    return ht->obj_value ? Qtrue : Qfalse;
-}
-
-static VALUE hat_suffix_p(VALUE self) {
+static VALUE hat_value_type(VALUE self) {
     HatTrie* ht;
     Data_Get_Struct(self, HatTrie, ht);
-    return ht->suffix ? Qtrue : Qfalse;
+    return ht->obj_value ? ID2SYM(rb_intern("object")) : ID2SYM(rb_intern("int64"));
 }
 
 static VALUE hat_size(VALUE self) {
@@ -111,50 +108,58 @@ static VALUE hat_set(VALUE self, VALUE key, VALUE value) {
     long long v = ht->obj_value ? value : NUM2LL(value);
     char* s = RSTRING_PTR(key);
     size_t len = RSTRING_LEN(key);
-    if (ht->suffix) {
-        char* s_end = s + len;
-        long n;
-        for (; s < s_end; s += n, len -= n) {
-            n = rb_enc_mbclen(s, s_end, u8_enc);
-            hattrie_get(p, s, len)[0] = v;
-        }
+    hattrie_get(p, s, len)[0] = v;
+    return self;
+}
+
+static inline void hat_change(HatTrie* ht, hattrie_t* p, char* s, size_t len) {
+    // NOTE must use 2-step change, because the block may change the trie
+    value_t* vp = hattrie_tryget(p, s, len);
+    long long v;
+    if (ht->obj_value) {
+        VALUE value = vp ? LL2V(vp[0]) : ht->default_value;
+        v = V2LL(rb_yield(value));
     } else {
-        hattrie_get(p, s, len)[0] = v;
+        VALUE value = vp ? LL2NUM(vp[0]) : ht->default_value;
+        v = NUM2LL(rb_yield(value));
+    }
+    hattrie_get(p, s, len)[0] = v;
+}
+
+static inline void hat_change_prefix(HatTrie* ht, hattrie_t* p, char* s, size_t len, char* rs) {
+    char* rs_end = rs + len;
+    long n;
+    for (; rs < rs_end; rs += n, len -= n) {
+        hat_change(ht, p, s, len);
+        // no need check encoding because reverse succeeded
+        n = rb_enc_fast_mbclen(rs, rs_end, u8_enc);
     }
-    return self;
 }
 
-static VALUE hat_alt(VALUE self, VALUE key) {
+static VALUE hat_change_all(VALUE self, VALUE type, VALUE key) {
     PRE_HAT;
     char* s = RSTRING_PTR(key);
     size_t len = RSTRING_LEN(key);
-    if (ht->suffix) {
+    ID ty = SYM2ID(type);
+    if (ty == rb_intern("suffix")) {
         char* s_end = s + len;
         long n;
         for (; s < s_end; s += n, len -= n) {
+            hat_change(ht, p, s, len);
             n = rb_enc_mbclen(s, s_end, u8_enc);
-            value_t* vp = hattrie_tryget(p, s, len);
-            long long v;
-            if (ht->obj_value) {
-                VALUE value = vp ? LL2V(vp[0]) : Qnil;
-                v = V2LL(rb_yield(value));
-            } else {
-                VALUE value = vp ? LL2NUM(vp[0]) : LL2NUM(0);
-                v = NUM2LL(rb_yield(value));
-            }
-            hattrie_get(p, s, len)[0] = v;
         }
-    } else {
-        value_t* vp = hattrie_tryget(p, s, len);
-        long long v;
-        if (ht->obj_value) {
-            VALUE value = vp ? LL2V(vp[0]) : Qnil;
-            v = V2LL(rb_yield(value));
-        } else {
-            VALUE value = vp ? LL2NUM(vp[0]) : LL2NUM(0);
-            v = NUM2LL(rb_yield(value));
+    } else if (ty == rb_intern("prefix")) {
+        volatile VALUE reversed = rb_funcall(key, rb_intern("reverse"), 0);
+        hat_change_prefix(ht, p, s, len, RSTRING_PTR(reversed));
+    } else if (ty == rb_intern("substring")) {
+        volatile VALUE reversed = rb_funcall(key, rb_intern("reverse"), 0);
+        char* rs = RSTRING_PTR(reversed);
+        char* s_end = s + len;
+        long n;
+        for (; s < s_end; s += n, len -= n) {
+            hat_change_prefix(ht, p, s, len, rs);
+            n = rb_enc_fast_mbclen(s, s_end, u8_enc);
         }
-        hattrie_get(p, s, len)[0] = v;
     }
     return self;
 }
@@ -162,7 +167,7 @@ static VALUE hat_alt(VALUE self, VALUE key) {
 static VALUE hat_append(VALUE self, VALUE key) {
     HatTrie* ht;
     Data_Get_Struct(self, HatTrie, ht);
-    return hat_set(self, key, ht->obj_value ? Qnil : LL2NUM(0));
+    return hat_set(self, key, ht->default_value);
 }
 
 static VALUE hat_get(VALUE self, VALUE key) {
@@ -171,7 +176,7 @@ static VALUE hat_get(VALUE self, VALUE key) {
     if (vt) {
         return ht->obj_value ? (*vt) : LL2NUM(*vt);
     } else {
-        return Qnil;
+        return ht->default_value;
     }
 }
 
@@ -184,7 +189,7 @@ static VALUE hat_del(VALUE self, VALUE key) {
         hattrie_del(p, RSTRING_PTR(key), RSTRING_LEN(key));
         return ht->obj_value ? (*vt) : LL2NUM(*vt);
     } else {
-        return Qnil;
+        return ht->default_value;
     }
 }
 
@@ -205,7 +210,6 @@ static VALUE hat_search_callback(VALUE data) {
     return rb_funcall(p->callback, rb_intern("call"), 2, p->suffix, p->value);
 }
 
-// returns: true if an error occured
 static VALUE hat_search(VALUE self, VALUE key, VALUE vlimit, VALUE vsort, VALUE callback) {
     PRE_HAT;
     long limit = 0;
@@ -248,14 +252,13 @@ void Init_triez() {
 
     rb_define_alloc_func(hat_class, hat_alloc);
     DEF(hat_class, "_internal_set_type", hat_set_type, 2);
-    DEF(hat_class, "obj_value?", hat_obj_value_p, 0);
-    DEF(hat_class, "suffix?", hat_suffix_p, 0);
+    DEF(hat_class, "value_type", hat_value_type, 0);
     DEF(hat_class, "size", hat_size, 0);
-    DEF(hat_class, "has_key?", hat_check, 1);
     DEF(hat_class, "[]=", hat_set, 2);
-    DEF(hat_class, "alt", hat_alt, 1);
+    DEF(hat_class, "change_all", hat_change_all, 2);
     DEF(hat_class, "<<", hat_append, 1);
     DEF(hat_class, "[]", hat_get, 1);
+    DEF(hat_class, "has_key?", hat_check, 1);
     DEF(hat_class, "delete", hat_del, 1);
     DEF(hat_class, "_internal_search", hat_search, 4);
 }

data/lib/triez.rb

@@ -1,34 +1,49 @@
 require_relative "../ext/triez"
 
 class Triez
-  VERSION = '0.3'
+  VERSION = '1.0'
 
   private :_internal_set_type
   private :_internal_search
 
   def initialize opts={}
     opts = opts.dup
-    obj_value = opts.delete :obj_value
-    obj_value = false if obj_value.nil?
-    suffix    = opts.delete :suffix
-    suffix    = false if suffix.nil?
+
+    value_type = opts.delete :value_type
+    if value_type.nil?
+      value_type = :int64
+    elsif value_type != :int64 and value_type != :object
+      raise ArgumentError, "value_type should be :int64 or :object, but got #{value_type.inspect}"
+    end
+
+    default = opts.delete :default
+    if default.nil?
+      default = (value_type == :int64 ? 0 : nil)
+    elsif value_type == :int64
+      default = default.to_i
+    end
+
     unless opts.empty?
-      raise ArgumentError, "Unknown options: #{opts.keys.inspect}, only [:suffix, :obj_value] are allowed"
+      raise ArgumentError, "Unknown options: #{opts.keys.inspect}, only [:value_type, :default] are allowed"
     end
-    _internal_set_type obj_value, suffix
+
+    _internal_set_type value_type == :object, default
   end
 
   def each &p
     raise ArgumentError, 'Need a block' unless p
+
     _internal_search '', nil, true, p
   end
 
   def search_with_prefix prefix, opts={}, &p
     opts  = opts.dup
+
     limit = opts.delete :limit
     if !limit.nil? and limit < 0
       raise ArgumentError, "Limit should be > 0"
     end
+
     sort = opts.delete :sort
     unless opts.empty?
       raise ArgumentError, "Unknown options: #{opts.keys.inspect}, only [:limit, :sort] are allowed"

data/readme.md

@@ -1,10 +1,10 @@
 ## What
 
-Pragmatic [trie](http://en.wikipedia.org/wiki/Trie) for Ruby.
+Pragmatic [tries](http://en.wikipedia.org/wiki/Trie) for Ruby, spelled in lolcat.
 
-It is fast, memory efficient, unicode aware.
+It is fast, memory efficient, unicode aware, prefix searchable, and enchanced with prefix/suffix/substring keys.
 
-The backend of *triez* is a cache oblivious data structure: the [HAT trie](https://github.com/dcjones/hat-trie). It is generally faster and more memory efficient than double arrays or burst tries.
+The backend of *triez* is a cache oblivious data structure: the [HAT trie](https://github.com/dcjones/hat-trie) (In fact I'm using a [modified version](https://github.com/luikore/hat-trie) for improved functionality). HAT trie is generally faster and more memory efficient than [double array](http://linux.thai.net/~thep/datrie/datrie.html) or [burst trie](http://ww2.cs.mu.oz.au/~jz/fulltext/acmtois02.pdf).
 
 ## Requirement
 
@@ -22,32 +22,57 @@ gem ins triez
 ``` ruby
 require 'triez'
 
+# create triez
 t = Triez.new
 
-# insertion
+# the above code is equivalent to :int64 for :value_type and 0 for :default
+t = Triez.new value_type: :int64
+
+# more flexible with object type [*see note below]
+t = Triez.new value_type: :object
+
+# get the value type
+t.value_type
+
+# set a different default value
+t = Triez.new value_type: :object, default: 'hello'
+
+# insert or change value
 t['key'] = 100
 
-# insert a key with default value (0 for normal triez, nil for obj_valued triez)
+# insert a key with default value
 t << 'key'
 
-# search
+# batch change values under all suffices/prefices/substrings of a key
+t.change_all(:suffix, 'key') {|old_value| ...calculate new value }
+t.change_all(:prefix, 'key') {|old_value| ...calculate new value }
+# enumerates all occurences of substrings of the key
+t.change_all(:substring, 'key') {|old_value| ...calculate new value }
+
+# size of inserted keys
+t.size
+
+# search with exact match
 t.has_key? 'key'
 t['key']
 
-# iterate over values under a prefix.
+# prefixed search (iterate over values under a prefix), available options are:
+# - limit: max items, `nil` means no limit
+# - sort: whether iterate in alphabetic order, default is true
 t.search_with_prefix(prefix, limit: 10, sort: true) do |suffix, value|
   ...
 end
 
-# enumerate (NOTE it is unordered)
+# if no block given, an array in the form of [[suffix, value]] is returned
+t.search_with_prefix('prefix')
+
+# enumerate all keys and values in the order of binary collation
 t.each do |key, value|
   ...
 end
 ```
 
----
-
-By default, a *triez* stores signed integers within 64bits, you can use it as weights, counts or database IDs, and doesn't cost any time in GC marking phase. In case you need to store arbitrary object in a node, use `obj_value: true`:
+\* Note: By default, *triez* store signed integers within 64bits, you can use them as weights, counts or database IDs. In case you need to store arbitrary object in a node, use `obj_value: true`:
 
 ``` ruby
 t = Triez.new obj_value: true
@@ -55,46 +80,9 @@ t['Tom'] = {name: 'Tom', sex: 'Female'}
 t['Tree'] = [:leaf, :trunk, :root]
 ```
 
----
-
-When a *triez* is initialized with `suffix: true`, it inserts all suffices of a key
-
-``` ruby
-t = Triez.new suffix: true
-t['万塘路一锅鸡'] = 2
-t['万塘路一锅鸡'] #=> 2
-t['塘路一锅鸡'] #=> 2
-t['路一锅鸡']  #=> 2
-t['一锅鸡']   #=> 2
-t['锅鸡']    #=> 2
-t['鸡']     #=> 2
-```
-
-You can batch change values with a block
-
-``` ruby
-# v *= 5 for 'abcd', 'bcd', 'cd', 'd'
-t.alt 'abcd' do |v|
-  v * 5
-end
-t['abcd'] #=> 10
-t['cd']   #=> 10
-```
-
----
-
-Misc methods
-
-``` ruby
-# if it is a suffix trie
-t.suffix?
-# if the value type is object
-t.obj_value?
-```
-
 ## Examples
 
-Prefix-based autocompletion:
+**Prefix based autocompletion**:
 
 ``` ruby
 require 'triez'
@@ -117,7 +105,7 @@ candidate: red
 
 ---
 
-Efficiently search for strings containing a substring:
+**Efficient [full text search](https://en.wikipedia.org/wiki/Full_text_search) with a [suffix tree](https://en.wikipedia.org/wiki/Suffix_tree)**:
 
 ``` ruby
 require 'triez'
@@ -126,18 +114,59 @@ sequences = {
   'ATACGGTCCA' => 2,
   'GCTTGTACGT' => 3
 }
-t = Triez.new suffix: true
+t = Triez.new
+
+# build suffix trie
 sequences.each do |seq, id|
-  t[seq] = id
+  t.change_all :suffix, [seq] = id
 end
+
 t.search_with_prefix 'CGGT' do |_, id|
   puts id #=> 2
 end
 ```
 
-The search time is linear to the length of the substring.
+The searching time is linear to the length of the substring.
+
+---
 
-## Benchmarks
+**Solve the [longest common substring problem](https://en.wikipedia.org/wiki/Longest_common_substring_problem)**:
+
+``` ruby
+# coding: utf-8
+require 'triez'
+sentences = %w[
+  万塘路一锅鸡
+  去文二路一锅鸡吃饭
+  来一锅鸡顶盒
+  一锅鸡胗
+]
+
+# value is bitset representing id of the sentence
+# in ruby we can use integers of arbitrary length as bitsets
+t = Triez.new value_type: :object, default: 0
+
+sentences.each_with_index do |sentence, i|
+  elem = 1 << i
+  t.change_all :substring, sentence do |v|
+    # union
+    v | elem
+  end
+end
+
+# longest common substring
+lcs = ''
+
+# find the key tagged with universe
+universe = (1 << sentences.size) - 1
+t.each do |k, v|
+  lcs = k if k.size > lcs.size and v == universe
+end
+
+puts lcs #=> 一锅鸡
+```
+
+## Benchmark
 
 Here's a benchmark on
 
@@ -146,23 +175,23 @@ ruby 1.9.3p374 (2013-01-15 revision 38858) [x86_64-darwin12.2.1]
 2.3 GHz Intel Core i7
 ```
 
-The test data is 3 milion titles of wikipedia articles (from http://dumps.wikimedia.org/enwiki/20121101/)
+The test data are 3 milion titles of wikipedia articles (from http://dumps.wikimedia.org/enwiki/20121101/)
 
 ```
-thing/backend      | memory  | insertion time | 3 M query
--------------------|---------|----------------|----------
-hash/linked hash   | 340.2 M |    4.369 s     | 0.2800 s
-trie/double array* | 155.6 M |    130.7 s     | 0.4359 s
-triez/HAT trie     | 121.7 M |    3.872 s     | 0.3472 s
+thing/backend           | memory  | insertion time | 3 M query
+------------------------|---------|----------------|----------
+hash/linked hash        | 340.2 M |    4.369 s     | 0.2800 s
+fast_trie/double array* | 155.6 M |    130.7 s     | 0.4359 s
+triez/HAT trie          | 121.7 M |    3.872 s     | 0.3472 s
 ```
 
-NOTE: `trie/double array` -> https://github.com/tyler/trie
+Note: `trie/double array` -> https://github.com/tyler/trie
 
 ## Caveats
 
-- `sort` orders keys with binary collation, not unicode codepoint collation in string comparison.
+- The `sort` option in prefixed search orders keys with binary [collation](https://en.wikipedia.org/wiki/Collation), but string comparison in Ruby is with unicode codepoint collation.
 - For some rare case of many threads modifying the same trie, you may need a mutex.
-- If you still feel memory not enough, you may consider [MARISA-trie](https://code.google.com/p/marisa-trie/) (NOTE that MARISA is immutable) or a database.
+- If you still feel memory not enough, you may consider [MARISA-trie](https://code.google.com/p/marisa-trie/) (note that MARISA is immutable), or a database.
 
 ## Development
 
@@ -172,3 +201,7 @@ cd triez
 rake glob_src
 rake
 ```
+
+## Note
+
+Although HAT trie uses MurMurHash3 instead of SipHash in Ruby, It is still safe under hashDoS because bucket size is limited.

data/test/triez_test.rb

@@ -1,20 +1,28 @@
+# coding: utf-8
 require "test/unit"
 require_relative "../lib/triez"
 
 GC.stress
 
 class TriezTest < Test::Unit::TestCase
-  def test_init_options
-    t = Triez.new obj_value: true
-    assert_equal true, t.obj_value?
-    assert_equal false, t.suffix?
-    t = Triez.new suffix: true
-    assert_equal true, t.suffix?
-    assert_equal false, t.obj_value?
+  def test_init_type_options
+    t = Triez.new value_type: :int64
+    assert_equal :int64, t.value_type
+    t = Triez.new value_type: :object
+    assert_equal :object, t.value_type
+    t = Triez.new
+    assert_equal :int64, t.value_type
+
+    assert_raise ArgumentError do
+      Triez.new value_type: :string
+    end
+    assert_raise ArgumentError do
+      Triez.new invalid_option: :int64
+    end
   end
 
   def test_hat_trie
-    t = Triez.new obj_value: true
+    t = Triez.new value_type: :object
 
     v1 = (1 << 40)
     v2 = (1 << 141)
@@ -87,21 +95,15 @@ class TriezTest < Test::Unit::TestCase
     assert_equal true, t.has_key?('c')
   end
 
-  def test_suffix_insert
-    t = Triez.new suffix: true
-    t << '12345'
-    assert_equal 5, t.size
-  end
-
   def test_full_text_search
     sequences = {
       'ACTGAAAAAAACTG' => 1,
       'ATACGGTCCA' => 2,
       'GCTTGTACGT' => 3
     }
-    t = Triez.new suffix: true
+    t = Triez.new
     sequences.each do |seq, id|
-      t[seq] = id
+      t.change_all(:suffix, seq){ id }
     end
     assert_equal 2, t.search_with_prefix('CGGT').map(&:last).flatten.first
   end
@@ -111,6 +113,76 @@ class TriezTest < Test::Unit::TestCase
     t["a\0b"] = 1
     assert_equal 1, t["a\0b"]
     assert_equal 1, t.size
-    assert_equal nil, t["a"]
+    assert_equal 0, t["a"]
+  end
+
+  def test_change_all_with_prefix
+    default = 10
+    t = Triez.new default: default
+    t['regexp'] = 1
+    t['readme'] = 2
+    t.change_all :prefix, 'readme' do |v|
+      v += 4
+    end
+    assert_equal 'readme'.size + 1, t.size
+    assert_equal 6, t['readme']
+    assert_equal default + 4, t['read']
+    assert_equal 1, t['regexp']
+  end
+
+  def test_change_all_with_suffix
+    t = Triez.new
+    t['regexp'] = 1
+    t['exp'] = 2
+    t['reg'] = 3
+    t.change_all :suffix, 'regexp' do |v|
+      v += 4
+    end
+    assert_equal 5, t['regexp']
+    assert_equal 6, t['exp']
+    assert_equal 3, t['reg']
+    assert_equal 'regexp'.size + 1, t.size
+  end
+
+  def test_change_all_with_substring
+    t = Triez.new value_type: :object
+    t.change_all :substring, 'abc' do
+      1
+    end
+
+    keys = []
+    t.each do |k, v|
+      keys << k
+    end
+    assert_equal %w[a b c ab bc abc].sort, keys.sort
+  end
+
+  def test_solve_longest_common_substring
+    sentences = %w[
+      万塘路一锅鸡
+      文二路一锅鸡
+      来一锅鸡顶盒
+      一锅鸡胗
+    ]
+
+    # value is bitset representing id of the sentence
+    # in ruby we can use integers of arbitrary length as bitsets
+    t = Triez.new value_type: :object, default: 0
+
+    sentences.each_with_index do |sentence, i|
+      elem = 1 << i
+      t.change_all :substring, sentence do |v|
+        # union
+        v | elem
+      end
+    end
+
+    # longest common substring
+    lcs = ''
+    universe = (1 << sentences.size) - 1
+    t.each do |k, v|
+      lcs = k if (k.size > lcs.size and v == universe)
+    end
+    assert_equal '一锅鸡', lcs
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: triez
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '1.0'
   prerelease: 
 platform: ruby
 authors:
@@ -22,7 +22,6 @@ files:
 - readme.md
 - lib/triez.rb
 - test/triez_test.rb
-- ext/hat-stub.c
 - ext/triez.cc
 - ext/common.h
 - ext/extconf.rb
@@ -31,6 +30,7 @@ files:
 - ext/hat-trie/COPYING
 - ext/hat-trie/hat-trie.c
 - ext/hat-trie/hat-trie.h
+- ext/hat-trie/misc.c
 - ext/hat-trie/misc.h
 - ext/hat-trie/murmurhash3.c
 - ext/hat-trie/murmurhash3.h

data/ext/hat-stub.c

@@ -1,14 +0,0 @@
-#include <ruby.h>
-
-void* malloc_or_die(size_t sz) {
-    return malloc(sz);
-}
-
-void* realloc_or_die(void* p, size_t sz) {
-    return realloc(p, sz);
-}
-
-FILE* fopen_or_die(const char* file, const char* mode) {
-    // to do raise error
-    return fopen(file, mode);
-}