fast_method_source 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a8566fbdf9afc48e1122cd29d4ee799a455fd10
-  data.tar.gz: 3894ea5f9ab5e1b784b8c64078accf4b309323fb
+  metadata.gz: 5d4abbc77bfa1ddd3f7d8c335e4ed45de99d1d6f
+  data.tar.gz: 412abc3f1f3278f2a25041e3dcfc689e4c00b83d
 SHA512:
-  metadata.gz: 7ebf626281536e5d5ec319bc5bf3eb820cfa2e1191f07c5d7d7b94afcc1de95a0be63acafd01bbc93800e53753c399527243a27cd9e372da28b05a5133dc1557
-  data.tar.gz: f6a255e157ba75498e4b1005d462c9851da0c762cb9b81b096f754051b5e9ba056687c7ccc590e9229fda724928f37b1ba49ab35e42138e2737ac37b78a165a3
+  metadata.gz: 15c8a178256a9f168e2a2bf49a0f7a2dcba1a968664c1887d642de15685bf446d0b020eceb8fc322a1bb9e3172c158c2b28c3dc294ac8e46cc8c2406e7e479e6
+  data.tar.gz: 2930a5f50f0cf4d7b8745d0b44ca377a312cd06bdde2944ba38686fe782c7ec1fb0d232be6dd535e547aa4214a9f8528734882ed9d9820becf4a255e2c66c20d

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 Fast Method Source changelog
 ============================
 
+### v0.2.0 (June 11, 2015)
+
+* Significantly reduced memory consumption
+* The time of calculations has increased by 6%
+* Fixed memory not being freed on exceptions
+* Fixed exit code value for shells [→](https://github.com/kyrylo/fast_method_source/pull/2)
+
 ### v0.1.1 (June 9, 2015)
 
 * Fixed segfault on any C method query

data/README.md

@@ -63,13 +63,9 @@ This is a utility method and method_source doesn't feature it.
 Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19439
-Rehearsal ---------------------------------------------------------------------------
-FastMethodSource#comment_and_source_for  24.080000   1.900000  25.980000 ( 28.425889)
------------------------------------------------------------------ total: 25.980000sec
-
-                                              user     system      total        real
-FastMethodSource#comment_and_source_for  23.130000   1.710000  24.840000 ( 27.097578)
+Sample methods: 19438
+       user     system      total        real
+FastMethodSource#comment_and_source_for 26.050000   1.420000  27.470000 ( 30.528066)
 ```
 
 #### #source
@@ -79,15 +75,15 @@ FastMethodSource#comment_and_source_for  23.130000   1.710000  24.840000 ( 27.09
 Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19438
-Rehearsal -----------------------------------------------------------
-FastMethodSource#source  18.760000   1.290000  20.050000 ( 21.802014)
-MethodSource#source     100.100000   0.440000 100.540000 (122.748676)
------------------------------------------------- total: 120.590000sec
+Sample methods: 19596
+Rehearsal ------------------------------------------------------------
+FastMethodSource#comment   4.730000   0.300000   5.030000 (  5.590186)
+MethodSource#comment      73.660000   0.340000  74.000000 ( 89.475399)
+-------------------------------------------------- total: 79.030000sec
 
-                              user     system      total        real
-FastMethodSource#source  19.040000   1.170000  20.210000 ( 22.079805)
-MethodSource#source      92.740000   0.300000  93.040000 (103.833941)
+                               user     system      total        real
+FastMethodSource#comment   4.450000   0.300000   4.750000 (  5.278761)
+MethodSource#comment      69.880000   0.110000  69.990000 ( 77.663383)
 ```
 
 #### #comment
@@ -97,15 +93,15 @@ MethodSource#source      92.740000   0.300000  93.040000 (103.833941)
 Processor: Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz
 Platform: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
 Counting the number of sample methods...
-Sample methods: 19595
-Rehearsal ------------------------------------------------------------
-FastMethodSource#comment   4.120000   0.520000   4.640000 (  5.188443)
-MethodSource#comment      82.480000   0.330000  82.810000 (103.135012)
--------------------------------------------------- total: 87.450000sec
+Sample methods: 19438
+Rehearsal -----------------------------------------------------------
+FastMethodSource#source  20.610000   1.290000  21.900000 ( 24.341358)
+MethodSource#source      92.730000   0.470000  93.200000 (111.384362)
+------------------------------------------------ total: 115.100000sec
 
-                               user     system      total        real
-FastMethodSource#comment   3.580000   0.370000   3.950000 (  4.398557)
-MethodSource#comment      73.390000   0.150000  73.540000 ( 81.880220)
+                              user     system      total        real
+FastMethodSource#source  20.990000   1.150000  22.140000 ( 24.612721)
+MethodSource#source      86.390000   0.290000  86.680000 ( 96.241494)
 ```
 
 ### Correctness of output
@@ -133,18 +129,17 @@ Output.
 
 ### RAM consumption
 
-Memory consumption is considerably higher for Fast Method Source (for the
-benchmarks it used about 800-1500 MB of RES RAM). In fact, since the library is
-very young, it *may* have memory leaks.
+The [`comment_and_source`](/benchmarks/comment_and_source_for.rb) benchmark
+shows that at this moment the library uses about 450 MB of RAM.
 
 API
 ---
 
 ### General description
 
-The library provides two methods `#source` and `#comment`. There are two ways to
-use Fast Method Source. One way is to monkey-patch relevant core Ruby classes
-and use the methods directly.
+The library provides the following methods: `#comment`, `#source` and
+`#comment_and_source`. There are two ways to use Fast Method Source. One way is
+to monkey-patch relevant core Ruby classes and use the methods directly.
 
 ```ruby
 require 'fast_method_source'

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/ext/fast_method_source/extconf.rb

@@ -1,5 +1,5 @@
 require 'mkmf'
 
-$CFLAGS << ' -std=c99 -Wno-declaration-after-statement'
+$CFLAGS << ' -std=c99 -Wno-declaration-after-statement -O3'
 
 create_makefile('fast_method_source/fast_method_source')

data/ext/fast_method_source/fast_method_source.c

@@ -1,31 +1,96 @@
-#include "fast_method_source.h"
+// For getline(), fileno() and friends
+#define _XOPEN_SOURCE 700
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ruby.h>
+
+#include "node.h"
+
+#ifdef _WIN32
+#include <io.h>
+static const char *null_filename = "NUL";
+#define DUP(fd) _dup(fd)
+#define DUP2(fd, newfd) _dup2(fd, newfd)
+#else
+#include <unistd.h>
+static const char *null_filename = "/dev/null";
+#define DUP(fd) dup(fd)
+#define DUP2(fd, newfd) dup2(fd, newfd)
+#endif
+
+#define MAXLINES 600
+#define MAXLINELEN 90
+#define COMMENT_SIZE 1000
+#define SAFE_CHAR 'z'
+
+typedef struct {
+    int forward  : 1;
+    int backward : 1;
+} read_order;
+
+struct filebuf {
+    unsigned method_location;
+    const char *filename;
+    VALUE method_name;
+    char **lines;
+    unsigned relevant_lines;
+};
+
+struct retval {
+    VALUE val;
+    VALUE method_name;
+};
+
+static void read_lines(read_order order, struct filebuf *filebuf);
+static void read_lines_before(struct filebuf *filebuf);
+static void read_lines_after(struct filebuf *filebuf);
+static void reallocate_filebuf(char **lines[], unsigned rl_len);
+static void reallocate_linebuf(char **linebuf, const unsigned cl_len);
+static VALUE find_source(struct filebuf *filebuf);
+static VALUE find_comment(struct filebuf *filebuf);
+static VALUE mMethodExtensions_source(VALUE self);
+static NODE *parse_expr(VALUE rb_str);
+static NODE *parse_with_silenced_stderr(VALUE rb_str);
+static void filter_interp(char *line);
+static char **allocate_memory_for_file(void);
+static void free_memory_for_file(char **file[], const unsigned relevant_lines_n);
+static int contains_end_kw(const char *line);
+static int is_comment(const char *line, const size_t line_len);
+static int is_static_definition(const char *line);
+static int is_accessor(const char *line);
+static int is_dangling_literal_end(const char *line);
+static int is_dangling_literal_begin(const char *line);
+static void strnprep(char *s, const char *t, size_t len);
+static void raise_if_nil(VALUE val, VALUE method_name);
+static VALUE raise_if_nil_safe(VALUE args);
+static void realloc_comment(char **comment, unsigned len);
+static void filebuf_init(VALUE self, struct filebuf *filebuf);
+static void free_filebuf(VALUE retval, struct filebuf *filebuf);
 
 static VALUE rb_eSourceNotFoundError;
 
-static unsigned
-read_lines_after(const unsigned method_location,
-                 const char *filename, char **filebuf[])
+static void
+read_lines_after(struct filebuf *filebuf)
 {
     read_order order = {1, 0};
-    return read_lines(order, method_location, filename, filebuf);
+    read_lines(order, filebuf);
 }
 
-static unsigned
-read_lines_before(const unsigned method_location,
-                  const char *filename, char **filebuf[])
+static void
+read_lines_before(struct filebuf *filebuf)
 {
     read_order order = {0, 1};
-    return read_lines(order, method_location, filename, filebuf);
+    read_lines(order, filebuf);
 }
 
-static unsigned
-read_lines(read_order order, const unsigned method_location,
-           const char *filename, char **filebuf[])
+static void
+read_lines(read_order order, struct filebuf *filebuf)
 {
     FILE *fp;
 
-    if ((fp = fopen(filename, "r")) == NULL) {
-        rb_raise(rb_eIOError, "No such file or directory - %s", filename);
+    if ((fp = fopen(filebuf->filename, "r")) == NULL) {
+        rb_raise(rb_eIOError, "No such file or directory - %s", filebuf->filename);
     }
 
     ssize_t cl_len;
@@ -39,20 +104,20 @@ read_lines(read_order order, const unsigned method_location,
     while ((cl_len = getline(&current_line, &current_linebuf_size, fp)) != -1) {
         line_count++;
         if (order.forward) {
-            if (line_count < method_location) {
+            if (line_count < filebuf->method_location) {
                 continue;
             }
         } else if (order.backward) {
-            if (line_count > method_location) {
+            if (line_count > filebuf->method_location) {
                 break;
             }
         }
 
         if ((rl_n != 0) && (rl_n % (MAXLINES-1) == 0)) {
-            reallocate_filebuf(filebuf, rl_n);
+            reallocate_filebuf(&filebuf->lines, rl_n);
         }
 
-        current_linebuf = &(*filebuf)[rl_n];
+        current_linebuf = &(filebuf->lines)[rl_n];
 
         if (cl_len >= MAXLINELEN) {
             reallocate_linebuf(current_linebuf, cl_len);
@@ -65,19 +130,13 @@ read_lines(read_order order, const unsigned method_location,
 
     free(current_line);
     fclose(fp);
-
-    return rl_n;
+    filebuf->relevant_lines = rl_n;
 }
 
 static void
 reallocate_linebuf(char **linebuf, const unsigned cl_len)
 {
-    char *tmp_line;
-
-    if ((tmp_line = realloc(*linebuf, cl_len + 1)) == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate memory");
-    }
-
+    char *tmp_line = REALLOC_N(*linebuf, char, cl_len + 1);
     *linebuf = tmp_line;
 }
 
@@ -85,26 +144,28 @@ static void
 reallocate_filebuf(char **lines[], unsigned rl_len)
 {
     unsigned new_size = rl_len + MAXLINES + 1;
-    char **temp_lines = realloc(*lines, sizeof(*temp_lines) * new_size);
+    char **temp_lines = REALLOC_N(*lines, char *, new_size);
 
-    if (temp_lines == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate memory");
-    } else {
-        *lines = temp_lines;
+    *lines = temp_lines;
 
-        for (int i = 0; i < MAXLINES; i++) {
-            if (((*lines)[rl_len + i] = malloc(sizeof(char) * MAXLINELEN)) == NULL) {
-                rb_raise(rb_eNoMemError, "failed to allocate memory");
-            }
-        }
+    for (int i = 0; i < MAXLINES; i++) {
+        (*lines)[rl_len + i] = ALLOC_N(char, MAXLINELEN);
     }
 }
 
+static void
+realloc_comment(char **comment, unsigned len)
+{
+    char *tmp_comment = REALLOC_N(*comment, char, len);
+    *comment = tmp_comment;
+}
+
 static NODE *
 parse_with_silenced_stderr(VALUE rb_str)
 {
     int old_stderr;
     FILE *null_fd;
+    VALUE last_exception = rb_errinfo();
 
     old_stderr = DUP(STDERR_FILENO);
     fflush(stderr);
@@ -114,6 +175,7 @@ parse_with_silenced_stderr(VALUE rb_str)
     volatile VALUE vparser = rb_parser_new();
     NODE *node = rb_parser_compile_string(vparser, "-", rb_str, 1);
     rb_str_free(rb_str);
+    rb_set_errinfo(last_exception);
 
     fflush(stderr);
     fclose(null_fd);
@@ -221,22 +283,22 @@ is_dangling_literal_begin(const char *line)
 }
 
 static VALUE
-find_source(char **filebuf[], const unsigned relevant_lines_n)
+find_source(struct filebuf *filebuf)
 {
     VALUE rb_expr;
 
-    const unsigned expr_size = relevant_lines_n * MAXLINELEN;
-    char *expr = malloc(expr_size);
+    const unsigned expr_size = filebuf->relevant_lines * MAXLINELEN;
+    char *expr = ALLOC_N(char, expr_size);
     expr[0] = '\0';
-    char *parseable_expr = malloc(expr_size);
+    char *parseable_expr = ALLOC_N(char, expr_size);
     parseable_expr[0] = '\0';
 
     int l = 0;
-    while ((*filebuf)[l][0] == '\n') {
+    while (filebuf->lines[l][0] == '\n') {
         l++;
         continue;
     }
-    char *first_line = (*filebuf)[l];
+    char *first_line = (filebuf->lines)[l];
 
     char *current_line = NULL;
     int should_parse = 0;
@@ -247,8 +309,8 @@ find_source(char **filebuf[], const unsigned relevant_lines_n)
         should_parse = 1;
     }
 
-    for (unsigned i = l; i < relevant_lines_n; i++) {
-        current_line = (*filebuf)[i];
+    for (unsigned i = l; i < filebuf->relevant_lines; i++) {
+        current_line = filebuf->lines[i];
         current_line_len = strlen(current_line);
 
         strncat(expr, current_line, current_line_len);
@@ -270,16 +332,15 @@ find_source(char **filebuf[], const unsigned relevant_lines_n)
         if (should_parse || contains_end_kw(current_line)) {
             if (parse_expr(rb_str_new2(parseable_expr)) != NULL) {
                 rb_expr = rb_str_new2(expr);
-                free(expr);
-                free(parseable_expr);
+                xfree(expr);
+                xfree(parseable_expr);
                 return rb_expr;
             }
         }
     }
 
-    free(expr);
-    free(parseable_expr);
-    free_memory_for_file(filebuf, relevant_lines_n);
+    xfree(expr);
+    xfree(parseable_expr);
 
     return Qnil;
 }
@@ -297,47 +358,58 @@ strnprep(char *s, const char *t, size_t len)
 }
 
 static VALUE
-find_comment(char **filebuf[], const unsigned method_location,
-             const unsigned relevant_lines_n)
+find_comment(struct filebuf *filebuf)
 {
-    char comment[COMMENT_SIZE];
+    size_t comment_len;
+    size_t current_line_len;
+    size_t future_bufsize;
+    char *current_line = NULL;
+    VALUE rb_comment;
+
+    unsigned long bufsize = COMMENT_SIZE;
+    char *comment = ALLOC_N(char, COMMENT_SIZE);
     comment[0] = '\0';
 
-    int i = method_location - 2;
+    int i = filebuf->method_location - 2;
 
-    while ((*filebuf)[i][0] == '\n') {
+    while (filebuf->lines[i][0] == '\n') {
         i--;
         continue;
     }
 
-    if (!is_comment((*filebuf)[i], strlen((*filebuf)[i]))) {
+    if (!is_comment(filebuf->lines[i], strlen(filebuf->lines[i]))) {
         return rb_str_new("", 0);
     } else {
-        while (is_comment((*filebuf)[i],  strlen((*filebuf)[i]))) {
-            strnprep(comment, (*filebuf)[i],  strlen((*filebuf)[i]));
+        while ((current_line = filebuf->lines[i]) &&
+               is_comment(current_line,  (current_line_len = strlen(current_line)))) {
+            comment_len = strlen(comment);
+            future_bufsize = comment_len + current_line_len;
+
+            if (future_bufsize >= bufsize) {
+                bufsize = future_bufsize + COMMENT_SIZE + 1;
+                realloc_comment(&comment, bufsize);
+            }
+            strnprep(comment, current_line, current_line_len);
             i--;
         }
 
-        return rb_str_new2(comment);
+        rb_comment = rb_str_new2(comment);
+        xfree(comment);
+        return rb_comment;
     }
 
-    free_memory_for_file(filebuf, relevant_lines_n);
+    xfree(comment);
+    free_memory_for_file(&filebuf->lines, filebuf->relevant_lines);
     return Qnil;
 }
 
 static char **
 allocate_memory_for_file(void)
 {
-    char **file;
-
-    if ((file = malloc(sizeof(*file) * MAXLINES)) == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate memory");
-    }
+    char **file = ALLOC_N(char *, MAXLINES);
 
     for (int i = 0; i < MAXLINES; i++) {
-        if ((file[i] = malloc(sizeof(char) * MAXLINELEN)) == NULL) {
-            rb_raise(rb_eNoMemError, "failed to allocate memory");
-        };
+        file[i] = ALLOC_N(char, MAXLINELEN);
     }
 
     return file;
@@ -349,78 +421,94 @@ free_memory_for_file(char **file[], const unsigned relevant_lines_n)
     int lines_to_free = relevant_lines_n >= MAXLINES ? relevant_lines_n : MAXLINES;
 
     for (int i = 0; i < lines_to_free; i++) {
-        free((*file)[i]);
+        xfree((*file)[i]);
     }
 
-    free(*file);
+    xfree(*file);
+}
+
+static VALUE
+raise_if_nil_safe(VALUE args)
+{
+    struct retval *retval = (struct retval *) args;
+    raise_if_nil(retval->val, retval->method_name);
+
+    return Qnil;
 }
 
 static void
-check_if_nil(VALUE val, VALUE name)
+raise_if_nil(VALUE val, VALUE method_name)
 {
     if (NIL_P(val)) {
         rb_raise(rb_eSourceNotFoundError, "could not locate source for %s",
-                 RSTRING_PTR(rb_sym2str(name)));
+                 RSTRING_PTR(rb_sym2str(method_name)));
     }
 }
 
-static VALUE
-mMethodExtensions_source(VALUE self)
+static void
+filebuf_init(VALUE self, struct filebuf *filebuf)
 {
     VALUE source_location = rb_funcall(self, rb_intern("source_location"), 0);
     VALUE name = rb_funcall(self, rb_intern("name"), 0);
 
-    check_if_nil(source_location, name);
+    raise_if_nil(source_location, name);
 
     VALUE rb_filename = RARRAY_AREF(source_location, 0);
     VALUE rb_method_location = RARRAY_AREF(source_location, 1);
 
-    check_if_nil(rb_filename, name);
-    check_if_nil(rb_method_location, name);
+    raise_if_nil(rb_filename, name);
+    raise_if_nil(rb_method_location, name);
 
-    const char *filename = RSTRING_PTR(rb_filename);
-    const unsigned method_location = FIX2INT(rb_method_location);
+    filebuf->filename = RSTRING_PTR(rb_filename);
+    filebuf->method_location = FIX2INT(rb_method_location);
+    filebuf->method_name = name;
+    filebuf->lines = allocate_memory_for_file();
+}
 
-    char **filebuf = allocate_memory_for_file();
-    const unsigned relevant_lines_n = read_lines_after(method_location,
-                                                       filename, &filebuf);
-    VALUE source = find_source(&filebuf, relevant_lines_n);
+static void
+free_filebuf(VALUE val, struct filebuf *filebuf)
+{
+    int failed;
+    struct retval retval = {val, filebuf->method_name};
 
-    check_if_nil(source, name);
-    free_memory_for_file(&filebuf, relevant_lines_n);
+    rb_protect(raise_if_nil_safe, (VALUE) &retval, &failed);
+    free_memory_for_file(&filebuf->lines, filebuf->relevant_lines);
 
-    return source;
+    if (failed) {
+        rb_jump_tag(failed);
+    }
 }
 
 static VALUE
-mMethodExtensions_comment(VALUE self)
+mMethodExtensions_source(VALUE self)
 {
-    VALUE source_location = rb_funcall(self, rb_intern("source_location"), 0);
-    VALUE name = rb_funcall(self, rb_intern("name"), 0);
+    struct filebuf filebuf;
 
-    check_if_nil(source_location, name);
+    filebuf_init(self, &filebuf);
+    read_lines_after(&filebuf);
 
-    VALUE rb_filename = RARRAY_AREF(source_location, 0);
-    VALUE rb_method_location = RARRAY_AREF(source_location, 1);
+    VALUE source = find_source(&filebuf);
+
+    free_filebuf(source, &filebuf);
+
+    return source;
+}
 
-    check_if_nil(rb_filename, name);
-    check_if_nil(rb_method_location, name);
+static VALUE
+mMethodExtensions_comment(VALUE self)
+{
+    struct filebuf filebuf;
 
-    const char *filename = RSTRING_PTR(rb_filename);
-    const unsigned method_location = FIX2INT(rb_method_location);
+    filebuf_init(self, &filebuf);
+    read_lines_before(&filebuf);
 
-    char **filebuf = allocate_memory_for_file();
-    const unsigned relevant_lines_n = read_lines_before(method_location,
-                                                        filename, &filebuf);
-    VALUE comment = find_comment(&filebuf, method_location, relevant_lines_n);
+    VALUE comment = find_comment(&filebuf);
 
-    check_if_nil(comment, name);
-    free_memory_for_file(&filebuf, relevant_lines_n);
+    free_filebuf(comment, &filebuf);
 
     return comment;
 }
 
-
 void Init_fast_method_source(void)
 {
     VALUE rb_mFastMethodSource = rb_define_module_under(rb_cObject, "FastMethodSource");

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_method_source
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kyrylo Silin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-09 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,7 +80,6 @@ files:
 - VERSION
 - ext/fast_method_source/extconf.rb
 - ext/fast_method_source/fast_method_source.c
-- ext/fast_method_source/fast_method_source.h
 - ext/fast_method_source/node.h
 - lib/fast_method_source.rb
 - lib/fast_method_source/core_ext.rb

data/ext/fast_method_source/fast_method_source.h

@@ -1,53 +0,0 @@
-#define _XOPEN_SOURCE 700
-#include <stdio.h>
-#include <stdlib.h>
-#include <ruby.h>
-#include "node.h"
-
-#ifdef _WIN32
-#include <io.h>
-static const char *null_filename = "NUL";
-#define DUP(fd) _dup(fd)
-#define DUP2(fd, newfd) _dup2(fd, newfd)
-#else
-#include <unistd.h>
-static const char *null_filename = "/dev/null";
-#define DUP(fd) dup(fd)
-#define DUP2(fd, newfd) dup2(fd, newfd)
-#endif
-
-#define MAXLINES 1000
-#define MAXLINELEN 300
-#define COMMENT_SIZE 15000
-
-typedef struct {
-    int forward  : 1;
-    int backward : 1;
-} read_order;
-
-static unsigned read_lines(read_order order, const unsigned method_location,
-                           const char *filename, char **filebuf[]);
-static unsigned read_lines_before(const unsigned method_location,
-                                  const char *filename, char **filebuf[]);
-static unsigned read_lines_after(const unsigned method_location,
-                                 const char *filename, char **filebuf[]);
-static void reallocate_filebuf(char **lines[], unsigned rl_len);
-static void reallocate_linebuf(char **linebuf, const unsigned cl_len);
-static VALUE find_source(char **filebuf[], const unsigned relevant_lines_n);
-static VALUE find_comment(char **filebuf[], const unsigned relevant_lines_n,
-                          const unsigned method_location);
-static VALUE mMethodExtensions_source(VALUE self);
-static NODE *parse_expr(VALUE rb_str);
-static NODE *parse_with_silenced_stderr(VALUE rb_str);
-static void filter_interp(char *line);
-static char **allocate_memory_for_file(void);
-static void free_memory_for_file(char **file[], const unsigned relevant_lines_n);
-static int contains_end_kw(const char *line);
-static int is_comment(const char *line, const size_t line_len);
-static int is_static_definition(const char *line);
-static int is_accessor(const char *line);
-static int is_dangling_literal_end(const char *line);
-static int is_dangling_literal_begin(const char *line);
-static void strnprep(char *s, const char *t, size_t len);
-
-#define SAFE_CHAR 'z'