antlr4-native 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1abe502ed412ef8d9fda78dd371448d290c10bd757c34044c881c110f11c84df
-  data.tar.gz: 7093d010f55d0dac4b9b4e3d9a8f0da004ed40d4595caab9623bd717b879c812
+  metadata.gz: f14d05febd863a51c3e111e7ef3493eb2fe1b72fe72b0b3d1c5c114a2947f7c7
+  data.tar.gz: e8f3fe771ae21c552a1074e2f0608f9c87da1e7bd9063f2f8e18363531c37e6b
 SHA512:
-  metadata.gz: 0d2498b8804a2ba13e8fbc6e90ff0c3b209962712ec7005142d59a3ebe656123d28396a0a278a634bc228304bd9160beff49dd11985db6d5249ebed7857127b5
-  data.tar.gz: 738c3abb9486de9819faaab462a9f65e0823803f382180f3b32347e51d9d330c1072bfe9c1df239e48fc5c82c4f99f8db1e9bb3c6584752b6607b78ae4173c4a
+  metadata.gz: 64cf7e6628edbaff365daf278c1e70dccd7ca083128d604efe8fcb4850c77efc621ce204fe250a7ffb91adb5d6cb4d02de9f1f68bbbb32c4c8c79d725c308a26
+  data.tar.gz: 1c5ba3ec3908cc1a951794d0e70f87afa0f01694ef623b38269ad5f22569fd8b587c1c6a7e820d32de273f6c87e77d15abcf604e83b0edd13f2a0636c09c5d86

data/antlr4-native.gemspec

@@ -14,4 +14,6 @@ Gem::Specification.new do |s|
 
   s.require_path = 'lib'
   s.files = Dir['{lib,spec,vendor}/**/*', 'Gemfile', 'README.md', 'Rakefile', 'antlr4-native.gemspec']
+
+  s.add_runtime_dependency "rice", "~> 4.0"
 end

data/lib/antlr4-native/context.rb

@@ -51,16 +51,24 @@ module Antlr4Native
 
     def conversions
       @class_conversions ||= <<~END
-        template <>
-        Object to_ruby<#{parser_ns}::#{name}*>(#{parser_ns}::#{name}* const &x) {
-          if (!x) return Nil;
-          return Data_Object<#{parser_ns}::#{name}>(x, #{proxy_class_variable}, nullptr, nullptr);
-        }
+        namespace Rice::detail {
+          template <>
+          class To_Ruby<#{parser_ns}::#{name}*> {
+          public:
+            VALUE convert(#{parser_ns}::#{name}* const &x) {
+              if (!x) return Nil;
+              return Data_Object<#{parser_ns}::#{name}>(x, false, #{proxy_class_variable});
+            }
+          };
 
-        template <>
-        Object to_ruby<#{name}Proxy*>(#{name}Proxy* const &x) {
-          if (!x) return Nil;
-          return Data_Object<#{name}Proxy>(x, #{proxy_class_variable}, nullptr, nullptr);
+          template <>
+          class To_Ruby<#{name}Proxy*> {
+          public:
+            VALUE convert(#{name}Proxy* const &x) {
+              if (!x) return Nil;
+              return Data_Object<#{name}Proxy>(x, false, #{proxy_class_variable});
+            }
+          };
         }
       END
     end
@@ -88,7 +96,7 @@ module Antlr4Native
                 }
               }
 
-              return a;
+              return std::move(a);
             }
           END
         else
@@ -105,7 +113,7 @@ module Antlr4Native
               }
 
               for (auto child : getChildren()) {
-                if (ctx == from_ruby<ContextProxy>(child).getOriginal()) {
+                if (ctx == detail::From_Ruby<ContextProxy>().convert(child.value()).getOriginal()) {
                   return child;
                 }
               }
@@ -127,17 +135,17 @@ module Antlr4Native
               Array a;
 
               if (orig == nullptr) {
-                return a;
+                return std::move(a);
               }
 
               auto vec = ((#{parser_ns}::#{name}*)orig) -> #{token_mtd.name}(#{params});
 
               for (auto it = vec.begin(); it != vec.end(); it ++) {
                 TerminalNodeProxy proxy(*it);
-                a.push(proxy);
+                a.push(detail::To_Ruby<TerminalNodeProxy>().convert(proxy));
               }
 
-              return a;
+              return std::move(a);
             }
           END
         else
@@ -154,7 +162,7 @@ module Antlr4Native
               }
 
               TerminalNodeProxy proxy(token);
-              return to_ruby(proxy);
+              return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
             }
           END
         end
@@ -164,8 +172,7 @@ module Antlr4Native
     def class_wrapper(module_var)
       @class_wrapper ||= begin
         lines = [
-          "#{proxy_class_variable} = #{module_var}",
-          ".define_class<#{name}Proxy, ContextProxy>(\"#{name}\")"
+          %(#{proxy_class_variable} = define_class_under<#{name}Proxy, ContextProxy>(#{module_var}, "#{name}"))
         ]
 
         each_context_method do |ctx_method|

data/lib/antlr4-native/generator.rb

@@ -65,47 +65,59 @@ module Antlr4Native
       <<~END
         #include <iostream>
 
-        #include "antlr4-runtime.h"
+        #include <antlr4-runtime.h>
 
-        #include "#{parser_ns}.h"
-        #include "#{antlr_ns}BaseVisitor.h"
-        #include "#{lexer_ns}.h"
+        #include "antlrgen/#{parser_ns}.h"
+        #include "antlrgen/#{antlr_ns}BaseVisitor.h"
+        #include "antlrgen/#{lexer_ns}.h"
 
-        #include "rice/Array.hpp"
-        #include "rice/Class.hpp"
-        #include "rice/Constructor.hpp"
-        #include "rice/Director.hpp"
+        #include <rice/rice.hpp>
+        #include <rice/stl.hpp>
 
         #ifdef _WIN32
-        #undef FALSE
-        #undef TRUE
         #undef OPTIONAL
         #undef IN
         #undef OUT
         #endif
 
+        #undef FALSE
+        #undef TRUE
+
+        #undef TYPE
+
         using namespace std;
         using namespace Rice;
         using namespace antlr4;
 
         #{proxy_class_declarations}
 
-        template <>
-        Object to_ruby<Token*>(Token* const &x) {
-          if (!x) return Nil;
-          return Data_Object<Token>(x, rb_cToken, nullptr, nullptr);
-        }
-
-        template <>
-        Object to_ruby<tree::ParseTree*>(tree::ParseTree* const &x) {
-          if (!x) return Nil;
-          return Data_Object<tree::ParseTree>(x, rb_cParseTree, nullptr, nullptr);
-        }
-
-        template <>
-        Object to_ruby<tree::TerminalNode*>(tree::TerminalNode* const &x) {
-          if (!x) return Nil;
-          return Data_Object<tree::TerminalNode>(x, rb_cTerminalNode, nullptr, nullptr);
+        namespace Rice::detail {
+          template <>
+          class To_Ruby<Token*> {
+          public:
+            VALUE convert(Token* const &x) {
+              if (!x) return Nil;
+              return Data_Object<Token>(x, false, rb_cToken);
+            }
+          };
+
+          template <>
+          class To_Ruby<tree::ParseTree*> {
+          public:
+            VALUE convert(tree::ParseTree* const &x) {
+              if (!x) return Nil;
+              return Data_Object<tree::ParseTree>(x, false, rb_cParseTree);
+            }
+          };
+
+          template <>
+          class To_Ruby<tree::TerminalNode*> {
+          public:
+            VALUE convert(tree::TerminalNode* const &x) {
+              if (!x) return Nil;
+              return Data_Object<tree::TerminalNode>(x, false, rb_cTerminalNode);
+            }
+          };
         }
 
         class ContextProxy {
@@ -125,13 +137,13 @@ module Antlr4Native
           Object getStart() {
             auto token = ((ParserRuleContext*) orig) -> getStart();
 
-            return to_ruby(token);
+            return detail::To_Ruby<Token*>().convert(token);
           }
 
           Object getStop() {
             auto token = ((ParserRuleContext*) orig) -> getStop();
 
-            return to_ruby(token);
+            return detail::To_Ruby<Token*>().convert(token);
           }
 
           Array getChildren() {
@@ -172,7 +184,7 @@ module Antlr4Native
 
           bool doubleEquals(Object other) {
             if (other.is_a(rb_cContextProxy)) {
-              return from_ruby<ContextProxy*>(other) -> getOriginal() == getOriginal();
+              return detail::From_Ruby<ContextProxy*>().convert(other) -> getOriginal() == getOriginal();
             } else {
               return false;
             }
@@ -193,6 +205,7 @@ module Antlr4Native
           TerminalNodeProxy(tree::ParseTree* tree) : ContextProxy(tree) { }
         };
 
+
         #{proxy_class_headers}
 
         #{conversions}
@@ -261,7 +274,7 @@ module Antlr4Native
             auto ctx = this -> parser -> #{parser_root_method}();
 
             #{capitalize(parser_root_method)}ContextProxy proxy((#{parser_ns}::#{capitalize(parser_root_method)}Context*) ctx);
-            return to_ruby(proxy);
+            return detail::To_Ruby<#{capitalize(parser_root_method)}ContextProxy>().convert(proxy);
           }
 
           Object visit(VisitorProxy* visitor) {
@@ -301,10 +314,15 @@ module Antlr4Native
           #{parser_ns}* parser;
         };
 
-        template <>
-        Object to_ruby<ParserProxy*>(ParserProxy* const &x) {
-          if (!x) return Nil;
-          return Data_Object<ParserProxy>(x, rb_cParser, nullptr, nullptr);
+        namespace Rice::detail {
+          template <>
+          class To_Ruby<ParserProxy*> {
+          public:
+            VALUE convert(ParserProxy* const &x) {
+              if (!x) return Nil;
+              return Data_Object<ParserProxy>(x, false, rb_cParser);
+            }
+          };
         }
       END
     end
@@ -315,24 +333,14 @@ module Antlr4Native
         void Init_#{ext_name}() {
           Module rb_m#{parser_ns} = define_module("#{parser_ns}");
 
-          rb_cToken = rb_m#{parser_ns}
-            .define_class<Token>("Token")
+          rb_cToken = define_class_under<Token>(rb_m#{parser_ns}, "Token")
             .define_method("text", &Token::getText)
             .define_method("channel", &Token::getChannel)
             .define_method("token_index", &Token::getTokenIndex);
 
-          rb_cParser = rb_m#{parser_ns}
-            .define_class<ParserProxy>("Parser")
-            .define_singleton_method("parse", &ParserProxy::parse)
-            .define_singleton_method("parse_file", &ParserProxy::parseFile)
-            .define_method("#{parser_root_method}", &ParserProxy::#{parser_root_method})
-            .define_method("visit", &ParserProxy::visit);
-
-          rb_cParseTree = rb_m#{parser_ns}
-            .define_class<tree::ParseTree>("ParseTree");
+          rb_cParseTree = define_class_under<tree::ParseTree>(rb_m#{parser_ns}, "ParseTree");
 
-          rb_cContextProxy = rb_m#{parser_ns}
-            .define_class<ContextProxy>("Context")
+          rb_cContextProxy = define_class_under<ContextProxy>(rb_m#{parser_ns}, "Context")
             .define_method("children", &ContextProxy::getChildren)
             .define_method("child_count", &ContextProxy::childCount)
             .define_method("text", &ContextProxy::getText)
@@ -341,17 +349,21 @@ module Antlr4Native
             .define_method("parent", &ContextProxy::getParent)
             .define_method("==", &ContextProxy::doubleEquals);
 
-          rb_cTerminalNode = rb_m#{parser_ns}
-            .define_class<TerminalNodeProxy, ContextProxy>("TerminalNodeImpl");
+          rb_cTerminalNode = define_class_under<TerminalNodeProxy, ContextProxy>(rb_m#{parser_ns}, "TerminalNodeImpl");
 
-          rb_m#{parser_ns}
-            .define_class<#{visitor_generator.cpp_class_name}>("#{visitor_generator.class_name}")
+          define_class_under<#{antlr_ns}BaseVisitor>(rb_m#{parser_ns}, "#{visitor_generator.class_name}")
             .define_director<#{visitor_generator.cpp_class_name}>()
             .define_constructor(Constructor<#{visitor_generator.cpp_class_name}, Object>())
             .define_method("visit", &#{visitor_generator.cpp_class_name}::ruby_visit)
             .define_method("visit_children", &#{visitor_generator.cpp_class_name}::ruby_visitChildren)
         #{visitor_generator.visitor_proxy_methods('    ').join("\n")};
 
+          rb_cParser = define_class_under<ParserProxy>(rb_m#{parser_ns}, "Parser")
+            .define_singleton_function("parse", &ParserProxy::parse)
+            .define_singleton_function("parse_file", &ParserProxy::parseFile)
+            .define_method("#{parser_root_method}", &ParserProxy::#{parser_root_method})
+            .define_method("visit", &ParserProxy::visit);
+
         #{class_wrappers_str('  ')}
         }
       END
@@ -363,7 +375,7 @@ module Antlr4Native
           [
             "  #{idx == 0 ? 'if' : 'else if'} (antlrcpp::is<#{parser_ns}::#{context.name}*>(node)) {",
             "    #{context.name}Proxy proxy((#{parser_ns}::#{context.name}*)node);",
-            "    return to_ruby(proxy);",
+            "    return detail::To_Ruby<#{context.name}Proxy>().convert(proxy);",
             "  }"
           ]
         end
@@ -373,7 +385,7 @@ module Antlr4Native
           #{wrapper_branches.join("\n")}
             else if (antlrcpp::is<tree::TerminalNodeImpl*>(node)) {
               TerminalNodeProxy proxy(node);
-              return to_ruby(proxy);
+              return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
             } else {
               return Nil;
             }

data/lib/antlr4-native/version.rb

@@ -1,3 +1,3 @@
 module Antlr4Native
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/lib/antlr4-native/visitor_generator.rb

@@ -47,12 +47,20 @@ module Antlr4Native
 
           Object ruby_visit(ContextProxy* proxy) {
             auto result = visit(proxy -> getOriginal());
-            return result.as<Object>();
+            try {
+              return result.as<Object>();
+            } catch(std::bad_cast) {
+              return Qnil;
+            }
           }
 
           Object ruby_visitChildren(ContextProxy* proxy) {
             auto result = visitChildren(proxy -> getOriginal());
-            return result.as<Object>();
+            try {
+              return result.as<Object>();
+            } catch(std::bad_cast) {
+              return Qnil;
+            }
           }
 
         #{vms.join("\n")}

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: antlr4-native
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
-dependencies: []
+date: 2022-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: Create a Ruby native extension from any ANTLR4 grammar.
 email:
 - camertron@gmail.com
@@ -48,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Create a Ruby native extension from any ANTLR4 grammar.