jruby-prism-parser 0.23.0.pre.SNAPSHOT-java

data/ext/prism/api_pack.c

@@ -0,0 +1,267 @@
+#include "prism/extension.h"
+
+static VALUE rb_cPrism;
+static VALUE rb_cPrismPack;
+static VALUE rb_cPrismPackDirective;
+static VALUE rb_cPrismPackFormat;
+
+static VALUE v3_2_0_symbol;
+static VALUE pack_symbol;
+static VALUE unpack_symbol;
+
+#if SIZEOF_UINT64_T == SIZEOF_LONG_LONG
+# define UINT64T2NUM(x) ULL2NUM(x)
+# define NUM2UINT64T(x) (uint64_t)NUM2ULL(x)
+#elif SIZEOF_UINT64_T == SIZEOF_LONG
+# define UINT64T2NUM(x) ULONG2NUM(x)
+# define NUM2UINT64T(x) (uint64_t)NUM2ULONG(x)
+#else
+// error No uint64_t conversion
+#endif
+
+static VALUE
+pack_type_to_symbol(pm_pack_type type) {
+    switch (type) {
+        case PM_PACK_SPACE:
+            return ID2SYM(rb_intern("SPACE"));
+        case PM_PACK_COMMENT:
+            return ID2SYM(rb_intern("COMMENT"));
+        case PM_PACK_INTEGER:
+            return ID2SYM(rb_intern("INTEGER"));
+        case PM_PACK_UTF8:
+            return ID2SYM(rb_intern("UTF8"));
+        case PM_PACK_BER:
+            return ID2SYM(rb_intern("BER"));
+        case PM_PACK_FLOAT:
+            return ID2SYM(rb_intern("FLOAT"));
+        case PM_PACK_STRING_SPACE_PADDED:
+            return ID2SYM(rb_intern("STRING_SPACE_PADDED"));
+        case PM_PACK_STRING_NULL_PADDED:
+            return ID2SYM(rb_intern("STRING_NULL_PADDED"));
+        case PM_PACK_STRING_NULL_TERMINATED:
+            return ID2SYM(rb_intern("STRING_NULL_TERMINATED"));
+        case PM_PACK_STRING_MSB:
+            return ID2SYM(rb_intern("STRING_MSB"));
+        case PM_PACK_STRING_LSB:
+            return ID2SYM(rb_intern("STRING_LSB"));
+        case PM_PACK_STRING_HEX_HIGH:
+            return ID2SYM(rb_intern("STRING_HEX_HIGH"));
+        case PM_PACK_STRING_HEX_LOW:
+            return ID2SYM(rb_intern("STRING_HEX_LOW"));
+        case PM_PACK_STRING_UU:
+            return ID2SYM(rb_intern("STRING_UU"));
+        case PM_PACK_STRING_MIME:
+            return ID2SYM(rb_intern("STRING_MIME"));
+        case PM_PACK_STRING_BASE64:
+            return ID2SYM(rb_intern("STRING_BASE64"));
+        case PM_PACK_STRING_FIXED:
+            return ID2SYM(rb_intern("STRING_FIXED"));
+        case PM_PACK_STRING_POINTER:
+            return ID2SYM(rb_intern("STRING_POINTER"));
+        case PM_PACK_MOVE:
+            return ID2SYM(rb_intern("MOVE"));
+        case PM_PACK_BACK:
+            return ID2SYM(rb_intern("BACK"));
+        case PM_PACK_NULL:
+            return ID2SYM(rb_intern("NULL"));
+        default:
+            return Qnil;
+    }
+}
+
+static VALUE
+pack_signed_to_symbol(pm_pack_signed signed_type) {
+    switch (signed_type) {
+        case PM_PACK_UNSIGNED:
+            return ID2SYM(rb_intern("UNSIGNED"));
+        case PM_PACK_SIGNED:
+            return ID2SYM(rb_intern("SIGNED"));
+        case PM_PACK_SIGNED_NA:
+            return ID2SYM(rb_intern("SIGNED_NA"));
+        default:
+            return Qnil;
+    }
+}
+
+static VALUE
+pack_endian_to_symbol(pm_pack_endian endian) {
+    switch (endian) {
+        case PM_PACK_AGNOSTIC_ENDIAN:
+            return ID2SYM(rb_intern("AGNOSTIC_ENDIAN"));
+        case PM_PACK_LITTLE_ENDIAN:
+            return ID2SYM(rb_intern("LITTLE_ENDIAN"));
+        case PM_PACK_BIG_ENDIAN:
+            return ID2SYM(rb_intern("BIG_ENDIAN"));
+        case PM_PACK_NATIVE_ENDIAN:
+            return ID2SYM(rb_intern("NATIVE_ENDIAN"));
+        case PM_PACK_ENDIAN_NA:
+            return ID2SYM(rb_intern("ENDIAN_NA"));
+        default:
+            return Qnil;
+    }
+}
+
+static VALUE
+pack_size_to_symbol(pm_pack_size size) {
+    switch (size) {
+        case PM_PACK_SIZE_SHORT:
+            return ID2SYM(rb_intern("SIZE_SHORT"));
+        case PM_PACK_SIZE_INT:
+            return ID2SYM(rb_intern("SIZE_INT"));
+        case PM_PACK_SIZE_LONG:
+            return ID2SYM(rb_intern("SIZE_LONG"));
+        case PM_PACK_SIZE_LONG_LONG:
+            return ID2SYM(rb_intern("SIZE_LONG_LONG"));
+        case PM_PACK_SIZE_8:
+            return ID2SYM(rb_intern("SIZE_8"));
+        case PM_PACK_SIZE_16:
+            return ID2SYM(rb_intern("SIZE_16"));
+        case PM_PACK_SIZE_32:
+            return ID2SYM(rb_intern("SIZE_32"));
+        case PM_PACK_SIZE_64:
+            return ID2SYM(rb_intern("SIZE_64"));
+        case PM_PACK_SIZE_P:
+            return ID2SYM(rb_intern("SIZE_P"));
+        case PM_PACK_SIZE_NA:
+            return ID2SYM(rb_intern("SIZE_NA"));
+        default:
+            return Qnil;
+    }
+}
+
+static VALUE
+pack_length_type_to_symbol(pm_pack_length_type length_type) {
+    switch (length_type) {
+        case PM_PACK_LENGTH_FIXED:
+            return ID2SYM(rb_intern("LENGTH_FIXED"));
+        case PM_PACK_LENGTH_MAX:
+            return ID2SYM(rb_intern("LENGTH_MAX"));
+        case PM_PACK_LENGTH_RELATIVE:
+            return ID2SYM(rb_intern("LENGTH_RELATIVE"));
+        case PM_PACK_LENGTH_NA:
+            return ID2SYM(rb_intern("LENGTH_NA"));
+        default:
+            return Qnil;
+    }
+}
+
+static VALUE
+pack_encoding_to_ruby(pm_pack_encoding encoding) {
+    int index;
+    switch (encoding) {
+        case PM_PACK_ENCODING_ASCII_8BIT:
+            index = rb_ascii8bit_encindex();
+            break;
+        case PM_PACK_ENCODING_US_ASCII:
+            index = rb_usascii_encindex();
+            break;
+        case PM_PACK_ENCODING_UTF_8:
+            index = rb_utf8_encindex();
+            break;
+        default:
+            return Qnil;
+    }
+    return rb_enc_from_encoding(rb_enc_from_index(index));
+}
+
+/**
+ * call-seq:
+ *   Pack::parse(version, variant, source) -> Format
+ *
+ * Parse the given source and return a format object.
+ */
+static VALUE
+pack_parse(VALUE self, VALUE version_symbol, VALUE variant_symbol, VALUE format_string) {
+    if (version_symbol != v3_2_0_symbol) {
+        rb_raise(rb_eArgError, "invalid version");
+    }
+
+    pm_pack_variant variant;
+    if (variant_symbol == pack_symbol) {
+        variant = PM_PACK_VARIANT_PACK;
+    } else if (variant_symbol == unpack_symbol) {
+        variant = PM_PACK_VARIANT_UNPACK;
+    } else {
+        rb_raise(rb_eArgError, "invalid variant");
+    }
+
+    StringValue(format_string);
+
+    const char *format = RSTRING_PTR(format_string);
+    const char *format_end = format + RSTRING_LEN(format_string);
+    pm_pack_encoding encoding = PM_PACK_ENCODING_START;
+
+    VALUE directives_array = rb_ary_new();
+
+    while (format < format_end) {
+        pm_pack_type type;
+        pm_pack_signed signed_type;
+        pm_pack_endian endian;
+        pm_pack_size size;
+        pm_pack_length_type length_type;
+        uint64_t length;
+
+        const char *directive_start = format;
+
+        pm_pack_result parse_result = pm_pack_parse(variant, &format, format_end, &type, &signed_type, &endian,
+                                                    &size, &length_type, &length, &encoding);
+
+        const char *directive_end = format;
+
+        switch (parse_result) {
+            case PM_PACK_OK:
+                break;
+            case PM_PACK_ERROR_UNSUPPORTED_DIRECTIVE:
+                rb_raise(rb_eArgError, "unsupported directive");
+            case PM_PACK_ERROR_UNKNOWN_DIRECTIVE:
+                rb_raise(rb_eArgError, "unsupported directive");
+            case PM_PACK_ERROR_LENGTH_TOO_BIG:
+                rb_raise(rb_eRangeError, "pack length too big");
+            case PM_PACK_ERROR_BANG_NOT_ALLOWED:
+                rb_raise(rb_eRangeError, "bang not allowed");
+            case PM_PACK_ERROR_DOUBLE_ENDIAN:
+                rb_raise(rb_eRangeError, "double endian");
+            default:
+                rb_bug("parse result");
+        }
+
+        if (type == PM_PACK_END) {
+            break;
+        }
+
+        VALUE directive_args[9] = {
+            version_symbol,
+            variant_symbol,
+            rb_usascii_str_new(directive_start, directive_end - directive_start),
+            pack_type_to_symbol(type),
+            pack_signed_to_symbol(signed_type),
+            pack_endian_to_symbol(endian),
+            pack_size_to_symbol(size),
+            pack_length_type_to_symbol(length_type),
+            UINT64T2NUM(length)
+        };
+
+        rb_ary_push(directives_array, rb_class_new_instance(9, directive_args, rb_cPrismPackDirective));
+    }
+
+    VALUE format_args[2];
+    format_args[0] = directives_array;
+    format_args[1] = pack_encoding_to_ruby(encoding);
+    return rb_class_new_instance(2, format_args, rb_cPrismPackFormat);
+}
+
+/**
+ * The function that gets called when Ruby initializes the prism extension.
+ */
+void
+Init_prism_pack(void) {
+    rb_cPrism = rb_define_module("Prism");
+    rb_cPrismPack = rb_define_module_under(rb_cPrism, "Pack");
+    rb_cPrismPackDirective = rb_define_class_under(rb_cPrismPack, "Directive", rb_cObject);
+    rb_cPrismPackFormat = rb_define_class_under(rb_cPrismPack, "Format", rb_cObject);
+    rb_define_singleton_method(rb_cPrismPack, "parse", pack_parse, 3);
+
+    v3_2_0_symbol = ID2SYM(rb_intern("v3_2_0"));
+    pack_symbol = ID2SYM(rb_intern("pack"));
+    unpack_symbol = ID2SYM(rb_intern("unpack"));
+}

data/ext/prism/extconf.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+if ARGV.delete("--help")
+  print(<<~TEXT)
+    USAGE: ruby #{$PROGRAM_NAME} [options]
+
+      Flags that are always valid:
+
+          --enable-debug-mode-build
+              Enable debug mode build.
+              You may also use set PRISM_DEBUG_MODE_BUILD environment variable.
+
+          --help
+              Display this message.
+
+      Environment variables used:
+
+          PRISM_DEBUG_MODE_BUILD
+              Equivalent to `--enable-debug-mode-build` when set, even if nil or blank.
+
+  TEXT
+  exit!(0)
+end
+
+# If this gem is being build from a git source, then we need to run
+# templating if it hasn't been run yet. In normal packaging, we would have
+# shipped the templated files with the gem, so this wouldn't be necessary.
+def generate_templates
+  Dir.chdir(File.expand_path("../..", __dir__)) do
+    if !File.exist?("include/prism/ast.h") && Dir.exist?(".git")
+      system("templates/template.rb", exception: true)
+    end
+  end
+end
+
+# Runs `make` in the root directory of the project. Note that this is the
+# `Makefile` for the overall project, not the `Makefile` that is being generated
+# by this script.`
+def make(target)
+  Dir.chdir(File.expand_path("../..", __dir__)) do
+    system("make", target, exception: true)
+  end
+end
+
+require "rbconfig"
+
+# On non-CRuby we only need the shared library since we'll interface with it
+# through FFI, so we'll build only that and not the C extension. We also avoid
+# `require "mkmf"` as that prepends the LLVM toolchain to PATH on TruffleRuby,
+# but we want to use the native toolchain here since libprism is run natively.
+if RUBY_ENGINE != "ruby"
+  require 'fileutils'
+  generate_templates
+  lib_file = "build/libprism.#{RbConfig::CONFIG["SOEXT"]}"
+  make(lib_file)
+  FileUtils.cp "../../#{lib_file}", RbConfig::CONFIG["libdir"]
+  FileUtils.cp "../../jruby-prism.jar", "#{RbConfig::CONFIG['libdir']}/jruby-prism.jar"
+  File.write("Makefile", "all install clean:\n\t@#{RbConfig::CONFIG["NULLCMD"]}\n")
+  return
+end
+
+require "mkmf"
+
+# First, ensure that we can find the header for the prism library.
+generate_templates # Templates should be generated before find_header.
+unless find_header("prism.h", File.expand_path("../../include", __dir__))
+  raise "prism.h is required"
+end
+
+# Next, ensure we can find the header for the C extension. Explicitly look for
+# the extension header in the parent directory because we want to consistently
+# look for `prism/extension.h` in our source files to line up with our mirroring
+# in CRuby.
+unless find_header("prism/extension.h", File.expand_path("..", __dir__))
+  raise "prism/extension.h is required"
+end
+
+# If `--enable-debug-mode-build` is passed to this script or the
+# `PRISM_DEBUG_MODE_BUILD` environment variable is defined, we'll build with the
+# `PRISM_DEBUG_MODE_BUILD` macro defined. This causes parse functions to
+# duplicate their input so that they have clearly set bounds, which is useful
+# for finding bugs that cause the parser to read off the end of the input.
+if enable_config("debug-mode-build", ENV["PRISM_DEBUG_MODE_BUILD"] || false)
+  append_cflags("-DPRISM_DEBUG_MODE_BUILD")
+end
+
+# By default, all symbols are hidden in the shared library.
+append_cflags("-fvisibility=hidden")
+
+# We need to link against the libprism.a archive, which is built by the
+# project's `Makefile`. We'll build it if it doesn't exist yet, and then add it
+# to `mkmf`'s list of local libraries.
+archive_target = "build/libprism.a"
+archive_path = File.expand_path("../../#{archive_target}", __dir__)
+
+make(archive_target) unless File.exist?(archive_path)
+$LOCAL_LIBS << " #{archive_path}"
+
+# Finally, we'll create the `Makefile` that is going to be used to configure and
+# build the C extension.
+create_makefile("prism/prism")
+
+# Now that the `Makefile` for the C extension is built, we'll append on an extra
+# rule that dictates that the extension should be rebuilt if the archive is
+# updated.
+File.open("Makefile", "a") do |mf|
+  mf.puts
+  mf.puts("# Automatically rebuild the extension if libprism.a changed")
+  mf.puts("$(TARGET_SO): $(LOCAL_LIBS)")
+end