edn_turbo 0.5.7 → 0.6.0

data/ext/edn_turbo/edn_parser.rl

@@ -1,3 +1,25 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2015-2019 Ed Porras
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 #include <iostream>
 #include <string>
 #include <sstream>
@@ -71,20 +93,20 @@
     action parse_val_string {
         // string types within double-quotes
         const char *np = parse_string(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_keyword {
         // tokens with a leading ':'
         const char *np = parse_keyword(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_number {
         // tokens w/ leading digits: non-negative integers & decimals.
         // try to parse a decimal first
         const char *np = parse_decimal(fpc, pe, v);
-        if (np == NULL) {
+        if (np == nullptr) {
             // if we can't, try to parse it as an int
             np = parse_integer(fpc, pe, v);
         }
@@ -103,20 +125,20 @@
     action parse_val_operator {
         // stand-alone operators *, +, -, etc.
         const char *np = parse_operator(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_char {
         // tokens w/ leading \ (escaped characters \newline, \c, etc.)
         const char *np = parse_esc_char(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_symbol {
         // user identifiers and reserved keywords (true, false, nil)
         VALUE sym = Qnil;
         const char *np = parse_symbol(fpc, pe, sym);
-        if (np == NULL) { fexec pe; } else {
+        if (np == nullptr) { fexec pe; } else {
             // parse_symbol will make 'sym' a ruby string
             if      (std::strcmp(RSTRING_PTR(sym), "true") == 0)  { v = Qtrue; }
             else if (std::strcmp(RSTRING_PTR(sym), "false") == 0) { v = Qfalse; }
@@ -131,31 +153,31 @@
     action parse_val_vector {
         // [
         const char *np = parse_vector(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_list {
         // (
         const char *np = parse_list(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_map {
         // {
         const char *np = parse_map(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_meta {
         // ^
         const char *np = parse_meta(fpc, pe);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_val_dispatch {
         // handles tokens w/ leading # ("#_", "#{", and tagged elems)
         const char *np = parse_dispatch(fpc + 1, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
 
@@ -191,7 +213,7 @@ const char *edn::Parser::parse_value(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_value_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -247,7 +269,7 @@ const char* edn::Parser::parse_string(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_string_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -293,7 +315,7 @@ const char* edn::Parser::parse_keyword(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_keyword_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -328,7 +350,7 @@ const char* edn::Parser::parse_decimal(const char *p, const char *pe, VALUE& v)
         return p + 1;
     }
     else if (cs == EDN_decimal_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -360,7 +382,7 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
         return p + 1;
     }
     else if (cs == EDN_integer_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -382,7 +404,7 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
         // parse a symbol including the leading operator (-, +, .)
         VALUE sym = Qnil;
         const char *np = parse_symbol(p_save, pe, sym);
-        if (np == NULL) { fexec pe; } else {
+        if (np == nullptr) { fexec pe; } else {
             if (sym != Qnil)
                 v = edn::util::call_module_fn(rb_mEDN, EDN_MAKE_SYMBOL_METHOD, sym);
             fexec np;
@@ -396,7 +418,7 @@ const char* edn::Parser::parse_integer(const char *p, const char *pe, VALUE& v)
         //
         // try to parse a decimal first
         const char *np = parse_decimal(p_save, pe, v);
-        if (np == NULL) {
+        if (np == nullptr) {
             // if we can't, try to parse it as an int
             np = parse_integer(p_save, pe, v);
         }
@@ -447,7 +469,7 @@ const char* edn::Parser::parse_operator(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_operator_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -491,7 +513,7 @@ const char* edn::Parser::parse_esc_char(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_escaped_char_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -551,7 +573,7 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, VALUE& s)
         error(__FUNCTION__, "invalid symbol sequence", *p);
     }
     else if (cs == EDN_symbol_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -589,7 +611,7 @@ const char* edn::Parser::parse_symbol(const char *p, const char *pe, VALUE& s)
         VALUE e;
         std::size_t meta_sz = meta_size();
         const char *np = parse_value(fpc, pe, e);
-        if (np == NULL) { fhold; fbreak; } else {
+        if (np == nullptr) { fhold; fbreak; } else {
             // if there's an entry in the discard list, the current
             // object is not meant to be kept due to a #_ so don't
             // push it into the list of elements
@@ -657,7 +679,7 @@ const char* edn::Parser::parse_vector(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_vector_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -702,7 +724,7 @@ const char* edn::Parser::parse_list(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_list_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -760,7 +782,7 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_map_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -779,19 +801,19 @@ const char* edn::Parser::parse_map(const char *p, const char *pe, VALUE& v)
     action parse_disp_set {
         // #{ }
         const char *np = parse_set(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_disp_discard {
         // discard token #_
         const char *np = parse_discard(fpc, pe);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
     action parse_disp_tagged {
         // #inst, #uuid, or #user/tag
         const char *np = parse_tagged(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else fexec np;
+        if (np == nullptr) { fhold; fbreak; } else fexec np;
     }
 
 
@@ -819,7 +841,7 @@ const char* edn::Parser::parse_dispatch(const char *p, const char *pe, VALUE& v)
     }
     else if (cs == EDN_dispatch_en_main) {} // silence ragel warning
 
-    return NULL;
+    return nullptr;
 }
 
 
@@ -863,7 +885,7 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
         return pe;
     }
     else if (cs == EDN_set_en_main) {} // silence ragel warning
-    return NULL;
+    return nullptr;
 }
 
 
@@ -883,7 +905,7 @@ const char* edn::Parser::parse_set(const char *p, const char *pe, VALUE& v)
 
     action discard_value {
         const char *np = parse_value(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else {
+        if (np == nullptr) { fhold; fbreak; } else {
             // this token is to be discarded so store it in the
             // discard stack - we really don't need to save it so this
             // could be simplified
@@ -922,7 +944,7 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     }
     else if (cs == EDN_discard_en_main) {} // silence ragel warning
 
-    return NULL;
+    return nullptr;
 }
 
 
@@ -962,7 +984,7 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     action parse_tag {
         // parses the symbol portion of the pair
         const char *np = parse_symbol(fpc, pe, sym_name);
-        if (np == NULL) { fhold; fbreak; } else {
+        if (np == nullptr) { fhold; fbreak; } else {
             sym_ok = true;
             fexec np;
         }
@@ -970,7 +992,7 @@ const char* edn::Parser::parse_discard(const char *p, const char *pe)
     action parse_data {
         // parses the value portion
         const char *np = parse_value(fpc, pe, data);
-        if (np == NULL) { fhold; fbreak; } else {
+        if (np == nullptr) { fhold; fbreak; } else {
             data_ok = true;
             fexec np;
         }
@@ -1001,7 +1023,7 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, VALUE& v)
         if (!sym_ok || !data_ok) {
             error(__FUNCTION__, "tagged element symbol error", *p);
             v = EDN_EOF_CONST;
-            return NULL;
+            return nullptr;
         }
 
         try {
@@ -1019,7 +1041,7 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, VALUE& v)
     }
     else if (cs == EDN_tagged_en_main) {} // silence ragel warning
     v =  EDN_EOF_CONST;
-    return NULL;
+    return nullptr;
 }
 
 
@@ -1038,7 +1060,7 @@ const char* edn::Parser::parse_tagged(const char *p, const char *pe, VALUE& v)
 
     action parse_data {
         const char *np = parse_value(fpc, pe, v);
-        if (np == NULL) { fhold; fbreak; } else { fexec np; }
+        if (np == nullptr) { fhold; fbreak; } else { fexec np; }
     }
 
     main := begin_meta (
@@ -1065,7 +1087,7 @@ const char* edn::Parser::parse_meta(const char *p, const char *pe)
     }
     else if (cs == EDN_meta_en_main) {} // silence ragel warning
 
-    return NULL;
+    return nullptr;
 }
 
 
@@ -1086,7 +1108,7 @@ const char* edn::Parser::parse_meta(const char *p, const char *pe)
         // an actual data item
         std::size_t meta_sz = meta_size();
         const char* np = parse_value(fpc, pe, result);
-        if (np == NULL) { fexec pe; fbreak; } else {
+        if (np == nullptr) { fexec pe; fbreak; } else {
             // if we have metadata saved and it matches the count we
             // saved before we parsed a value, then we must bind the
             // metadata sequence to it
@@ -1120,7 +1142,7 @@ VALUE edn::Parser::parse(const char* src, std::size_t len)
         return EDN_EOF_CONST;
     }
     else if (cs == EDN_parser_first_final) {
-        p = pe = eof = NULL;
+        p = pe = eof = nullptr;
     }
     else if (cs == EDN_parser_en_main) {} // silence ragel warning
     return result;
@@ -1144,7 +1166,7 @@ VALUE edn::Parser::parse(const char* src, std::size_t len)
         meta_sz = meta_size();
 
         const char* np = parse_value(fpc, pe, value);
-        if (np == NULL) { fhold; fbreak; } else {
+        if (np == nullptr) { fhold; fbreak; } else {
             if (!meta_empty()) {
                 // was an additional metadata entry read? if so, don't
                 // return a value

data/ext/edn_turbo/extconf.rb

@@ -1,5 +1,27 @@
 # frozen_string_literal: true
 
+# The MIT License (MIT)
+
+# Copyright (c) 2015-2019 Ed Porras
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
 require 'mkmf'
 
 header_dirs =
@@ -38,7 +60,8 @@ lib_dirs =
 dir_config('icuuc', header_dirs, lib_dirs)
 
 # feels very hackish to do this but the new icu4c needs it on MacOS
-$CXXFLAGS << ' -stdlib=libc++ -std=c++11' if RUBY_PLATFORM.match?(/darwin/)
+$CXXFLAGS << ' -stdlib=libc++ -Wno-deprecated-register' if RUBY_PLATFORM =~ /darwin/
+$CXXFLAGS << ' -std=c++11 -std=gnu++11'
 
 abort "\n>> failed to find icu4c headers - is icu4c installed?\n\n" unless
   find_header('unicode/uversion.h')

data/ext/edn_turbo/main.cc

@@ -1,3 +1,25 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2015-2019 Ed Porras
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 #include <signal.h>
 #include <iostream>
 #include <clocale>
@@ -10,150 +32,147 @@
 
 namespace edn {
 
-    VALUE rb_mEDN;
-    VALUE rb_mEDNT;
-
-    // Symbols used to call into the ruby world.
-    VALUE EDN_MAKE_SYMBOL_METHOD       = Qnil;
-    VALUE EDN_MAKE_LIST_METHOD         = Qnil;
-    VALUE EDN_MAKE_SET_METHOD          = Qnil;
-    VALUE EDN_MAKE_BIG_DECIMAL_METHOD  = Qnil;
-    VALUE EDN_TAGGED_ELEM_METHOD       = Qnil;
-    VALUE EDNT_EXTENDED_VALUE_METHOD   = Qnil;
-
-    VALUE RUBY_STRING_TO_I_METHOD      = Qnil;
-    VALUE RUBY_STRING_TO_F_METHOD      = Qnil;
-    VALUE RUBY_READ_METHOD             = Qnil;
-
-    // returned when EOF - defined as a constant in EDN module
-    VALUE EDN_EOF_CONST                = Qnil;
-
-    //
-    // Wrappers to hook the class w/ the C-api.
-    static void delete_parser(void* p_ptr) {
-        delete reinterpret_cast<edn::Parser*>(p_ptr);
-    }
-
-    static const rb_data_type_t parser_data_type = {
-        "edn_turbo::Parser",
-        {0, delete_parser, 0, {0}},
-        0, 0,
-        RUBY_TYPED_FREE_IMMEDIATELY,
-    };
-
-    static VALUE wrap_parser_ptr(VALUE klass, edn::Parser* ptr) {
-        return TypedData_Wrap_Struct(klass, &parser_data_type, ptr);
-    }
-
-    static VALUE alloc_obj(VALUE self){
-        return wrap_parser_ptr(self, new Parser());
-    }
-
-    static inline Parser* get_parser(VALUE self)
-    {
-        Parser *p;
-        TypedData_Get_Struct( self, edn::Parser, &parser_data_type, p );
-        return p;
-    }
-    static VALUE set_source(VALUE self, VALUE data);
-
-    //
-    // Called by the constructor - sets the source if passed.
-    static VALUE initialize(int argc, VALUE* argv, VALUE self)
-    {
-        if (argc > 0) {
-            set_source( self, argv[0] );
-        }
-        return self;
-    }
-
-    //
-    // change the input source
-    static VALUE set_source(VALUE self, VALUE data)
-    {
-        Parser* p = get_parser(self);
-
-        switch (TYPE(data))
-        {
-          case T_STRING:
-          {
+   VALUE rb_mEDN;
+   VALUE rb_mEDNT;
+
+   // Symbols used to call into the ruby world.
+   VALUE EDN_MAKE_SYMBOL_METHOD       = Qnil;
+   VALUE EDN_MAKE_LIST_METHOD         = Qnil;
+   VALUE EDN_MAKE_SET_METHOD          = Qnil;
+   VALUE EDN_MAKE_BIG_DECIMAL_METHOD  = Qnil;
+   VALUE EDN_TAGGED_ELEM_METHOD       = Qnil;
+   VALUE EDNT_EXTENDED_VALUE_METHOD   = Qnil;
+
+   VALUE RUBY_STRING_TO_I_METHOD      = Qnil;
+   VALUE RUBY_STRING_TO_F_METHOD      = Qnil;
+   VALUE RUBY_READ_METHOD             = Qnil;
+
+   // returned when EOF - defined as a constant in EDN module
+   VALUE EDN_EOF_CONST                = Qnil;
+
+   //
+   // Wrappers to hook the class w/ the C-api.
+   static void delete_parser(void* p_ptr) {
+      delete reinterpret_cast<edn::Parser*>(p_ptr);
+   }
+
+   static const rb_data_type_t parser_data_type = {
+      "edn_turbo::Parser",
+      {0, delete_parser, 0, {0}},
+      0, 0,
+      RUBY_TYPED_FREE_IMMEDIATELY,
+   };
+
+   static VALUE wrap_parser_ptr(VALUE klass, edn::Parser* ptr) {
+      return TypedData_Wrap_Struct(klass, &parser_data_type, ptr);
+   }
+
+   static VALUE alloc_obj(VALUE self){
+      return wrap_parser_ptr(self, new Parser());
+   }
+
+   static inline Parser* get_parser(VALUE self)
+   {
+      Parser *p;
+      TypedData_Get_Struct( self, edn::Parser, &parser_data_type, p );
+      return p;
+   }
+   static VALUE set_source(VALUE self, VALUE data);
+
+   //
+   // Called by the constructor - sets the source if passed.
+   static VALUE initialize(int argc, VALUE* argv, VALUE self)
+   {
+      if (argc > 0) {
+         set_source( self, argv[0] );
+      }
+      return self;
+   }
+
+   //
+   // change the input source
+   static VALUE set_source(VALUE self, VALUE data)
+   {
+      Parser* p = get_parser(self);
+
+      switch (TYPE(data))
+      {
+        case T_STRING:
+           {
               const char* stream = StringValueCStr(data);
               if (stream) {
-                  p->set_source( stream, std::strlen(stream) );
+                 p->set_source( stream, std::strlen(stream) );
               }
               break;
-          }
-          case T_FILE:
-          {
+           }
+        case T_FILE:
+           {
               // extract the stream pointer
               rb_io_t* fptr = RFILE(data)->fptr;
               if (!fptr) {
-                  rb_raise(rb_eRuntimeError, "Ruby IO - fptr is NULL");
+                 rb_raise(rb_eRuntimeError, "Ruby IO - fptr is null");
               }
 
               rb_io_check_char_readable(fptr);
 
               FILE* fp = rb_io_stdio_file(fptr);
               if (!fp) {
-                  rb_raise(rb_eRuntimeError, "Ruby IO - fptr->fp is NULL");
+                 rb_raise(rb_eRuntimeError, "Ruby IO - fptr->fp is null");
               }
 
               p->set_source(fp);
               break;
-          }
-          case T_DATA:
-          {
-              // StringIO or some other IO not part of the ruby core -
-              // this is very inefficient as it'll require read()
-              // calls from the ruby side (involves a lot of data
-              // wrapping, etc)
+           }
+        case T_DATA:
+           {
+              // StringIO or some other IO not part of the ruby core
               if (rb_respond_to(data, RUBY_READ_METHOD)) {
-                  p->set_source(data);
-                  break;
+                 p->set_source(data);
+                 break;
               }
-          }
-          default:
-              rb_raise(rb_eRuntimeError, "set_source expected String, core IO, or IO that responds to read()");
-              break;
-        }
-
-        return self;
-    }
-
-    //
-    // eof?
-    static VALUE eof(VALUE self, VALUE data)
-    {
-        return get_parser(self)->is_eof();
-    }
-
-    //
-    // parses an entire stream
-    static VALUE read(VALUE self, VALUE data)
-    {
-        if (TYPE(data) != T_STRING) {
-            rb_raise(rb_eTypeError, "Expected String data");
-        }
-        const char* stream = StringValueCStr(data);
-        if (stream) {
-            return get_parser(self)->parse(stream, std::strlen(stream) );
-        }
-        return Qnil;
-    }
-
-    //
-    // gets the next token in the current stream
-    static VALUE next(VALUE self, VALUE data)
-    {
-        return get_parser(self)->next();
-    }
-
-    //
-    // signal handler
-    static void die(int sig)
-    {
-        exit(-1);
-    }
+           }
+        default:
+           rb_raise(rb_eArgError, "set_source expected String, core IO, or IO that responds to read()");
+           break;
+      }
+
+      return self;
+   }
+
+   //
+   // eof?
+   static VALUE eof(VALUE self, VALUE data)
+   {
+      return get_parser(self)->is_eof();
+   }
+
+   //
+   // parses an entire stream
+   static VALUE read(VALUE self, VALUE data)
+   {
+      if (TYPE(data) != T_STRING) {
+         rb_raise(rb_eTypeError, "Expected String data");
+      }
+      const char* stream = StringValueCStr(data);
+      if (stream) {
+         return get_parser(self)->parse(stream, std::strlen(stream) );
+      }
+      return Qnil;
+   }
+
+   //
+   // gets the next token in the current stream
+   static VALUE next(VALUE self, VALUE data)
+   {
+      return get_parser(self)->next();
+   }
+
+   //
+   // signal handler
+   [[noreturn]] static void die(int sig)
+   {
+      exit(-1);
+   }
 }
 
 
@@ -162,45 +181,49 @@ namespace edn {
 extern "C"
 void Init_edn_turbo(void)
 {
-    struct sigaction a;
-    a.sa_handler = edn::die;
-    sigemptyset(&a.sa_mask);
-    a.sa_flags = 0;
-    sigaction(SIGINT, &a, NULL);
-
-    // pass things back as utf-8
-    if (!setlocale( LC_ALL, "" )) {
-        rb_raise(rb_eRuntimeError, "Extension init error calling setlocale() - It appears your system's locale is not configured correctly.\n");
-    }
-
-    edn::rb_mEDN  = rb_const_get(rb_cObject, rb_intern("EDN"));
-    edn::rb_mEDNT = rb_define_module("EDNT");
-
-    // bind the ruby Parser class to the C++ one
-    VALUE rb_cParser = rb_define_class_under(edn::rb_mEDNT, "Parser", rb_cObject);
-    rb_define_alloc_func(rb_cParser, edn::alloc_obj);
-    rb_define_method(rb_cParser, "initialize", (VALUE(*)(ANYARGS)) &edn::initialize, -1 );
-    rb_define_method(rb_cParser, "ext_eof", (VALUE(*)(ANYARGS)) &edn::eof, 0 );
-
-    rb_define_method(rb_cParser, "set_input", (VALUE(*)(ANYARGS)) &edn::set_source, 1 );
-    rb_define_method(rb_cParser, "parse", (VALUE(*)(ANYARGS)) &edn::read, 1 );
-    rb_define_method(rb_cParser, "read", (VALUE(*)(ANYARGS)) &edn::next, 0 );
-
-    // bind ruby methods we'll call - these should be defined in edn_turbo.rb
-    edn::EDN_MAKE_SYMBOL_METHOD        = rb_intern("symbol");
-    edn::EDN_MAKE_LIST_METHOD          = rb_intern("list");
-    edn::EDN_MAKE_SET_METHOD           = rb_intern("set");
-    edn::EDN_MAKE_BIG_DECIMAL_METHOD   = rb_intern("big_decimal");
-    edn::EDN_TAGGED_ELEM_METHOD        = rb_intern("tagged_element");
-
-    // defined in EDNT - see edn_parser.rb
-    edn::EDNT_EXTENDED_VALUE_METHOD     = rb_intern("extend_for_meta");
-
-    // ruby methods
-    edn::RUBY_STRING_TO_I_METHOD       = rb_intern("to_i");
-    edn::RUBY_STRING_TO_F_METHOD       = rb_intern("to_f");
-    edn::RUBY_READ_METHOD              = rb_intern("read");
-
-    // so we can return EOF directly
-    edn::EDN_EOF_CONST                 = rb_const_get(edn::rb_mEDN, rb_intern("EOF"));
+   struct sigaction a;
+   a.sa_handler = edn::die;
+   sigemptyset(&a.sa_mask);
+   a.sa_flags = 0;
+   sigaction(SIGINT, &a, nullptr);
+
+   // pass things back as utf-8
+   if (!setlocale( LC_ALL, "" )) {
+      rb_raise(rb_eRuntimeError, "Extension init error calling setlocale() - It appears your system's locale is not configured correctly.\n");
+   }
+
+   edn::rb_mEDN  = rb_const_get(rb_cObject, rb_intern("EDN"));
+   edn::rb_mEDNT = rb_define_module("EDNT");
+
+   // bind the ruby Parser class to the C++ one
+   VALUE rb_cParser = rb_define_class_under(edn::rb_mEDNT, "Parser", rb_cObject);
+   rb_define_alloc_func(rb_cParser, edn::alloc_obj);
+   rb_define_method(rb_cParser, "initialize",
+                    reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::initialize), -1 );
+   rb_define_method(rb_cParser, "ext_eof",
+                    reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::eof), 0 );
+   rb_define_method(rb_cParser, "set_input",
+                    reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::set_source), 1 );
+   rb_define_method(rb_cParser, "parse",
+                    reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::read), 1 );
+   rb_define_method(rb_cParser, "read",
+                    reinterpret_cast<VALUE(*)(ANYARGS)>(&edn::next), 0 );
+
+   // bind ruby methods we'll call - these should be defined in edn_turbo.rb
+   edn::EDN_MAKE_SYMBOL_METHOD        = rb_intern("symbol");
+   edn::EDN_MAKE_LIST_METHOD          = rb_intern("list");
+   edn::EDN_MAKE_SET_METHOD           = rb_intern("set");
+   edn::EDN_MAKE_BIG_DECIMAL_METHOD   = rb_intern("big_decimal");
+   edn::EDN_TAGGED_ELEM_METHOD        = rb_intern("tagged_element");
+
+   // defined in EDNT - see edn_parser.rb
+   edn::EDNT_EXTENDED_VALUE_METHOD    = rb_intern("extend_for_meta");
+
+   // ruby methods
+   edn::RUBY_STRING_TO_I_METHOD       = rb_intern("to_i");
+   edn::RUBY_STRING_TO_F_METHOD       = rb_intern("to_f");
+   edn::RUBY_READ_METHOD              = rb_intern("read");
+
+   // so we can return EOF directly
+   edn::EDN_EOF_CONST                 = rb_const_get(edn::rb_mEDN, rb_intern("EOF"));
 }