antlr4-native 1.0.2 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08bed362c4b5695e0e900adb1b9837f284d92e70b7bc2006467bc1888d39f12c'
-  data.tar.gz: 881aac540b1395c0f3e974f4c3d8a3f747ab695deeba95bd5d40c2c7924c5015
+  metadata.gz: ba388dfab9f2c91aec93eb1ae6ce3da83bff2777a921c14dca055e7c5ef06f82
+  data.tar.gz: 635a32e158d29328fdb181a636462ec5f73af777ab6c1bff24da13191d735f3b
 SHA512:
-  metadata.gz: d02e7aa15bced54e120e5bef5ff5d2be69919a83a0473e025feca86b7e2ee446e4b808a7d56959f3a6e13a2e55eb0666b805f189ad668fe66b68c49fcf2dcd30
-  data.tar.gz: bfa38b403307ffe88aff984d1713af1e7716629c0794512a4fcee432f60199510c588345d1f1005cc1be6ce0f4f68d4a97555024b11436739e2347c1d4877fab
+  metadata.gz: c019c9f3549d0b0d4f1aae071592a160d3e2fdd2c8a0bab89c24d34d2f81d0925c1a4f2b4d59f227988ce94b042011c2e910f63b20df14366d2956483f1eb11a
+  data.tar.gz: 658ec185e823312c7acd8f45d33ef249fed4f0f9125606b11e0d683ab2dc7150bac18a7e4fded01e8dfb40faa04f12c8ce3a42d647a872c43de6c76810d7d3d0

data/README.md

@@ -28,7 +28,7 @@ generator = Antlr4Native::Generator.new(
 generator.generate
 ```
 
-In the example above, the output directory is set to the standard Ruby native extensions directory, 'ext'. Antlr4-native will generate code into ext/<name>, where <name> is the name of the parser as defined in the grammar file(s). In this case, PythonParser.g4 contains:
+In the example above, the output directory is set to the standard Ruby native extensions directory, 'ext'. Antlr4-native will generate code into ext/\<name\>, where \<name\> is the name of the parser as defined in the grammar file(s). In this case, PythonParser.g4 contains:
 
 ```antlr
 parser grammar Python3Parser;
@@ -85,12 +85,13 @@ Finally, if you override `#initialize` in your visitor subclasses, don't forget
 
 ## System Requirements
 
-* A Java runtime (version 1.6 or higher) is required to generate parsers, since ANTLR is a Java tool. The ANTLR .jar file is distributed inside the antlr4-native gem, so there's no need to download it separately.
+* A Java runtime (version 1.6 or higher) is required to generate parsers, since ANTLR is a Java tool. The ANTLR .jar file is distributed inside the antlr4-native gem, so there's no need to download it separately. You can download a Java runtime [here](https://www.java.com/en/download/).
 * Ruby >= 2.3.
+* A C compiler (like gcc or clang) that supports C++14. If Ruby is working on your machine then you likely already have this.
 
 ## License
 
-Licensed under the MIT license. See LICENSE for details.
+Licensed under the MIT license. See LICENSE.txt for details.
 
 ## Authors
 

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
@@ -148,8 +156,13 @@ module Antlr4Native
               }
 
               auto token = ((#{parser_ns}::#{name}*)orig) -> #{token_mtd.name}(#{params});
+
+              if (token == nullptr) {
+                return Qnil;
+              }
+
               TerminalNodeProxy proxy(token);
-              return to_ruby(proxy);
+              return detail::To_Ruby<TerminalNodeProxy>().convert(proxy);
             }
           END
         end
@@ -159,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

@@ -63,18 +63,27 @@ module Antlr4Native
 
     def interop_code
       <<~END
-        #include "iostream"
+        #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 OPTIONAL
+        #undef IN
+        #undef OUT
+        #endif
+
+        #undef FALSE
+        #undef TRUE
+
+        #undef TYPE
 
         using namespace std;
         using namespace Rice;
@@ -82,6 +91,35 @@ module Antlr4Native
 
         #{proxy_class_declarations}
 
+        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 {
         public:
           ContextProxy(tree::ParseTree* orig) {
@@ -96,45 +134,43 @@ module Antlr4Native
             return orig -> getText();
           }
 
-          Array getChildren() {
-            if (children == nullptr) {
-              children = new Array();
+          Object getStart() {
+            auto token = ((ParserRuleContext*) orig) -> getStart();
 
-              if (orig != nullptr) {
-                for (auto it = orig -> children.begin(); it != orig -> children.end(); it ++) {
-                  Object parseTree = ContextProxy::wrapParseTree(*it);
+            return detail::To_Ruby<Token*>().convert(token);
+          }
 
-                  if (parseTree != Nil) {
-                    children -> push(parseTree);
-                  }
-                }
-              }
-            }
+          Object getStop() {
+            auto token = ((ParserRuleContext*) orig) -> getStop();
 
-            return *children;
+            return detail::To_Ruby<Token*>().convert(token);
           }
 
-          Object getParent() {
-            if (parent == Nil) {
-              if (orig != nullptr) {
-                parent = ContextProxy::wrapParseTree(orig -> parent);
+          Array getChildren() {
+            Array children;
+            if (orig != nullptr) {
+              for (auto it = orig -> children.begin(); it != orig -> children.end(); it ++) {
+                Object parseTree = ContextProxy::wrapParseTree(*it);
+
+                if (parseTree != Nil) {
+                  children.push(parseTree);
+                }
               }
             }
+            return children;
+          }
 
-            return parent;
+          Object getParent() {
+            return orig == nullptr ? Nil : ContextProxy::wrapParseTree(orig -> parent);
           }
 
           size_t childCount() {
-            if (orig == nullptr) {
-              return 0;
-            }
-
-            return getChildren().size();
+            return orig == nullptr ? 0 : orig -> children.size();
           }
 
           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;
             }
@@ -146,8 +182,6 @@ module Antlr4Native
 
         protected:
           tree::ParseTree* orig = nullptr;
-          Array* children = nullptr;
-          Object parent = Nil;
         };
 
         class TerminalNodeProxy : public ContextProxy {
@@ -155,6 +189,7 @@ module Antlr4Native
           TerminalNodeProxy(tree::ParseTree* tree) : ContextProxy(tree) { }
         };
 
+
         #{proxy_class_headers}
 
         #{conversions}
@@ -191,31 +226,7 @@ module Antlr4Native
     end
 
     def conversions
-      @conversions ||= begin
-        context_conversions = contexts.map(&:conversions).join("\n")
-
-        <<~END
-          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);
-          }
-
-          #{context_conversions}
-        END
-      end
+      @conversions ||= contexts.map(&:conversions).join("\n")
     end
 
     def proxy_class_methods
@@ -243,14 +254,21 @@ module Antlr4Native
             return parser;
           }
 
-          VALUE visit(VisitorProxy* visitor) {
-            visitor -> visit(this -> parser -> #{parser_root_method}());
+          Object #{parser_root_method}() {
+            auto ctx = this -> parser -> #{parser_root_method}();
+
+            #{capitalize(parser_root_method)}ContextProxy proxy((#{parser_ns}::#{capitalize(parser_root_method)}Context*) ctx);
+            return detail::To_Ruby<#{capitalize(parser_root_method)}ContextProxy>().convert(proxy);
+          }
+
+          Object visit(VisitorProxy* visitor) {
+            auto result = visitor -> visit(this -> parser -> #{parser_root_method}());
 
             // reset for the next visit call
             this -> lexer -> reset();
             this -> parser -> reset();
 
-            return Qnil;
+            return result;
           }
 
           ~ParserProxy() {
@@ -280,10 +298,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
@@ -294,38 +317,37 @@ 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")
-            .define_method("text", &Token::getText);
+          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("visit", &ParserProxy::visit);
+          rb_cParseTree = define_class_under<tree::ParseTree>(rb_m#{parser_ns}, "ParseTree");
 
-          rb_cParseTree = rb_m#{parser_ns}
-            .define_class<tree::ParseTree>("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)
+            .define_method("start", &ContextProxy::getStart)
+            .define_method("stop", &ContextProxy::getStop)
             .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}, Return().keepAlive())
+            .define_method("visit", &ParserProxy::visit, Return().keepAlive());
+
         #{class_wrappers_str('  ')}
         }
       END
@@ -337,7 +359,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
@@ -347,7 +369,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.0.2'
+  VERSION = '2.0.1'
 end

data/lib/antlr4-native/visitor_generator.rb

@@ -46,13 +46,21 @@ module Antlr4Native
           #{cpp_class_name}(Object self) : Director(self) { }
 
           Object ruby_visit(ContextProxy* proxy) {
-            visit(proxy -> getOriginal());
-            return Nil;
+            auto result = visit(proxy -> getOriginal());
+            try {
+              return result.as<Object>();
+            } catch(std::bad_cast) {
+              return Qnil;
+            }
           }
 
           Object ruby_visitChildren(ContextProxy* proxy) {
-            visitChildren(proxy -> getOriginal());
-            return Nil;
+            auto result = visitChildren(proxy -> getOriginal());
+            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.0.2
+  version: 2.0.1
 platform: ruby
 authors:
 - Cameron Dutro
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-02 00:00:00.000000000 Z
-dependencies: []
+date: 2022-05-09 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
@@ -33,7 +47,7 @@ files:
 homepage: http://github.com/camertron/antlr4-native-rb
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -48,8 +62,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Create a Ruby native extension from any ANTLR4 grammar.
 test_files: []