openc3 5.0.6

data/ext/openc3/ext/packet/packet.c

@@ -0,0 +1,318 @@
+/*
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# 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 Affero General Public License for more details.
+*/
+
+/*
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+
+#include "../structure/structure.c"
+
+static VALUE cPacket = Qnil;
+static VALUE cPacketItem = Qnil;
+
+static ID id_method_class = 0;
+static ID id_method_target_name_equals = 0;
+static ID id_method_packet_name_equals = 0;
+static ID id_method_description_equals = 0;
+static ID id_method_upcase = 0;
+static ID id_method_clone = 0;
+static ID id_method_to_utf8 = 0;
+static ID id_method_clear = 0;
+
+static ID id_ivar_id_items = 0;
+static ID id_ivar_received_time = 0;
+static ID id_ivar_received_count = 0;
+static ID id_ivar_hazardous = 0;
+static ID id_ivar_hazardous_description = 0;
+static ID id_ivar_given_values = 0;
+static ID id_ivar_limits_items = 0;
+static ID id_ivar_processors = 0;
+static ID id_ivar_stale = 0;
+static ID id_ivar_limits_change_callback = 0;
+static ID id_ivar_read_conversion_cache = 0;
+static ID id_ivar_raw = 0;
+static ID id_ivar_messages_disabled = 0;
+static ID id_ivar_meta = 0;
+static ID id_ivar_hidden = 0;
+static ID id_ivar_disabled = 0;
+static ID id_ivar_target_name = 0;
+static ID id_ivar_packet_name = 0;
+static ID id_ivar_description = 0;
+static ID id_ivar_stored = 0;
+static ID id_ivar_extra = 0;
+
+/* Sets the target name this packet is associated with. Unidentified packets
+ * will have target name set to nil.
+ *
+ * @param target_name [String] Name of the target this packet is associated with */
+static VALUE target_name_equals(VALUE self, VALUE target_name)
+{
+  if (RTEST(target_name))
+  {
+    if (rb_funcall(target_name, id_method_class, 0) != rb_cString)
+    {
+      rb_raise(rb_eArgError, "target_name must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(target_name, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_target_name, rb_funcall(rb_funcall(target_name, id_method_upcase, 0), id_method_freeze, 0));
+  }
+  else
+  {
+    rb_ivar_set(self, id_ivar_target_name, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_target_name);
+}
+
+/* Sets the packet name. Unidentified packets will have packet name set to
+ * nil.
+ *
+ * @param packet_name [String] Name of the packet */
+static VALUE packet_name_equals(VALUE self, VALUE packet_name)
+{
+  if (RTEST(packet_name))
+  {
+    if (rb_funcall(packet_name, id_method_class, 0) != rb_cString)
+    {
+      rb_raise(rb_eArgError, "packet_name must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(packet_name, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_packet_name, rb_funcall(rb_funcall(packet_name, id_method_upcase, 0), id_method_freeze, 0));
+  }
+  else
+  {
+    rb_ivar_set(self, id_ivar_packet_name, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_packet_name);
+}
+
+/* Sets the description of the packet
+ *
+ * @param description [String] Description of the packet */
+static VALUE description_equals(VALUE self, VALUE description)
+{
+  if (RTEST(description))
+  {
+    if (rb_funcall(description, id_method_class, 0) != rb_cString)
+    {
+      rb_raise(rb_eArgError, "description must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(description, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_description, rb_funcall(rb_funcall(description, id_method_to_utf8, 0), id_method_freeze, 0));
+  }
+  else
+  {
+    rb_ivar_set(self, id_ivar_description, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_description);
+}
+
+/* Sets the received time of the packet
+ *
+ * @param received_time [Time] Time this packet was received */
+static VALUE received_time_equals(VALUE self, VALUE received_time)
+{
+  volatile VALUE read_conversion_cache = rb_ivar_get(self, id_ivar_read_conversion_cache);
+  if (RTEST(received_time))
+  {
+    if (rb_funcall(received_time, id_method_class, 0) != rb_cTime)
+    {
+      rb_raise(rb_eArgError, "received_time must be a Time but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_time, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_received_time, rb_funcall(rb_funcall(received_time, id_method_clone, 0), id_method_freeze, 0));
+  }
+  else
+  {
+    rb_ivar_set(self, id_ivar_received_time, Qnil);
+  }
+  if (RTEST(read_conversion_cache))
+  {
+    rb_funcall(read_conversion_cache, id_method_clear, 0);
+  }
+  return rb_ivar_get(self, id_ivar_received_time);
+}
+
+/* Sets the received count of the packet
+ *
+ * @param received_count [Integer] Number of times this packet has been
+ *   received */
+static VALUE received_count_equals(VALUE self, VALUE received_count)
+{
+  volatile VALUE read_conversion_cache = rb_ivar_get(self, id_ivar_read_conversion_cache);
+#ifdef RUBY_INTEGER_UNIFICATION /* Ruby 2.4.0 unified Fixnum and Bignum into Integer. This check allows the code to build pre- and post-2.4.0. */
+  if (rb_funcall(received_count, id_method_class, 0) != rb_cInteger)
+  {
+    rb_raise(rb_eArgError, "received_count must be an Integer but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_count, id_method_class, 0), id_method_to_s, 0)));
+  }
+#else
+  if ((rb_funcall(received_count, id_method_class, 0) != rb_cFixnum) && (rb_funcall(received_count, id_method_class, 0) != rb_cBignum))
+  {
+    rb_raise(rb_eArgError, "received_count must be an Integer but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_count, id_method_class, 0), id_method_to_s, 0)));
+  }
+#endif
+  rb_ivar_set(self, id_ivar_received_count, received_count);
+  if (RTEST(read_conversion_cache))
+  {
+    rb_funcall(read_conversion_cache, id_method_clear, 0);
+  }
+  return rb_ivar_get(self, id_ivar_received_count);
+}
+
+/* Creates a new packet by initalizing the attributes.
+ *
+ * @param target_name [String] Name of the target this packet is associated with
+ * @param packet_name [String] Name of the packet
+ * @param default_endianness [Symbol] One of {BinaryAccessor::ENDIANNESS}
+ * @param description [String] Description of the packet
+ * @param buffer [String] String buffer to hold the packet data
+ * @param item_class [Class] Class used to instantiate items (Must be a
+ *   subclass of PacketItem)
+ */
+static VALUE packet_initialize(int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE target_name = Qnil;
+  volatile VALUE packet_name = Qnil;
+  volatile VALUE default_endianness = Qnil;
+  volatile VALUE description = Qnil;
+  volatile VALUE buffer = Qnil;
+  volatile VALUE item_class = Qnil;
+  volatile VALUE super_args[3] = {Qnil, Qnil, Qnil};
+
+  switch (argc)
+  {
+  case 2:
+    target_name = argv[0];
+    packet_name = argv[1];
+    default_endianness = symbol_BIG_ENDIAN;
+    description = Qnil;
+    buffer = Qnil;
+    item_class = cPacketItem;
+    break;
+  case 3:
+    target_name = argv[0];
+    packet_name = argv[1];
+    default_endianness = argv[2];
+    description = Qnil;
+    buffer = Qnil;
+    item_class = cPacketItem;
+    break;
+  case 4:
+    target_name = argv[0];
+    packet_name = argv[1];
+    default_endianness = argv[2];
+    description = argv[3];
+    buffer = Qnil;
+    item_class = cPacketItem;
+    break;
+  case 5:
+    target_name = argv[0];
+    packet_name = argv[1];
+    default_endianness = argv[2];
+    description = argv[3];
+    buffer = argv[4];
+    item_class = cPacketItem;
+    break;
+  case 6:
+    target_name = argv[0];
+    packet_name = argv[1];
+    default_endianness = argv[2];
+    description = argv[3];
+    buffer = argv[4];
+    item_class = argv[5];
+    break;
+  default:
+    /* Invalid number of arguments given */
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..6)", argc);
+    break;
+  };
+
+  super_args[0] = default_endianness;
+  super_args[1] = buffer;
+  super_args[2] = item_class;
+  rb_call_super(3, (VALUE *)super_args);
+  target_name_equals(self, target_name);
+  packet_name_equals(self, packet_name);
+  description_equals(self, description);
+  rb_ivar_set(self, id_ivar_received_time, Qnil);
+  rb_ivar_set(self, id_ivar_received_count, INT2FIX(0));
+  rb_ivar_set(self, id_ivar_id_items, Qnil);
+  rb_ivar_set(self, id_ivar_hazardous, Qfalse);
+  rb_ivar_set(self, id_ivar_hazardous_description, Qnil);
+  rb_ivar_set(self, id_ivar_given_values, Qnil);
+  rb_ivar_set(self, id_ivar_limits_items, Qnil);
+  rb_ivar_set(self, id_ivar_processors, Qnil);
+  rb_ivar_set(self, id_ivar_stale, Qtrue);
+  rb_ivar_set(self, id_ivar_limits_change_callback, Qnil);
+  rb_ivar_set(self, id_ivar_read_conversion_cache, Qnil);
+  rb_ivar_set(self, id_ivar_raw, Qnil);
+  rb_ivar_set(self, id_ivar_messages_disabled, Qfalse);
+  rb_ivar_set(self, id_ivar_meta, Qnil);
+  rb_ivar_set(self, id_ivar_hidden, Qfalse);
+  rb_ivar_set(self, id_ivar_disabled, Qfalse);
+  rb_ivar_set(self, id_ivar_stored, Qfalse);
+  rb_ivar_set(self, id_ivar_extra, Qnil);
+
+  return self;
+}
+
+/*
+ * Initialize all Packet methods
+ */
+void Init_packet(void)
+{
+  Init_structure();
+
+  id_method_class = rb_intern("class");
+  id_method_target_name_equals = rb_intern("target_name=");
+  id_method_packet_name_equals = rb_intern("packet_name=");
+  id_method_description_equals = rb_intern("description=");
+  id_method_upcase = rb_intern("upcase");
+  id_method_clone = rb_intern("clone");
+  id_method_to_utf8 = rb_intern("to_utf8");
+  id_method_clear = rb_intern("clear");
+
+  id_ivar_id_items = rb_intern("@id_items");
+  id_ivar_received_time = rb_intern("@received_time");
+  id_ivar_received_count = rb_intern("@received_count");
+  id_ivar_hazardous = rb_intern("@hazardous");
+  id_ivar_hazardous_description = rb_intern("@hazardous_description");
+  id_ivar_given_values = rb_intern("@given_values");
+  id_ivar_limits_items = rb_intern("@limits_items");
+  id_ivar_processors = rb_intern("@processors");
+  id_ivar_stale = rb_intern("@stale");
+  id_ivar_limits_change_callback = rb_intern("@limits_change_callback");
+  id_ivar_read_conversion_cache = rb_intern("@read_conversion_cache");
+  id_ivar_raw = rb_intern("@raw");
+  id_ivar_messages_disabled = rb_intern("@messages_disabled");
+  id_ivar_meta = rb_intern("@meta");
+  id_ivar_hidden = rb_intern("@hidden");
+  id_ivar_disabled = rb_intern("@disabled");
+  id_ivar_target_name = rb_intern("@target_name");
+  id_ivar_packet_name = rb_intern("@packet_name");
+  id_ivar_description = rb_intern("@description");
+  id_ivar_stored = rb_intern("@stored");
+  id_ivar_extra = rb_intern("@extra");
+
+  cPacket = rb_define_class_under(mOpenC3, "Packet", cStructure);
+  rb_define_method(cPacket, "initialize", packet_initialize, -1);
+  rb_define_method(cPacket, "packet_name=", packet_name_equals, 1);
+  rb_define_method(cPacket, "target_name=", target_name_equals, 1);
+  rb_define_method(cPacket, "description=", description_equals, 1);
+  rb_define_method(cPacket, "received_time=", received_time_equals, 1);
+  rb_define_method(cPacket, "received_count=", received_count_equals, 1);
+
+  cPacketItem = rb_define_class_under(mOpenC3, "PacketItem", cStructureItem);
+}

data/ext/openc3/ext/platform/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+  $CFLAGS << ' -O3'
+end
+if /gcc/.match?(CONFIG['CC'])
+  $CFLAGS << ' -g -Wall'
+  if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
+end
+
+create_makefile 'openc3/ext/platform'

data/ext/openc3/ext/platform/platform.c

@@ -0,0 +1,134 @@
+/*
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# 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 Affero General Public License for more details.
+*/
+
+/*
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+
+/* OpenC3 module reference */
+VALUE mOpenC3 = Qnil;
+
+/* SegFault class reference */
+VALUE cSegFault = Qnil;
+
+#ifdef _WIN32
+/* OpenC3 5 drops segfault catching support for running directly on Windows - Usually in linux containers */
+#else
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <sys/stat.h>
+
+/* Mark that this function does not return (it exits) to remove compiler warning */
+__attribute__((noreturn)) static void catch_sigsegv(int sig_num)
+{
+  const int FILENAME_LEN = 256;
+  char *openc3_log_dir = NULL;
+  time_t rawtime;
+  struct tm timeinfo;
+  struct tm *timeinfo_ptr;
+  struct stat stats;
+  char filename[FILENAME_LEN];
+  FILE *file = NULL;
+
+  signal(SIGSEGV, SIG_DFL);
+  signal(SIGILL, SIG_DFL);
+
+  openc3_log_dir = getenv("OPENC3_LOGS_DIR");
+  // If the OPENC3_LOGS_DIR env var isn't set or if it's too big set to "."
+  // NOTE: The filename buffer will be written to by snprintf which appends
+  // a null terminator so we have 1 less byte available minus the length
+  // of the fixed filename structure
+  if ((openc3_log_dir == NULL) || (strlen(openc3_log_dir) > (FILENAME_LEN - 1 - strlen("/YYYY_MM_DD_HH_MM_SS_segfault.txt"))))
+  {
+    openc3_log_dir = (char *)".";
+  }
+  // Validate that we can write to this directory
+  if (stat(openc3_log_dir, &stats) == 0)
+  {
+    if (!((stats.st_mode & W_OK) && S_ISDIR(stats.st_mode)))
+    {
+      openc3_log_dir = (char *)".";
+    }
+  }
+  else
+  {
+    openc3_log_dir = (char *)".";
+  }
+
+  time(&rawtime);
+  timeinfo_ptr = localtime_r(&rawtime, &timeinfo);
+  if (timeinfo_ptr == NULL)
+  {
+    // If localtime returns NULL we set our own and set to 1919 to make it interesting
+    strptime("1919-01-01 00:00:00", "%Y-%m-%d %H:%M:%S", &timeinfo);
+  }
+  snprintf(filename, FILENAME_LEN, "%s/%04u_%02u_%02u_%02u_%02u_%02u_segfault.txt",
+           openc3_log_dir,
+           1900 + timeinfo.tm_year,
+           1 + timeinfo.tm_mon,
+           timeinfo.tm_mday,
+           timeinfo.tm_hour,
+           timeinfo.tm_min,
+           timeinfo.tm_sec);
+
+  // Fortify warns about Path Manipulation here. We explictly allow this to let
+  // segfault files be written to a directory of their choosing.
+  // The input is validated above for length and to ensure it is a writable directory.
+  // If the checks fail the directory is set to the current directory without additional info.
+  file = freopen(filename, "a", stderr);
+  /* Using file removes a warning */
+  if (file)
+  {
+    rb_bug("OpenC3 caught segfault");
+  }
+  else
+  {
+    rb_bug("OpenC3 caught segfault");
+  }
+}
+#endif
+
+/* NOTE: Uncomment and rebuild for testing the handler */
+// static VALUE segfault(VALUE self)
+// {
+//   char *a = 0;
+//   *a = 50;
+//   return Qnil;
+// }
+
+/*
+ * Initialize methods for Platform specific C code
+ */
+void Init_platform(void)
+{
+#ifdef _WIN32
+  /* Only supprt linux segfault catching */
+#else
+  signal(SIGSEGV, catch_sigsegv);
+  signal(SIGILL, catch_sigsegv);
+#endif
+
+  /* NOTE: Uncomment and rebuild for testing the handler */
+  // mOpenC3 = rb_define_module("OpenC3");
+  // cSegFault = rb_define_class_under(mOpenC3, "SegFault", rb_cObject);
+  // rb_define_singleton_method(cSegFault, "segfault", segfault, 0);
+}

data/ext/openc3/ext/polynomial_conversion/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+  $CFLAGS << ' -O3'
+end
+if /gcc/.match?(CONFIG['CC'])
+  $CFLAGS << ' -Wall'
+  if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
+end
+
+create_makefile 'openc3/ext/polynomial_conversion'

data/ext/openc3/ext/polynomial_conversion/polynomial_conversion.c

@@ -0,0 +1,79 @@
+/*
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# 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 Affero General Public License for more details.
+*/
+
+/*
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+#include "math.h"
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+
+VALUE mOpenC3;
+VALUE cConversion;
+VALUE cPolynomialConversion;
+
+static ID id_ivar_coeffs = 0;
+static ID id_method_to_f = 0;
+
+/*
+ * Calling this method performs a polynomial conversion on the given value.
+ *
+ *   conversion.call(1, packet) #=> 2.5
+ */
+static VALUE polynomial_conversion_call(VALUE self, VALUE value, VALUE myself, VALUE buffer)
+{
+  int index = 0;
+  double converted = 0.0;
+  double raised_to_power = 1.0;
+  volatile VALUE coeffs = rb_ivar_get(self, id_ivar_coeffs);
+  long coeffs_length = RARRAY_LEN(coeffs);
+  double double_value = RFLOAT_VALUE(rb_funcall(value, id_method_to_f, 0));
+
+  /* Handle C0 */
+  double coeff = RFLOAT_VALUE(rb_ary_entry(coeffs, 0));
+  converted += coeff;
+
+  /* Handle Coefficients raised to a power */
+  for (index = 1; index < coeffs_length; index++)
+  {
+    raised_to_power *= double_value;
+    coeff = RFLOAT_VALUE(rb_ary_entry(coeffs, index));
+    converted += (coeff * raised_to_power);
+  }
+
+  return rb_float_new(converted);
+}
+
+/*
+ * Initialize methods for PolynomialConversion
+ */
+void Init_polynomial_conversion(void)
+{
+  id_ivar_coeffs = rb_intern("@coeffs");
+  id_method_to_f = rb_intern("to_f");
+
+  mOpenC3 = rb_define_module("OpenC3");
+  rb_require("openc3/conversions/conversion");
+  cConversion = rb_const_get(mOpenC3, rb_intern("Conversion"));
+  cPolynomialConversion = rb_define_class_under(mOpenC3, "PolynomialConversion", cConversion);
+  rb_define_method(cPolynomialConversion, "call", polynomial_conversion_call, 3);
+}

data/ext/openc3/ext/string/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+  $CFLAGS << ' -O3'
+end
+if /gcc/.match?(CONFIG['CC'])
+  $CFLAGS << ' -Wall'
+  if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
+end
+
+create_makefile 'openc3/ext/string'

data/ext/openc3/ext/string/string.c

@@ -0,0 +1,63 @@
+/*
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# 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 Affero General Public License for more details.
+*/
+
+/*
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+
+/*
+ * Removes quotes from the given string if present.
+ *
+ *   "'quoted string'".remove_quotes #=> "quoted string"
+ */
+static VALUE string_remove_quotes(VALUE self)
+{
+  long length = RSTRING_LEN(self);
+  char *ptr = RSTRING_PTR(self);
+  char first_char = 0;
+  char last_char = 0;
+
+  if (length < 2)
+  {
+    return self;
+  }
+
+  first_char = ptr[0];
+  if ((first_char != 34) && (first_char != 39))
+  {
+    return self;
+  }
+
+  last_char = ptr[length - 1];
+  if (last_char != first_char)
+  {
+    return self;
+  }
+
+  return rb_str_new(ptr + 1, length - 2);
+}
+
+/*
+ * Initialize methods for String Core Ext
+ */
+void Init_string(void)
+{
+  rb_define_method(rb_cString, "remove_quotes", string_remove_quotes, 0);
+}