From 28db4ce2840d74f06b55c1e2c7c48f228708fb1d Mon Sep 17 00:00:00 2001

From: Martin Milata <mmilata@redhat.com>

Date: Wed, 28 Jan 2015 16:11:15 +0100

Subject: [PATCH] Add support for Ruby report type

Related: #1334604

Signed-off-by: Martin Milata <mmilata@redhat.com>

---

 include/Makefile.am                          |   5 +

 include/report_type.h                        |   1 +

 include/ruby/frame.h                         |  99 ++++++

 include/ruby/stacktrace.h                    |  73 ++++

 lib/Makefile.am                              |   2 +

 lib/abrt.c                                   |  31 ++

 lib/generic_frame.c                          |   1 +

 lib/generic_frame.h                          |   3 +-

 lib/generic_stacktrace.c                     |   1 +

 lib/generic_stacktrace.h                     |   3 +-

 lib/generic_thread.c                         |   1 +

 lib/generic_thread.h                         |   3 +-

 lib/report.c                                 |   3 +

 lib/ruby_frame.c                             | 504 +++++++++++++++++++++++++++

 lib/ruby_stacktrace.c                        | 387 ++++++++++++++++++++

 tests/Makefile.am                            |   3 +

 tests/ruby_frame.at                          | 285 +++++++++++++++

 tests/ruby_stacktrace.at                     | 316 +++++++++++++++++

 tests/ruby_stacktraces/ruby-01               |  23 ++

 tests/ruby_stacktraces/ruby-01-expected-json |  97 ++++++

 tests/ruby_stacktraces/ruby-02               |  37 ++

 tests/ruby_stacktraces/ruby-02-expected-json | 158 +++++++++

 tests/ruby_stacktraces/ruby-03               |   4 +

 tests/ruby_stacktraces/ruby-03-expected-json |  19 +

 tests/ruby_stacktraces/ruby-04               |  39 +++

 tests/ruby_stacktraces/ruby-04-expected-json | 166 +++++++++

 tests/testsuite.at                           |   2 +

 27 files changed, 2263 insertions(+), 3 deletions(-)

 create mode 100644 include/ruby/frame.h

 create mode 100644 include/ruby/stacktrace.h

 create mode 100644 lib/ruby_frame.c

 create mode 100644 lib/ruby_stacktrace.c

 create mode 100644 tests/ruby_frame.at

 create mode 100644 tests/ruby_stacktrace.at

 create mode 100644 tests/ruby_stacktraces/ruby-01

 create mode 100644 tests/ruby_stacktraces/ruby-01-expected-json

 create mode 100644 tests/ruby_stacktraces/ruby-02

 create mode 100644 tests/ruby_stacktraces/ruby-02-expected-json

 create mode 100644 tests/ruby_stacktraces/ruby-03

 create mode 100644 tests/ruby_stacktraces/ruby-03-expected-json

 create mode 100644 tests/ruby_stacktraces/ruby-04

 create mode 100644 tests/ruby_stacktraces/ruby-04-expected-json

diff --git a/include/Makefile.am b/include/Makefile.am

index f72ec66..bcffe31 100644

--- a/include/Makefile.am

+++ b/include/Makefile.am

@@ -49,3 +49,8 @@ pythonheadersdir = $(includedir)/satyr/python

 pythonheaders_HEADERS = \

 	python/frame.h \

 	python/stacktrace.h

+

+rubyheadersdir = $(includedir)/satyr/ruby

+rubyheaders_HEADERS = \

+	ruby/frame.h \

+	ruby/stacktrace.h

diff --git a/include/report_type.h b/include/report_type.h

index a51620d..0d411ee 100644

--- a/include/report_type.h

+++ b/include/report_type.h

@@ -32,6 +32,7 @@ enum sr_report_type

     SR_REPORT_KERNELOOPS,

     SR_REPORT_JAVA,

     SR_REPORT_GDB,

+    SR_REPORT_RUBY,

     /* Keep this the last entry. */

     SR_REPORT_NUM

diff --git a/include/ruby/frame.h b/include/ruby/frame.h

new file mode 100644

index 0000000..ffc3c67

--- /dev/null

+++ b/include/ruby/frame.h

@@ -0,0 +1,99 @@

+/*

+    ruby_frame.h

+

+    Copyright (C) 2015  ABRT Team

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#ifndef SATYR_RUBY_FRAME_H

+#define SATYR_RUBY_FRAME_H

+

+/**

+ * @file

+ * @brief Ruby frame structure and related routines.

+ */

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#include "../report_type.h"

+#include <stdbool.h>

+#include <stdint.h>

+

+struct sr_location;

+struct sr_strbuf;

+struct sr_json_value;

+

+struct sr_ruby_frame

+{

+    enum sr_report_type type;

+

+    char *file_name;

+

+    uint32_t file_line;

+

+    bool special_function;

+

+    char *function_name;

+

+    uint32_t block_level;

+

+    uint32_t rescue_level;

+

+    struct sr_ruby_frame *next;

+};

+

+struct sr_ruby_frame *

+sr_ruby_frame_new();

+

+void

+sr_ruby_frame_init(struct sr_ruby_frame *frame);

+

+void

+sr_ruby_frame_free(struct sr_ruby_frame *frame);

+

+struct sr_ruby_frame *

+sr_ruby_frame_dup(struct sr_ruby_frame *frame, bool siblings);

+

+int

+sr_ruby_frame_cmp(struct sr_ruby_frame *frame1, struct sr_ruby_frame *frame2);

+

+int

+sr_ruby_frame_cmp_distance(struct sr_ruby_frame *frame1,

+                           struct sr_ruby_frame *frame2);

+

+struct sr_ruby_frame *

+sr_ruby_frame_append(struct sr_ruby_frame *dest,

+                     struct sr_ruby_frame *item);

+

+struct sr_ruby_frame *

+sr_ruby_frame_parse(const char **input, struct sr_location *location);

+

+char *

+sr_ruby_frame_to_json(struct sr_ruby_frame *frame);

+

+struct sr_ruby_frame *

+sr_ruby_frame_from_json(struct sr_json_value *root, char **error_message);

+

+void

+sr_ruby_frame_append_to_str(struct sr_ruby_frame *frame, struct sr_strbuf *dest);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/include/ruby/stacktrace.h b/include/ruby/stacktrace.h

new file mode 100644

index 0000000..caa3e0b

--- /dev/null

+++ b/include/ruby/stacktrace.h

@@ -0,0 +1,73 @@

+/*

+    ruby_stacktrace.h

+

+    Copyright (C) 2015  ABRT Team

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#ifndef SATYR_RUBY_STACKTRACE_H

+#define SATYR_RUBY_STACKTRACE_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#include "../report_type.h"

+#include <stdint.h>

+

+struct sr_ruby_frame;

+struct sr_location;

+struct sr_json_value;

+

+struct sr_ruby_stacktrace

+{

+    enum sr_report_type type;

+

+    char *exception_name;

+

+    struct sr_ruby_frame *frames;

+};

+

+struct sr_ruby_stacktrace *

+sr_ruby_stacktrace_new();

+

+void

+sr_ruby_stacktrace_init(struct sr_ruby_stacktrace *stacktrace);

+

+void

+sr_ruby_stacktrace_free(struct sr_ruby_stacktrace *stacktrace);

+

+struct sr_ruby_stacktrace *

+sr_ruby_stacktrace_dup(struct sr_ruby_stacktrace *stacktrace);

+

+struct sr_ruby_stacktrace *

+sr_ruby_stacktrace_parse(const char **input,

+                         struct sr_location *location);

+

+char *

+sr_ruby_stacktrace_get_reason(struct sr_ruby_stacktrace *stacktrace);

+

+char *

+sr_ruby_stacktrace_to_json(struct sr_ruby_stacktrace *stacktrace);

+

+struct sr_ruby_stacktrace *

+sr_ruby_stacktrace_from_json(struct sr_json_value *root, char **error_message);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

diff --git a/lib/Makefile.am b/lib/Makefile.am

index f798347..26016f2 100644

--- a/lib/Makefile.am

+++ b/lib/Makefile.am

@@ -57,6 +57,8 @@ libsatyr_conv_la_SOURCES = \

 	python_stacktrace.c \

 	report.c \

 	rpm.c \

+	ruby_frame.c \

+	ruby_stacktrace.c \

 	sha1.c \

 	strbuf.c \

 	unstrip.c \

diff --git a/lib/abrt.c b/lib/abrt.c

index 4599e2c..a07d44a 100644

--- a/lib/abrt.c

+++ b/lib/abrt.c

@@ -30,6 +30,7 @@

 #include "python/stacktrace.h"

 #include "koops/stacktrace.h"

 #include "java/stacktrace.h"

+#include "ruby/stacktrace.h"

 #include "json.h"

 #include "location.h"

 #include <stdio.h>

@@ -567,6 +568,34 @@ sr_abrt_report_from_dir(const char *directory,

         }

     }

+    /* Ruby stacktrace. */

+    if (report->report_type == SR_REPORT_RUBY)

+    {

+        char *backtrace_contents = file_contents(directory, "backtrace",

+                                                 error_message);

+        if (!backtrace_contents)

+        {

+            sr_report_free(report);

+            return NULL;

+        }

+

+        /* Parse the Ruby stacktrace. */

+        struct sr_location location;

+        sr_location_init(&location);

+        const char *contents_pointer = backtrace_contents;

+        report->stacktrace = (struct sr_stacktrace *)sr_ruby_stacktrace_parse(

+            &contents_pointer,

+            &location);

+

+        free(backtrace_contents);

+        if (!report->stacktrace)

+        {

+            *error_message = sr_location_to_string(&location);

+            sr_report_free(report);

+            return NULL;

+        }

+    }

+

     return report;

 }

@@ -581,6 +610,8 @@ sr_abrt_type_from_analyzer(const char *analyzer)

         return SR_REPORT_KERNELOOPS;

     else if (0 == strncmp(analyzer, "Java", 4))

         return SR_REPORT_JAVA;

+    else if (0 == strncmp(analyzer, "Ruby", 4))

+        return SR_REPORT_RUBY;

     return SR_REPORT_INVALID;

 }

diff --git a/lib/generic_frame.c b/lib/generic_frame.c

index eb644b5..d5512c9 100644

--- a/lib/generic_frame.c

+++ b/lib/generic_frame.c

@@ -34,6 +34,7 @@ static struct frame_methods* dtable[SR_REPORT_NUM] =

     [SR_REPORT_KERNELOOPS] = &koops_frame_methods,

     [SR_REPORT_JAVA] = &java_frame_methods,

     [SR_REPORT_GDB] = &gdb_frame_methods,

+    [SR_REPORT_RUBY] = &ruby_frame_methods,

 };

 void

diff --git a/lib/generic_frame.h b/lib/generic_frame.h

index a61626d..e9f392d 100644

--- a/lib/generic_frame.h

+++ b/lib/generic_frame.h

@@ -48,7 +48,8 @@ struct frame_methods

 };

 extern struct frame_methods core_frame_methods, python_frame_methods,

-       koops_frame_methods, gdb_frame_methods, java_frame_methods;

+       koops_frame_methods, gdb_frame_methods, java_frame_methods,

+       ruby_frame_methods;

 void

 frame_append_bthash_text(struct sr_frame *frame, enum sr_bthash_flags flags,

diff --git a/lib/generic_stacktrace.c b/lib/generic_stacktrace.c

index feb1dbc..f98a482 100644

--- a/lib/generic_stacktrace.c

+++ b/lib/generic_stacktrace.c

@@ -40,6 +40,7 @@ static struct stacktrace_methods* dtable[SR_REPORT_NUM] =

     [SR_REPORT_KERNELOOPS] = &koops_stacktrace_methods,

     [SR_REPORT_JAVA] = &java_stacktrace_methods,

     [SR_REPORT_GDB] = &gdb_stacktrace_methods,

+    [SR_REPORT_RUBY] = &ruby_stacktrace_methods,

 };

 /* In case stacktrace type supports only one thread, return the stacktrace itself. */

diff --git a/lib/generic_stacktrace.h b/lib/generic_stacktrace.h

index 8e3d629..6e1a444 100644

--- a/lib/generic_stacktrace.h

+++ b/lib/generic_stacktrace.h

@@ -55,7 +55,8 @@ struct stacktrace_methods

 };

 extern struct stacktrace_methods core_stacktrace_methods, python_stacktrace_methods,

-       koops_stacktrace_methods, gdb_stacktrace_methods, java_stacktrace_methods;

+       koops_stacktrace_methods, gdb_stacktrace_methods, java_stacktrace_methods,

+       ruby_stacktrace_methods;

 /* Macros to generate accessors for the "threads" member. */

 #define DEFINE_THREADS_FUNC(name, concrete_t) \

diff --git a/lib/generic_thread.c b/lib/generic_thread.c

index 59fff1b..16748b5 100644

--- a/lib/generic_thread.c

+++ b/lib/generic_thread.c

@@ -131,6 +131,7 @@ static struct thread_methods* dtable[SR_REPORT_NUM] =

     [SR_REPORT_KERNELOOPS] = &koops_thread_methods,

     [SR_REPORT_JAVA] = &java_thread_methods,

     [SR_REPORT_GDB] = &gdb_thread_methods,

+    [SR_REPORT_RUBY] = &ruby_thread_methods,

 };

 struct sr_frame *

diff --git a/lib/generic_thread.h b/lib/generic_thread.h

index 005e5ac..8635ad2 100644

--- a/lib/generic_thread.h

+++ b/lib/generic_thread.h

@@ -56,7 +56,8 @@ struct thread_methods

 };

 extern struct thread_methods core_thread_methods, python_thread_methods,

-       koops_thread_methods, gdb_thread_methods, java_thread_methods;

+       koops_thread_methods, gdb_thread_methods, java_thread_methods,

+       ruby_thread_methods;

 /* Macros to generate accessors for the "frames" member. */

 #define DEFINE_FRAMES_FUNC(name, concrete_t) \

diff --git a/lib/report.c b/lib/report.c

index 411df64..614b213 100644

--- a/lib/report.c

+++ b/lib/report.c

@@ -42,6 +42,7 @@ static char *report_types[] =

     [SR_REPORT_KERNELOOPS] = "kerneloops",

     [SR_REPORT_JAVA] = "java",

     [SR_REPORT_GDB] = "gdb",

+    [SR_REPORT_RUBY] = "ruby",

     NULL

 };

@@ -189,6 +190,7 @@ sr_report_to_json(struct sr_report *report)

     case SR_REPORT_PYTHON:

     case SR_REPORT_KERNELOOPS:

     case SR_REPORT_JAVA:

+    case SR_REPORT_RUBY:

         report_type = sr_report_type_to_string(report->report_type);

         reason = sr_stacktrace_get_reason(report->stacktrace);

         break;

@@ -383,6 +385,7 @@ sr_report_from_json(struct sr_json_value *root, char **error_message)

         case SR_REPORT_PYTHON:

         case SR_REPORT_KERNELOOPS:

         case SR_REPORT_JAVA:

+        case SR_REPORT_RUBY:

             report->stacktrace = sr_stacktrace_from_json(report->report_type, problem, error_message);

             break;

         default:

diff --git a/lib/ruby_frame.c b/lib/ruby_frame.c

new file mode 100644

index 0000000..9a9a317

--- /dev/null

+++ b/lib/ruby_frame.c

@@ -0,0 +1,504 @@

+/*

+    ruby_frame.c

+

+    Copyright (C) 2015  Red Hat, Inc.

+

+    This program is free software; you can redistribute it and/or modify

+    it under the terms of the GNU General Public License as published by

+    the Free Software Foundation; either version 2 of the License, or

+    (at your option) any later version.

+

+    This program is distributed in the hope that it will be useful,

+    but WITHOUT ANY WARRANTY; without even the implied warranty of

+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+    GNU General Public License for more details.

+

+    You should have received a copy of the GNU General Public License along

+    with this program; if not, write to the Free Software Foundation, Inc.,

+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+*/

+#include "ruby/frame.h"

+#include "utils.h"

+#include "location.h"

+#include "strbuf.h"

+#include "json.h"

+#include "generic_frame.h"

+#include "thread.h"

+#include "stacktrace.h"

+#include "internal_utils.h"

+#include <string.h>

+#include <inttypes.h>

+#include <ctype.h>

+

+/* Method table */

+

+static void

+ruby_append_bthash_text(struct sr_ruby_frame *frame, enum sr_bthash_flags flags,

+                          struct sr_strbuf *strbuf);

+static void

+ruby_append_duphash_text(struct sr_ruby_frame *frame, enum sr_duphash_flags flags,

+                           struct sr_strbuf *strbuf);

+

+DEFINE_NEXT_FUNC(ruby_next, struct sr_frame, struct sr_ruby_frame)

+DEFINE_SET_NEXT_FUNC(ruby_set_next, struct sr_frame, struct sr_ruby_frame)

+

+struct frame_methods ruby_frame_methods =

+{

+    .append_to_str = (append_to_str_fn_t) sr_ruby_frame_append_to_str,

+    .next = (next_frame_fn_t) ruby_next,

+    .set_next = (set_next_frame_fn_t) ruby_set_next,

+    .cmp = (frame_cmp_fn_t) sr_ruby_frame_cmp,

+    .cmp_distance = (frame_cmp_fn_t) sr_ruby_frame_cmp_distance,

+    .frame_append_bthash_text =

+        (frame_append_bthash_text_fn_t) ruby_append_bthash_text,

+    .frame_append_duphash_text =

+        (frame_append_duphash_text_fn_t) ruby_append_duphash_text,

+    .frame_free = (frame_free_fn_t) sr_ruby_frame_free,

+};

+

+/* Public functions */

+

+struct sr_ruby_frame *

+sr_ruby_frame_new()

+{

+    struct sr_ruby_frame *frame =

+        sr_malloc(sizeof(struct sr_ruby_frame));

+

+    sr_ruby_frame_init(frame);

+    return frame;

+}

+

+void

+sr_ruby_frame_init(struct sr_ruby_frame *frame)

+{

+    memset(frame, 0, sizeof(struct sr_ruby_frame));

+    frame->type = SR_REPORT_RUBY;

+}

+

+void

+sr_ruby_frame_free(struct sr_ruby_frame *frame)

+{

+    if (!frame)

+        return;

+

+    free(frame->file_name);

+    free(frame->function_name);

+    free(frame);

+}

+

+struct sr_ruby_frame *

+sr_ruby_frame_dup(struct sr_ruby_frame *frame, bool siblings)

+{

+    struct sr_ruby_frame *result = sr_ruby_frame_new();

+    memcpy(result, frame, sizeof(struct sr_ruby_frame));

+

+    /* Handle siblings. */

+    if (siblings)

+    {

+        if (result->next)

+            result->next = sr_ruby_frame_dup(result->next, true);

+    }

+    else

+        result->next = NULL; /* Do not copy that. */

+

+    /* Duplicate all strings. */

+    if (result->file_name)

+        result->file_name = sr_strdup(result->file_name);

+

+    if (result->function_name)

+        result->function_name = sr_strdup(result->function_name);

+

+    return result;

+}

+

+int

+sr_ruby_frame_cmp(struct sr_ruby_frame *frame1,

+                  struct sr_ruby_frame *frame2)

+{

+    /* function_name */

+    int function_name = sr_strcmp0(frame1->function_name,

+                                   frame2->function_name);

+    if (function_name != 0)

+        return function_name;

+

+    /* file_name */

+    int file_name = sr_strcmp0(frame1->file_name,

+                               frame2->file_name);

+    if (file_name != 0)

+        return file_name;

+

+    /* file_line */

+    int file_line = frame1->file_line - frame2->file_line;

+    if (file_line != 0)

+        return file_line;

+

+    /* special_function */

+    int special_function = frame1->special_function - frame2->special_function;

+    if (special_function != 0)

+        return special_function;

+

+    /* block_level */

+    int block_level = frame1->block_level - frame2->block_level;

+    if (block_level != 0)

+            return block_level;

+

+    /* rescue_level */

+    int rescue_level = frame1->rescue_level - frame2->rescue_level;

+    if (rescue_level != 0)

+            return rescue_level;

+

+    return 0;

+}

+

+int

+sr_ruby_frame_cmp_distance(struct sr_ruby_frame *frame1,

+                           struct sr_ruby_frame *frame2)

+{

+    /* function_name */

+    int function_name = sr_strcmp0(frame1->function_name,

+                                   frame2->function_name);

+    if (function_name != 0)

+        return function_name;

+

+    /* file_name */

+    int file_name = sr_strcmp0(frame1->file_name,

+                               frame2->file_name);

+    if (file_name != 0)

+        return file_name;

+

+    /* special_function */

+    int special_function = frame1->special_function - frame2->special_function;

+    if (special_function != 0)

+        return special_function;

+

+    return 0;

+}

+

+struct sr_ruby_frame *

+sr_ruby_frame_append(struct sr_ruby_frame *dest,

+                     struct sr_ruby_frame *item)

+{

+    if (!dest)

+        return item;

+

+    struct sr_ruby_frame *dest_loop = dest;

+    while (dest_loop->next)

+        dest_loop = dest_loop->next;

+

+    dest_loop->next = item;

+    return dest;

+}

+

+struct sr_ruby_frame *

+sr_ruby_frame_parse(const char **input,

+                    struct sr_location *location)

+{

+    const char *local_input = *input;

+    struct sr_ruby_frame *frame = sr_ruby_frame_new();

+

+    /* take everything before the backtick

+     * /usr/share/rubygems/rubygems/core_ext/kernel_require.rb:55:in `require'

+     * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

+     */

+    char *filename_lineno_in = NULL;

+    if (!sr_parse_char_cspan(&local_input, "`", &filename_lineno_in))

+    {

+        location->message = sr_strdup("Unable to find the '`' character "

+                                      "identifying the beginning of function name.");

+        goto fail;

+    }

+

+    size_t l = strlen(filename_lineno_in);

+    location->column += l;

+

+    char *p = filename_lineno_in + l;

+

+    /* /usr/share/rubygems/rubygems/core_ext/kernel_require.rb:55:in `require'

+     *                                                           ^^^^

+     */

+    p -= strlen(":in ");

+    if (p < filename_lineno_in || 0 != strcmp(":in ", p))

+    {

+        location->column -= strlen(":in ");

+        location->message = sr_strdup("Unable to find ':in ' preceding the "

+                                      "backtick character.");

+        goto fail;

+    }

+

+    /* Find the beginning of the line number. */

+    *p = '\0';

+    do {

+        p--;

+    } while (p >= filename_lineno_in && isdigit(*p));

+    p++;

+

+    /* /usr/share/rubygems/rubygems/core_ext/kernel_require.rb:55:in `require'

+     *                                                         ^^

+     */

+    char *p_copy = p;

+    int lineno_len = sr_parse_uint32((const char **)&p_copy, &frame->file_line);

+    if (lineno_len <= 0)

+    {

+        location->message = sr_strdup("Unable to find line number before ':in '");

+        goto fail;

+    }

+

+    /* /usr/share/rubygems/rubygems/core_ext/kernel_require.rb:55:in `require'

+     *                                                        ^

+     */

+    p--;

+    if (p < filename_lineno_in || *p != ':')

+    {

+        location->column -= lineno_len;

+        location->message = sr_strdup("Unable to fin the ':' character "

+                                      "preceding the line number");

+        goto fail;

+    }

+

+    /* Everything before the colon is the file name. */

+    *p = '\0';

+    frame->file_name = filename_lineno_in;

+    filename_lineno_in = NULL;

+

+    if(!sr_skip_char(&local_input, '`'))

+    {

+        location->message = sr_strdup("Unable to find the '`' character "

+                                      "identifying the beginning of function name.");

+        goto fail;

+    }

+

+    location->column++;

+

+    /* The part in quotes can look like:

+     * `rescue in rescue in block (3 levels) in func'

+     * parse the number of rescues and blocks

+     */

+    while (sr_skip_string(&local_input, "rescue in "))

+    {