openc3 5.0.6

data/ext/mkrf_conf.rb

@@ -0,0 +1,49 @@
+# encoding: ascii-8bit
+
+# 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
+
+# This file gems specific to platform
+
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb'
+
+def gem_installed?(name, version = Gem::Requirement.default)
+  version = Gem::Requirement.create version unless version.is_a? Gem::Requirement
+  Gem::Specification.each.any? { |spec| name == spec.name and version.satisfied_by? spec.version }
+end
+
+begin
+  Gem::Command.build_args = ARGV
+rescue NoMethodError
+end
+inst = Gem::DependencyInstaller.new
+begin
+  if !/mswin|mingw|cygwin/i.match?(RbConfig::CONFIG['target_os'])
+    unless gem_installed?("ruby-termios", ">= 0.9")
+      STDOUT.puts "Attempting to install ruby-termios... If this fails please manually \"gem install ruby-termios\" and try again."
+      inst.install "ruby-termios", ">= 0.9"
+    end
+  end
+rescue
+  exit(1)
+end
+
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")   # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close

data/ext/openc3/ext/array/array.c

@@ -0,0 +1,122 @@
+/*
+# 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"
+
+static ID id_method_greater_than = 0;
+static ID id_method_less_than = 0;
+
+/*
+ * Returns the maximum value and its index
+ */
+static VALUE max_with_index(VALUE self)
+{
+  int index = 0;
+  long array_length = RARRAY_LEN(self);
+  int maximum_index = 0;
+  volatile VALUE value = Qnil;
+  volatile VALUE maximum = Qnil;
+  volatile VALUE return_value = Qnil;
+
+  if (array_length > 0)
+  {
+    maximum = rb_ary_entry(self, 0);
+    maximum_index = 0;
+
+    for (index = 1; index < array_length; index++)
+    {
+      value = rb_ary_entry(self, index);
+
+      if (rb_funcall(value, id_method_greater_than, 1, maximum) == Qtrue)
+      {
+        maximum = value;
+        maximum_index = index;
+      }
+    }
+  }
+
+  return_value = rb_ary_new2(2);
+  rb_ary_push(return_value, maximum);
+  if (NIL_P(maximum))
+  {
+    rb_ary_push(return_value, Qnil);
+  }
+  else
+  {
+    rb_ary_push(return_value, INT2FIX(maximum_index));
+  }
+  return return_value;
+}
+
+/*
+ * Returns the minimum value and its index
+ */
+static VALUE min_with_index(VALUE self)
+{
+  int index = 0;
+  long array_length = RARRAY_LEN(self);
+  int minimum_index = 0;
+  volatile VALUE value = Qnil;
+  volatile VALUE minimum = Qnil;
+  volatile VALUE return_value = Qnil;
+
+  if (array_length > 0)
+  {
+    minimum = rb_ary_entry(self, 0);
+    minimum_index = 0;
+
+    for (index = 1; index < array_length; index++)
+    {
+      value = rb_ary_entry(self, index);
+
+      if (rb_funcall(value, id_method_less_than, 1, minimum) == Qtrue)
+      {
+        minimum = value;
+        minimum_index = index;
+      }
+    }
+  }
+
+  return_value = rb_ary_new2(2);
+  rb_ary_push(return_value, minimum);
+  if (NIL_P(minimum))
+  {
+    rb_ary_push(return_value, Qnil);
+  }
+  else
+  {
+    rb_ary_push(return_value, INT2FIX(minimum_index));
+  }
+  return return_value;
+}
+
+/*
+ * Initialize methods for Array Core Ext
+ */
+void Init_array(void)
+{
+  id_method_greater_than = rb_intern(">");
+  id_method_less_than = rb_intern("<");
+
+  rb_define_method(rb_cArray, "max_with_index", max_with_index, 0);
+  rb_define_method(rb_cArray, "min_with_index", min_with_index, 0);
+}

data/ext/openc3/ext/array/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/array'

data/ext/openc3/ext/buffered_file/buffered_file.c

@@ -0,0 +1,198 @@
+/*
+# 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"
+
+VALUE mOpenC3 = Qnil;
+VALUE cBufferedFile = Qnil;
+static ID id_ivar_buffer = 0;
+static ID id_ivar_buffer_index = 0;
+static ID id_method_clear = 0;
+static ID id_method_slice_bang = 0;
+static ID id_method_to_s = 0;
+static ID id_method_pos = 0;
+static ID id_const_BUFFER_SIZE = 0;
+static ID id_const_ALL_RANGE = 0;
+static VALUE BUFFERED_FILE_SEEK_SET = Qnil;
+static VALUE BUFFERED_FILE_SEEK_CUR = Qnil;
+
+#define BUFFER_SIZE (1024 * 16)
+
+/* Initialize the BufferedFile.  Takes the same args as File */
+static VALUE buffered_file_initialize(int argc, VALUE *argv, VALUE self)
+{
+  rb_call_super(argc, argv);
+  rb_ivar_set(self, id_ivar_buffer, rb_str_new2(""));
+  rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(0));
+  return self;
+}
+
+/* Read using an internal buffer to avoid system calls */
+static VALUE buffered_file_read(VALUE self, VALUE arg_length)
+{
+  long length = FIX2INT(arg_length);
+  volatile VALUE buffer = rb_ivar_get(self, id_ivar_buffer);
+  long buffer_length = RSTRING_LEN(buffer);
+  long buffer_index = FIX2INT(rb_ivar_get(self, id_ivar_buffer_index));
+  volatile VALUE result = Qnil;
+  volatile VALUE super_arg = Qnil;
+
+  if (length <= (buffer_length - buffer_index))
+  {
+    /* Return part of the buffer without having to go to the OS */
+    result = rb_str_substr(buffer, buffer_index, length);
+    buffer_index += length;
+    rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(buffer_index));
+    return result;
+  }
+  else if (length > BUFFER_SIZE)
+  {
+    /* Reading more than our buffer */
+    if (buffer_length > 0)
+    {
+      if (buffer_index > 0)
+      {
+        rb_funcall(buffer, id_method_slice_bang, 1, rb_range_new(INT2FIX(0), INT2FIX(buffer_index - 1), Qfalse));
+        buffer_length = RSTRING_LEN(buffer);
+        buffer_index = 0;
+        rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(buffer_index));
+      }
+      super_arg = INT2FIX(length - buffer_length);
+      rb_str_append(buffer, rb_funcall(rb_call_super(1, (VALUE *)&super_arg), id_method_to_s, 0));
+      return rb_funcall(buffer, id_method_slice_bang, 1, rb_const_get(cBufferedFile, id_const_ALL_RANGE));
+    }
+    else
+    {
+      return rb_call_super(1, &arg_length);
+    }
+  }
+  else
+  {
+    /* Read into the buffer */
+    if (buffer_index > 0)
+    {
+      rb_funcall(buffer, id_method_slice_bang, 1, rb_range_new(INT2FIX(0), INT2FIX(buffer_index - 1), Qfalse));
+      buffer_length = RSTRING_LEN(buffer);
+      buffer_index = 0;
+      rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(buffer_index));
+    }
+    super_arg = INT2FIX(BUFFER_SIZE - buffer_length);
+    rb_str_append(buffer, rb_funcall(rb_call_super(1, (VALUE *)&super_arg), id_method_to_s, 0));
+    buffer_length = RSTRING_LEN(buffer);
+    if (buffer_length <= 0)
+    {
+      return Qnil;
+    }
+
+    if (length <= buffer_length)
+    {
+      result = rb_str_substr(buffer, buffer_index, length);
+      buffer_index += length;
+      rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(buffer_index));
+      return result;
+    }
+    else
+    {
+      return rb_funcall(buffer, id_method_slice_bang, 1, rb_const_get(cBufferedFile, id_const_ALL_RANGE));
+    }
+  }
+}
+
+/* Get the current file position */
+static VALUE buffered_file_pos(VALUE self)
+{
+  volatile VALUE parent_pos = rb_call_super(0, NULL);
+  long long ll_pos = NUM2LL(parent_pos);
+  long buffer_length = RSTRING_LEN(rb_ivar_get(self, id_ivar_buffer));
+  long buffer_index = FIX2INT(rb_ivar_get(self, id_ivar_buffer_index));
+  return LL2NUM(ll_pos - (long long)(buffer_length - buffer_index));
+}
+
+/* Seek to a given file position */
+static VALUE buffered_file_seek(int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE amount = Qnil;
+  volatile VALUE whence = Qnil;
+  long buffer_index = 0;
+  volatile VALUE super_args[2] = {Qnil, Qnil};
+
+  switch (argc)
+  {
+  case 1:
+    amount = argv[0];
+    whence = BUFFERED_FILE_SEEK_SET;
+    break;
+
+  case 2:
+    amount = argv[0];
+    whence = argv[1];
+    break;
+
+  default:
+    /* Invalid number of arguments given - let super handle */
+    return rb_call_super(argc, argv);
+  };
+
+  if (whence == BUFFERED_FILE_SEEK_CUR)
+  {
+    buffer_index = FIX2INT(rb_ivar_get(self, id_ivar_buffer_index)) + FIX2INT(amount);
+    if ((buffer_index >= 0) && (buffer_index < RSTRING_LEN(rb_ivar_get(self, id_ivar_buffer))))
+    {
+      rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(buffer_index));
+      return INT2FIX(0);
+    }
+    super_args[0] = rb_funcall(self, id_method_pos, 0);
+    super_args[1] = BUFFERED_FILE_SEEK_SET;
+    rb_call_super(2, (VALUE *)super_args);
+  }
+
+  rb_funcall(rb_ivar_get(self, id_ivar_buffer), id_method_clear, 0);
+  rb_ivar_set(self, id_ivar_buffer_index, INT2FIX(0));
+  return rb_call_super(argc, argv);
+}
+
+/*
+ * Initialize methods for BufferedFile
+ */
+void Init_buffered_file(void)
+{
+  id_ivar_buffer = rb_intern("@buffer");
+  id_ivar_buffer_index = rb_intern("@buffer_index");
+  id_method_clear = rb_intern("clear");
+  id_method_slice_bang = rb_intern("slice!");
+  id_method_to_s = rb_intern("to_s");
+  id_method_pos = rb_intern("pos");
+  id_const_BUFFER_SIZE = rb_intern("BUFFER_SIZE");
+  id_const_ALL_RANGE = rb_intern("ALL_RANGE");
+  BUFFERED_FILE_SEEK_SET = rb_const_get(rb_cIO, rb_intern("SEEK_SET"));
+  BUFFERED_FILE_SEEK_CUR = rb_const_get(rb_cIO, rb_intern("SEEK_CUR"));
+
+  mOpenC3 = rb_define_module("OpenC3");
+  cBufferedFile = rb_define_class_under(mOpenC3, "BufferedFile", rb_cFile);
+  rb_const_set(cBufferedFile, id_const_BUFFER_SIZE, INT2FIX(BUFFER_SIZE));
+  rb_const_set(cBufferedFile, id_const_ALL_RANGE, rb_range_new(INT2FIX(0), INT2FIX(-1), Qfalse));
+
+  rb_define_method(cBufferedFile, "initialize", buffered_file_initialize, -1);
+  rb_define_method(cBufferedFile, "read", buffered_file_read, 1);
+  rb_define_method(cBufferedFile, "seek", buffered_file_seek, -1);
+  rb_define_method(cBufferedFile, "pos", buffered_file_pos, 0);
+}

data/ext/openc3/ext/buffered_file/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/buffered_file'

data/ext/openc3/ext/config_parser/config_parser.c

@@ -0,0 +1,280 @@
+/*
+# 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"
+
+VALUE mOpenC3;
+VALUE cConfigParser;
+
+static ID id_cvar_progress_callback = 0;
+static ID id_ivar_line_number = 0;
+static ID id_ivar_keyword = 0;
+static ID id_ivar_parameters = 0;
+static ID id_ivar_line = 0;
+static ID id_method_readline = 0;
+static ID id_method_close = 0;
+static ID id_method_pos = 0;
+static ID id_method_call = 0;
+static ID id_method_scan = 0;
+static ID id_method_strip = 0;
+static ID id_method_to_s = 0;
+static ID id_method_upcase = 0;
+
+/*
+ * 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);
+}
+
+/*
+ * Method to read a line from the config file.
+ * This is a seperate method so that it can be protected.
+ */
+static VALUE config_parser_readline(VALUE io)
+{
+  return rb_funcall(io, id_method_readline, 0);
+}
+
+/*
+ * Iterates over each line of the io object and yields the keyword and parameters
+ */
+static VALUE parse_loop(VALUE self, VALUE io, VALUE yield_non_keyword_lines, VALUE remove_quotes, VALUE size, VALUE rx)
+{
+  int line_number = 0;
+  int result = 0;
+  long length = 0;
+  int index = 0;
+  double float_size = NUM2DBL(size);
+  volatile VALUE progress_callback = rb_cvar_get(cConfigParser, id_cvar_progress_callback);
+  volatile VALUE line = Qnil;
+  volatile VALUE data = Qnil;
+  volatile VALUE line_continuation = Qfalse;
+  volatile VALUE string = Qnil;
+  volatile VALUE array = rb_ary_new();
+  volatile VALUE first_item = Qnil;
+  volatile VALUE ivar_keyword = Qnil;
+  volatile VALUE ivar_parameters = rb_ary_new();
+  volatile VALUE ivar_line = Qnil;
+
+  rb_ivar_set(self, id_ivar_line_number, INT2FIX(0));
+  rb_ivar_set(self, id_ivar_keyword, ivar_keyword);
+  rb_ivar_set(self, id_ivar_parameters, ivar_parameters);
+  rb_ivar_set(self, id_ivar_line, ivar_line);
+
+  while (1)
+  {
+    line_number += 1;
+    rb_ivar_set(self, id_ivar_line_number, INT2FIX(line_number));
+
+    if (RTEST(progress_callback) && ((line_number % 10) == 0))
+    {
+      if (float_size > 0.0)
+      {
+        double float_pos = NUM2DBL(rb_funcall(io, id_method_pos, 0));
+        rb_funcall(progress_callback, id_method_call, 1, rb_float_new(float_pos / float_size));
+      }
+    }
+
+    line = rb_protect(config_parser_readline, io, &result);
+    if (result)
+    {
+      rb_set_errinfo(Qnil);
+      break;
+    }
+    line = rb_funcall(line, id_method_strip, 0);
+    data = rb_funcall(line, id_method_scan, 1, rx);
+    first_item = rb_funcall(rb_ary_entry(data, 0), id_method_to_s, 0);
+
+    if (RTEST(line_continuation))
+    {
+      rb_str_concat(ivar_line, line);
+      /* Carry over keyword and parameters */
+    }
+    else
+    {
+      ivar_line = line;
+      rb_ivar_set(self, id_ivar_line, ivar_line);
+      if ((RSTRING_LEN(first_item) == 0) || (RSTRING_PTR(first_item)[0] == '#'))
+      {
+        ivar_keyword = Qnil;
+      }
+      else
+      {
+        ivar_keyword = rb_funcall(first_item, id_method_upcase, 0);
+      }
+      rb_ivar_set(self, id_ivar_keyword, ivar_keyword);
+      ivar_parameters = rb_ary_new();
+      rb_ivar_set(self, id_ivar_parameters, ivar_parameters);
+    }
+
+    /* Ignore comments and blank lines */
+    if (ivar_keyword == Qnil)
+    {
+      if ((RTEST(yield_non_keyword_lines)) && (!(RTEST(line_continuation))))
+      {
+        rb_ary_clear(array);
+        rb_ary_push(array, ivar_keyword);
+        rb_ary_push(array, ivar_parameters);
+        rb_yield(array);
+      }
+      continue;
+    }
+
+    if (RTEST(line_continuation))
+    {
+      if (RTEST(remove_quotes))
+      {
+        rb_ary_push(ivar_parameters, string_remove_quotes(first_item));
+      }
+      else
+      {
+        rb_ary_push(ivar_parameters, first_item);
+      }
+      line_continuation = Qfalse;
+    }
+
+    length = RARRAY_LEN(data);
+    if (length > 1)
+    {
+      for (index = 1; index < length; index++)
+      {
+        string = rb_ary_entry(data, index);
+
+        /*
+         * Don't process trailing comments such as:
+         * KEYWORD PARAM #This is a comment
+         * But still process Ruby string interpolations such as:
+         * KEYWORD PARAM #{var}
+         */
+        if ((RSTRING_LEN(string) > 0) && (RSTRING_PTR(string)[0] == '#'))
+        {
+          if (!((RSTRING_LEN(string) > 1) && (RSTRING_PTR(string)[1] == '{')))
+          {
+            break;
+          }
+        }
+
+        /*
+         * If the string is simply '&' and its the last string then its a line continuation so break the loop
+         */
+        if ((RSTRING_LEN(string) == 1) && (RSTRING_PTR(string)[0] == '&') && (index == (length - 1)))
+        {
+          line_continuation = Qtrue;
+          continue;
+        }
+
+        line_continuation = Qfalse;
+        if (RTEST(remove_quotes))
+        {
+          rb_ary_push(ivar_parameters, string_remove_quotes(string));
+        }
+        else
+        {
+          rb_ary_push(ivar_parameters, string);
+        }
+      }
+    }
+
+    /*
+     * If we detected a line continuation while going through all the
+     * strings on the line then we strip off the continuation character and
+     * return to the top of the loop to continue processing the line.
+     */
+    if (RTEST(line_continuation))
+    {
+      /* Strip the continuation character */
+      if (RSTRING_LEN(ivar_line) >= 1)
+      {
+        ivar_line = rb_str_new(RSTRING_PTR(ivar_line), RSTRING_LEN(ivar_line) - 1);
+      }
+      else
+      {
+        ivar_line = rb_str_new2("");
+      }
+      rb_ivar_set(self, id_ivar_line, ivar_line);
+      continue;
+    }
+
+    rb_ary_clear(array);
+    rb_ary_push(array, ivar_keyword);
+    rb_ary_push(array, ivar_parameters);
+    rb_yield(array);
+  }
+
+  if (RTEST(progress_callback))
+  {
+    rb_funcall(progress_callback, id_method_call, 1, rb_float_new(1.0));
+  }
+
+  return Qnil;
+}
+
+/*
+ * Initialize methods for ConfigParser
+ */
+void Init_config_parser(void)
+{
+  id_cvar_progress_callback = rb_intern("@@progress_callback");
+  id_ivar_line_number = rb_intern("@line_number");
+  id_ivar_keyword = rb_intern("@keyword");
+  id_ivar_parameters = rb_intern("@parameters");
+  id_ivar_line = rb_intern("@line");
+  id_method_readline = rb_intern("readline");
+  id_method_close = rb_intern("close");
+  id_method_pos = rb_intern("pos");
+  id_method_call = rb_intern("call");
+  id_method_scan = rb_intern("scan");
+  id_method_strip = rb_intern("strip");
+  id_method_to_s = rb_intern("to_s");
+  id_method_upcase = rb_intern("upcase");
+
+  mOpenC3 = rb_define_module("OpenC3");
+
+  cConfigParser = rb_define_class_under(mOpenC3, "ConfigParser", rb_cObject);
+  rb_define_method(cConfigParser, "parse_loop", parse_loop, 5);
+}

data/ext/openc3/ext/config_parser/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/config_parser'