antlr4-native 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51499ca3096bdcbe0ce2e2231e9574b170a96acedeebc813f0e2c69134aa04f1
+  data.tar.gz: 485568b468bbaf64646344e239d58191e7025238c824e21b639e8641d953b118
+SHA512:
+  metadata.gz: 65ccf82166ff334ac080850448093501c6a371a04f2084a820e3a8298af061af50330fda845815173011c66c08a0ad3e8b2b1026b201d5b419c21d82db8d2b4c
+  data.tar.gz: fb9a2983e52969af587ccb1e6a401825fade06ed13f437a86f5cb8b6289848ee13c7c9284c13c558e17a5e24a60b7eaecf24854de4465ca7d4ef4bbddd10e0c7

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'pry-byebug'
+end
+
+group :development, :test do
+  gem 'rake'
+end

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks

data/antlr4-native.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'antlr4-native/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'antlr4-native'
+  s.version  = ::Antlr4Native::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/camertron/antlr4-native-rb'
+
+  s.description = s.summary = 'Create a Ruby native extension from any ANTLR4 grammar.'
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'README.md', 'Rakefile', 'antlr4-native.gemspec']
+end

data/lib/antlr4-native/context.rb

@@ -0,0 +1,193 @@
+module Antlr4Native
+  class Context
+    include StringHelpers
+
+    attr_reader :name, :parser_ns, :cpp_parser_source
+
+    def initialize(name, parser_ns, cpp_parser_source)
+      @name = name
+      @parser_ns = parser_ns
+      @cpp_parser_source = cpp_parser_source
+    end
+
+    def each_context_method
+      return to_enum(__method__) unless block_given?
+
+      mtds.each do |mtd|
+        yield mtd if mtd.context_method?
+      end
+    end
+
+    def each_token_method
+      return to_enum(__method__) unless block_given?
+
+      mtds.each do |mtd|
+        yield mtd if mtd.token_method?
+      end
+    end
+
+    def proxy_class_variable
+      @proxy_class_variable ||= "rb_c#{name}"
+    end
+
+    def proxy_class_header
+      @proxy_class_header ||= begin
+        <<~END
+          class #{name}Proxy : public ContextProxy {
+          public:
+            #{name}Proxy(tree::ParseTree* ctx) : ContextProxy(ctx) {};
+          #{method_signatures_for(each_context_method)}
+          #{method_signatures_for(each_token_method)}
+          };
+        END
+      end
+    end
+
+    def method_signatures_for(mtds)
+      mtds
+        .map { |mtd| "  Object #{mtd.cpp_name}(#{mtd.raw_args});" }
+        .join("\n")
+    end
+
+    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);
+        }
+
+        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);
+        }
+      END
+    end
+
+    def proxy_class_methods
+      proxy_class_context_methods + proxy_class_token_methods
+    end
+
+    def proxy_class_context_methods
+      each_context_method.map do |ctx_method|
+        return_type = "#{capitalize(ctx_method.name)}Context"
+        return_proxy_type = "#{return_type}Proxy"
+        params = ctx_method.args.map(&:name).join(', ')
+
+        if ctx_method.returns_vector?
+          <<~END
+            Object #{name}Proxy::#{ctx_method.cpp_name}(#{ctx_method.raw_args}) {
+              Array a;
+
+              if (orig != nullptr) {
+                size_t count = ((#{parser_ns}::#{name}*)orig) -> #{ctx_method.name}(#{params}).size();
+
+                for (size_t i = 0; i < count; i ++) {
+                  a.push(#{ctx_method.name}At(i));
+                }
+              }
+
+              return a;
+            }
+          END
+        else
+          <<~END
+            Object #{name}Proxy::#{ctx_method.cpp_name}(#{ctx_method.raw_args}) {
+              if (orig == nullptr) {
+                return Qnil;
+              }
+
+              auto ctx = ((#{parser_ns}::#{name}*)orig) -> #{ctx_method.name}(#{params});
+
+              if (ctx == nullptr) {
+                return Qnil;
+              }
+
+              for (auto child : getChildren()) {
+                if (ctx == from_ruby<ContextProxy>(child).getOriginal()) {
+                  return child;
+                }
+              }
+
+              return Nil;
+            }
+          END
+        end
+      end
+    end
+
+    def proxy_class_token_methods
+      each_token_method.map do |token_mtd|
+        params = token_mtd.args.map(&:name).join(', ')
+
+        if token_mtd.returns_vector?
+          <<~END
+            Object #{name}Proxy::#{token_mtd.cpp_name}(#{token_mtd.raw_args}) {
+              Array a;
+
+              if (orig == nullptr) {
+                return 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);
+              }
+
+              return a;
+            }
+          END
+        else
+          <<~END
+            Object #{name}Proxy::#{token_mtd.cpp_name}(#{token_mtd.raw_args}) {
+              if (orig == nullptr) {
+                return Qnil;
+              }
+
+              auto token = ((#{parser_ns}::#{name}*)orig) -> #{token_mtd.name}(#{params});
+              TerminalNodeProxy proxy(token);
+              return to_ruby(proxy);
+            }
+          END
+        end
+      end
+    end
+
+    def class_wrapper(module_var)
+      @class_wrapper ||= begin
+        lines = [
+          "#{proxy_class_variable} = #{module_var}",
+          ".define_class<#{name}Proxy, ContextProxy>(\"#{name}\")"
+        ]
+
+        each_context_method do |ctx_method|
+          lines << ".define_method(\"#{underscore(ctx_method.cpp_name)}\", &#{name}Proxy::#{ctx_method.cpp_name})"
+        end
+
+        each_token_method do |token_method|
+          lines << ".define_method(\"#{token_method.cpp_name}\", &#{name}Proxy::#{token_method.name})"
+        end
+
+        lines[-1] << ';'
+
+        lines
+      end
+    end
+
+    private
+
+    def mtds
+      @mtds ||= begin
+        puts "Finding methods for #{name}"
+
+        cpp_parser_source
+          .scan(/^([^\n]+) #{parser_ns}::#{name}::([^\(]*)\(([^\)]*)\)/).flat_map do |return_type, mtd_name, args|
+            ContextMethod.new(mtd_name, args, return_type, self)
+          end
+      end
+    end
+  end
+end

data/lib/antlr4-native/context_method.rb

@@ -0,0 +1,59 @@
+module Antlr4Native
+  class ContextMethod
+    RULE_METHODS = %w(enterRule exitRule getRuleIndex).freeze
+    META_METHODS = %w(accept copyFrom).freeze
+
+    attr_reader :name, :raw_args, :return_type, :context
+
+    def initialize(name, raw_args, return_type, context)
+      @name = name
+      @raw_args = raw_args
+      @return_type = return_type
+      @context = context
+    end
+
+    def cpp_name
+      @cpp_name ||=
+        if args.size == 1 && args.first.name == 'i'
+          # special case
+          "#{name}At"
+        else
+          [name, *args.map(&:name)].join('_')
+        end
+    end
+
+    def args
+      @args ||= raw_args.split(',').map do |arg|
+        ContextMethodArg.new(arg.strip)
+      end
+    end
+
+    def returns_vector?
+      return_type.start_with?('std::vector')
+    end
+
+    # @TODO: consider revising this
+    def context_method?
+      !token_method? &&
+        !rule_method? &&
+        !meta_method? &&
+        !constructor?
+    end
+
+    def token_method?
+      name[0].upcase == name[0]
+    end
+
+    def rule_method?
+      RULE_METHODS.include?(name)
+    end
+
+    def meta_method?
+      META_METHODS.include?(name)
+    end
+
+    def constructor?
+      name == context.name
+    end
+  end
+end

data/lib/antlr4-native/context_method_arg.rb

@@ -0,0 +1,27 @@
+module Antlr4Native
+  class ContextMethodArg
+    attr_reader :raw_arg
+
+    def initialize(raw_arg)
+      @raw_arg = raw_arg
+    end
+
+    def name
+      @name ||= parts[1]
+    end
+
+    def type
+      @type ||= parts[0].gsub(' ', '')
+    end
+
+    def pointer?
+      type.end_with?('*')
+    end
+
+    private
+
+    def parts
+      @parts ||= raw_arg.scan(/([\w\d:]+\s?\*?\s?)/).flatten
+    end
+  end
+end

data/lib/antlr4-native/generator.rb

@@ -0,0 +1,416 @@
+require 'fileutils'
+
+module Antlr4Native
+  class Generator
+    ANTLR_VERSION = '4.8'.freeze
+
+    ANTLR_JAR = File.expand_path(
+      File.join('..', '..', 'vendor', 'antlr4-4.8-1-complete.jar'), __dir__
+    ).freeze
+
+    include StringHelpers
+
+    attr_reader :grammar_files, :output_dir, :parser_root_method
+
+    def initialize(grammar_files:, output_dir:, parser_root_method:)
+      @grammar_files = grammar_files
+      @output_dir = output_dir
+      @parser_root_method = parser_root_method
+    end
+
+    def generate
+      generate_antlr_code
+      write_interop_file
+    end
+
+    def gem_name
+      @gem_name ||= dasherize(parser_ns)
+    end
+
+    def antlr_ns
+      grammar_names['parser'] || grammar_names['default']
+    end
+
+    def parser_ns
+      @parser_ns ||= grammar_names['parser'] || "#{grammar_names['default']}Parser"
+    end
+
+    def lexer_ns
+      @lexer_ns ||= grammar_names['lexer'] || "#{grammar_names['default']}Lexer"
+    end
+
+    def ext_name
+      @ext_name ||= underscore(parser_ns)
+    end
+
+    private
+
+    def generate_antlr_code
+      FileUtils.mkdir_p(antlrgen_dir)
+
+      system(<<~END)
+        java -jar #{ANTLR_JAR} \
+          -o #{antlrgen_dir} \
+          -Dlanguage=Cpp \
+          -visitor \
+          #{grammar_files.join(' ')}
+      END
+    end
+
+    def write_interop_file
+      File.write(interop_file, interop_code)
+    end
+
+    def interop_code
+      <<~END
+        #include "iostream"
+
+        #include "antlr4-runtime.h"
+
+        #include "#{parser_ns}.h"
+        #include "#{antlr_ns}BaseVisitor.h"
+        #include "#{lexer_ns}.h"
+
+        #include "rice/Array.hpp"
+        #include "rice/Class.hpp"
+        #include "rice/Constructor.hpp"
+        #include "rice/Director.hpp"
+
+        using namespace std;
+        using namespace Rice;
+        using namespace antlr4;
+
+        #{proxy_class_declarations}
+
+        class ContextProxy {
+        public:
+          ContextProxy(tree::ParseTree* orig) {
+            this -> orig = orig;
+          }
+
+          tree::ParseTree* getOriginal() {
+            return orig;
+          }
+
+          std::string getText() {
+            return orig -> getText();
+          }
+
+          Array getChildren() {
+            if (children == nullptr) {
+              children = new Array();
+
+              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;
+          }
+
+          Object getParent() {
+            if (parent == Nil) {
+              if (orig != nullptr) {
+                parent = ContextProxy::wrapParseTree(orig -> parent);
+              }
+            }
+
+            return parent;
+          }
+
+          size_t childCount() {
+            if (orig == nullptr) {
+              return 0;
+            }
+
+            return getChildren().size();
+          }
+
+          bool doubleEquals(Object other) {
+            if (other.is_a(rb_cContextProxy)) {
+              return from_ruby<ContextProxy*>(other) -> getOriginal() == getOriginal();
+            } else {
+              return false;
+            }
+          }
+
+        private:
+
+          static Object wrapParseTree(tree::ParseTree* node);
+
+        protected:
+          tree::ParseTree* orig = nullptr;
+          Array* children = nullptr;
+          Object parent = Nil;
+        };
+
+        class TerminalNodeProxy : public ContextProxy {
+        public:
+          TerminalNodeProxy(tree::ParseTree* tree) : ContextProxy(tree) { }
+        };
+
+        #{proxy_class_headers}
+
+        #{conversions}
+
+        #{proxy_class_methods}
+
+        #{visitor_generator.visitor_proxy}
+
+        #{parser_class}
+
+        #{context_proxy_methods}
+
+        #{init_function}
+      END
+    end
+
+    def proxy_class_headers
+      @proxy_class_headers ||= contexts
+        .map(&:proxy_class_header)
+        .join("\n")
+    end
+
+    def proxy_class_declarations
+      @proxy_class_declarations ||= contexts
+        .map { |ctx| "Class #{ctx.proxy_class_variable};" }
+        .concat([
+          'Class rb_cToken;',
+          'Class rb_cParser;',
+          'Class rb_cParseTree;',
+          'Class rb_cTerminalNode;',
+          'Class rb_cContextProxy;'
+        ])
+        .join("\n")
+    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
+    end
+
+    def proxy_class_methods
+      @proxy_class_methods ||= contexts.flat_map(&:proxy_class_methods).join("\n")
+    end
+
+    def parser_class
+      @parser_class ||= <<~END
+        class ParserProxy {
+        public:
+          static ParserProxy* parse(string code) {
+            auto input = new ANTLRInputStream(code);
+            return parseStream(input);
+          }
+
+          static ParserProxy* parseFile(string file) {
+            ifstream stream;
+            stream.open(file);
+
+            auto input = new ANTLRInputStream(stream);
+            auto parser = parseStream(input);
+
+            stream.close();
+
+            return parser;
+          }
+
+          VALUE visit(VisitorProxy* visitor) {
+            visitor -> visit(this -> parser -> #{parser_root_method}());
+
+            // reset for the next visit call
+            this -> lexer -> reset();
+            this -> parser -> reset();
+
+            return Qnil;
+          }
+
+          ~ParserProxy() {
+            delete this -> parser;
+            delete this -> tokens;
+            delete this -> lexer;
+            delete this -> input;
+          }
+
+        private:
+          static ParserProxy* parseStream(ANTLRInputStream* input) {
+            ParserProxy* parser = new ParserProxy();
+
+            parser -> input = input;
+            parser -> lexer = new #{lexer_ns}(parser -> input);
+            parser -> tokens = new CommonTokenStream(parser -> lexer);
+            parser -> parser = new #{parser_ns}(parser -> tokens);
+
+            return parser;
+          }
+
+          ParserProxy() {};
+
+          ANTLRInputStream* input;
+          #{lexer_ns}* lexer;
+          CommonTokenStream* tokens;
+          #{parser_ns}* parser;
+        };
+
+        template <>
+        Object to_ruby<ParserProxy*>(ParserProxy* const &x) {
+          if (!x) return Nil;
+          return Data_Object<ParserProxy>(x, rb_cParser, nullptr, nullptr);
+        }
+      END
+    end
+
+    def init_function
+      <<~END
+        extern "C"
+        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_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 = rb_m#{parser_ns}
+            .define_class<tree::ParseTree>("ParseTree");
+
+          rb_cContextProxy = rb_m#{parser_ns}
+            .define_class<ContextProxy>("Context")
+            .define_method("children", &ContextProxy::getChildren)
+            .define_method("child_count", &ContextProxy::childCount)
+            .define_method("text", &ContextProxy::getText)
+            .define_method("parent", &ContextProxy::getParent)
+            .define_method("==", &ContextProxy::doubleEquals);
+
+          rb_cTerminalNode = rb_mPython3Parser
+            .define_class<TerminalNodeProxy, ContextProxy>("TerminalNodeImpl");
+
+          rb_m#{parser_ns}
+            .define_class<#{visitor_generator.cpp_class_name}>("#{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")};
+
+        #{class_wrappers_str('  ')}
+        }
+      END
+    end
+
+    def context_proxy_methods
+      @context_proxy_methods ||= begin
+        wrapper_branches = contexts.flat_map.with_index do |context, idx|
+          [
+            "  #{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);",
+            "  }"
+          ]
+        end
+
+        <<~END
+          Object ContextProxy::wrapParseTree(tree::ParseTree* node) {
+          #{wrapper_branches.join("\n")}
+            else if (antlrcpp::is<tree::TerminalNodeImpl*>(node)) {
+              TerminalNodeProxy proxy(node);
+              return to_ruby(proxy);
+            } else {
+              return Nil;
+            }
+          }
+        END
+      end
+    end
+
+    def class_wrappers_str(indent)
+      class_wrappers.map do |cw|
+        ["#{indent}#{cw[0]}", *cw[1..-1].map { |line| "#{indent}  #{line}" }].join("\n")
+      end.join("\n\n")
+    end
+
+    def class_wrappers
+      @class_wrappers ||= contexts.map do |ctx|
+        ctx.class_wrapper("rb_m#{parser_ns}")
+      end
+    end
+
+    def contexts
+      @contexts ||= cpp_parser_source
+        .scan(/#{parser_ns}::([^\s:\(\)]+Context)/)
+        .flatten
+        .uniq
+        .reject { |c| c == '_sharedContext' }
+        .map { |name| Context.new(name, parser_ns, cpp_parser_source) }
+    end
+
+    def visitor_methods
+      @visitor_methods ||= cpp_visitor_source
+        .scan(/visit[A-Z][^\(\s]*/)
+        .flatten
+        .uniq
+    end
+
+    def visitor_generator
+      @visitor_generator ||= VisitorGenerator.new(visitor_methods, antlr_ns, parser_ns)
+    end
+
+    def antlrgen_dir
+      @antlrgen_dir ||= File.join(output_dir, gem_name, 'antlrgen')
+    end
+
+    def interop_file
+      @interop_file ||= File.join(output_dir, gem_name, "#{ext_name}.cpp")
+    end
+
+    def grammar_names
+      @grammar_names ||= begin
+        grammar_files.each_with_object({}) do |grammar_file, ret|
+          kind, name = File.read(grammar_file).scan(/^(parser|lexer)?\s*grammar\s*([^;]+);/).flatten
+          ret[kind&.strip || 'default'] = name
+        end
+      end
+    end
+
+    def cpp_parser_source
+      @cpp_parser_source ||= File.read(File.join(antlrgen_dir, "#{parser_ns}.cpp"))
+    end
+
+    def cpp_visitor_source
+      @cpp_visitor_source ||= File.read(File.join(antlrgen_dir, "#{antlr_ns}BaseVisitor.h"))
+    end
+  end
+end

data/lib/antlr4-native/string_helpers.rb

@@ -0,0 +1,21 @@
+module Antlr4Native
+  module StringHelpers
+    def capitalize(str)
+      str.sub(/\A(.)/) { $1.upcase }
+    end
+
+    def underscore(str)
+      str
+        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .gsub('-', '_')
+        .downcase
+    end
+
+    def dasherize(str)
+      underscore(str).gsub('_', '-')
+    end
+  end
+
+  StringHelpers.extend(StringHelpers)
+end

data/lib/antlr4-native/version.rb

@@ -0,0 +1,3 @@
+module Antlr4Native
+  VERSION = '1.0.0'
+end

data/lib/antlr4-native/visitor_generator.rb

@@ -0,0 +1,69 @@
+module Antlr4Native
+  class VisitorGenerator
+    VISITOR_METHOD_BLACKLIST = %w(visit visitChildren).freeze
+
+    include StringHelpers
+
+    attr_reader :visitor_methods, :antlr_ns, :parser_ns
+
+    def initialize(visitor_methods, antlr_ns, parser_ns)
+      @visitor_methods = visitor_methods
+      @antlr_ns = antlr_ns
+      @parser_ns = parser_ns
+    end
+
+    def class_name
+      @class_name ||= 'Visitor'
+    end
+
+    def cpp_class_name
+      @cpp_class_name ||= 'VisitorProxy'
+    end
+
+    def each_visitor_method
+      return to_enum(__method__) unless block_given?
+
+      visitor_methods.each do |visitor_method|
+        yield visitor_method unless VISITOR_METHOD_BLACKLIST.include?(visitor_method)
+      end
+    end
+
+    def visitor_proxy
+      vms = each_visitor_method.flat_map do |visitor_method|
+        context = "#{capitalize(visitor_method.sub(/\Avisit/, ''))}Context"
+
+        [
+          "  virtual antlrcpp::Any #{visitor_method}(#{parser_ns}::#{context} *ctx) override {",
+          "    #{context}Proxy proxy(ctx);",
+          "    return getSelf().call(\"#{underscore(visitor_method)}\", &proxy);",
+          "  }\n"
+        ]
+      end
+
+      <<~END
+        class #{cpp_class_name} : public #{antlr_ns}BaseVisitor, public Director {
+        public:
+          #{cpp_class_name}(Object self) : Director(self) { }
+
+          Object ruby_visit(ContextProxy* proxy) {
+            visit(proxy -> getOriginal());
+            return Nil;
+          }
+
+          Object ruby_visitChildren(ContextProxy* proxy) {
+            visitChildren(proxy -> getOriginal());
+            return Nil;
+          }
+
+        #{vms.join("\n")}
+        };
+      END
+    end
+
+    def visitor_proxy_methods(indent)
+      @visitor_proxy_methods ||= each_visitor_method.map do |visitor_method|
+        "#{indent}.define_method(\"#{underscore(visitor_method)}\", &#{cpp_class_name}::ruby_visitChildren)"
+      end
+    end
+  end
+end

data/lib/antlr4-native.rb

@@ -0,0 +1,8 @@
+module Antlr4Native
+  autoload :Context,          'antlr4-native/context'
+  autoload :ContextMethod,    'antlr4-native/context_method'
+  autoload :ContextMethodArg, 'antlr4-native/context_method_arg'
+  autoload :Generator,        'antlr4-native/generator'
+  autoload :StringHelpers,    'antlr4-native/string_helpers'
+  autoload :VisitorGenerator, 'antlr4-native/visitor_generator'
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: antlr4-native
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-01 00:00:00.000000000 Z
+dependencies: []
+description: Create a Ruby native extension from any ANTLR4 grammar.
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- antlr4-native.gemspec
+- lib/antlr4-native.rb
+- lib/antlr4-native/context.rb
+- lib/antlr4-native/context_method.rb
+- lib/antlr4-native/context_method_arg.rb
+- lib/antlr4-native/generator.rb
+- lib/antlr4-native/string_helpers.rb
+- lib/antlr4-native/version.rb
+- lib/antlr4-native/visitor_generator.rb
+homepage: http://github.com/camertron/antlr4-native-rb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Create a Ruby native extension from any ANTLR4 grammar.
+test_files: []