jruby-prism-parser 0.24.0-java → 1.4.0-java

data/src/options.c

@@ -1,5 +1,14 @@
 #include "prism/options.h"
 
+/**
+ * Set the shebang callback option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_shebang_callback_set(pm_options_t *options, pm_options_shebang_callback_t shebang_callback, void *shebang_callback_data) {
+    options->shebang_callback = shebang_callback;
+    options->shebang_callback_data = shebang_callback_data;
+}
+
 /**
  * Set the filepath option on the given options struct.
  */
@@ -16,6 +25,14 @@ pm_options_encoding_set(pm_options_t *options, const char *encoding) {
     pm_string_constant_init(&options->encoding, encoding, strlen(encoding));
 }
 
+/**
+ * Set the encoding_locked option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_encoding_locked_set(pm_options_t *options, bool encoding_locked) {
+    options->encoding_locked = encoding_locked;
+}
+
 /**
  * Set the line option on the given options struct.
  */
@@ -29,7 +46,23 @@ pm_options_line_set(pm_options_t *options, int32_t line) {
  */
 PRISM_EXPORTED_FUNCTION void
 pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_literal) {
-    options->frozen_string_literal = frozen_string_literal;
+    options->frozen_string_literal = frozen_string_literal ? PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED : PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED;
+}
+
+/**
+ * Sets the command line option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_command_line_set(pm_options_t *options, uint8_t command_line) {
+    options->command_line = command_line;
+}
+
+/**
+ * Checks if the given slice represents a number.
+ */
+static inline bool
+is_number(const char *string, size_t length) {
+    return pm_strspn_decimal_digit((const uint8_t *) string, (ptrdiff_t) length) == length;
 }
 
 /**
@@ -39,39 +72,97 @@ pm_options_frozen_string_literal_set(pm_options_t *options, bool frozen_string_l
  */
 PRISM_EXPORTED_FUNCTION bool
 pm_options_version_set(pm_options_t *options, const char *version, size_t length) {
-    if (version == NULL && length == 0) {
+    if (version == NULL) {
         options->version = PM_OPTIONS_VERSION_LATEST;
         return true;
     }
 
-    if (length == 5) {
-        if (strncmp(version, "3.3.0", length) == 0) {
-            options->version = PM_OPTIONS_VERSION_CRUBY_3_3_0;
+    if (length == 3) {
+        if (strncmp(version, "3.3", 3) == 0) {
+            options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
+            return true;
+        }
+
+        if (strncmp(version, "3.4", 3) == 0) {
+            options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
             return true;
         }
 
-        if (strncmp(version, "3.4.0", length) == 0) {
+        if (strncmp(version, "3.5", 3) == 0) {
             options->version = PM_OPTIONS_VERSION_LATEST;
             return true;
         }
+
+        return false;
     }
 
-    if (length == 6 && strncmp(version, "latest", length) == 0) {
-        options->version = PM_OPTIONS_VERSION_LATEST;
-        return true;
+    if (length >= 4) {
+        if (strncmp(version, "3.3.", 4) == 0 && is_number(version + 4, length - 4)) {
+            options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
+            return true;
+        }
+
+        if (strncmp(version, "3.4.", 4) == 0 && is_number(version + 4, length - 4)) {
+            options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
+            return true;
+        }
+
+        if (strncmp(version, "3.5.", 4) == 0 && is_number(version + 4, length - 4)) {
+            options->version = PM_OPTIONS_VERSION_LATEST;
+            return true;
+        }
+    }
+
+    if (length >= 6) {
+        if (strncmp(version, "latest", 7) == 0) { // 7 to compare the \0 as well
+            options->version = PM_OPTIONS_VERSION_LATEST;
+            return true;
+        }
     }
 
     return false;
 }
 
 /**
- * Allocate and zero out the scopes array on the given options struct.
+ * Set the main script option on the given options struct.
  */
 PRISM_EXPORTED_FUNCTION void
+pm_options_main_script_set(pm_options_t *options, bool main_script) {
+    options->main_script = main_script;
+}
+
+/**
+ * Set the partial script option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_partial_script_set(pm_options_t *options, bool partial_script) {
+    options->partial_script = partial_script;
+}
+
+/**
+ * Set the freeze option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_freeze_set(pm_options_t *options, bool freeze) {
+    options->freeze = freeze;
+}
+
+// For some reason, GCC analyzer thinks we're leaking allocated scopes and
+// locals here, even though we definitely aren't. This is a false positive.
+// Ideally we wouldn't need to suppress this.
+#if defined(__GNUC__) && (__GNUC__ >= 10)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
+#endif
+
+/**
+ * Allocate and zero out the scopes array on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION bool
 pm_options_scopes_init(pm_options_t *options, size_t scopes_count) {
     options->scopes_count = scopes_count;
-    options->scopes = calloc(scopes_count, sizeof(pm_options_scope_t));
-    if (options->scopes == NULL) abort();
+    options->scopes = xcalloc(scopes_count, sizeof(pm_options_scope_t));
+    return options->scopes != NULL;
 }
 
 /**
@@ -86,11 +177,12 @@ pm_options_scope_get(const pm_options_t *options, size_t index) {
  * Create a new options scope struct. This will hold a set of locals that are in
  * scope surrounding the code that is being parsed.
  */
-PRISM_EXPORTED_FUNCTION void
+PRISM_EXPORTED_FUNCTION bool
 pm_options_scope_init(pm_options_scope_t *scope, size_t locals_count) {
     scope->locals_count = locals_count;
-    scope->locals = calloc(locals_count, sizeof(pm_string_t));
-    if (scope->locals == NULL) abort();
+    scope->locals = xcalloc(locals_count, sizeof(pm_string_t));
+    scope->forwarding = PM_OPTIONS_SCOPE_FORWARDING_NONE;
+    return scope->locals != NULL;
 }
 
 /**
@@ -101,6 +193,14 @@ pm_options_scope_local_get(const pm_options_scope_t *scope, size_t index) {
     return &scope->locals[index];
 }
 
+/**
+ * Set the forwarding option on the given scope struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_scope_forwarding_set(pm_options_scope_t *scope, uint8_t forwarding) {
+    scope->forwarding = forwarding;
+}
+
 /**
  * Free the internal memory associated with the options.
  */
@@ -116,10 +216,10 @@ pm_options_free(pm_options_t *options) {
             pm_string_free(&scope->locals[local_index]);
         }
 
-        free(scope->locals);
+        xfree(scope->locals);
     }
 
-    free(options->scopes);
+    xfree(options->scopes);
 }
 
 /**
@@ -185,21 +285,32 @@ pm_options_read(pm_options_t *options, const char *data) {
         data += encoding_length;
     }
 
-    options->frozen_string_literal = *data++;
+    options->frozen_string_literal = (int8_t) *data++;
+    options->command_line = (uint8_t) *data++;
     options->version = (pm_options_version_t) *data++;
+    options->encoding_locked = ((uint8_t) *data++) > 0;
+    options->main_script = ((uint8_t) *data++) > 0;
+    options->partial_script = ((uint8_t) *data++) > 0;
+    options->freeze = ((uint8_t) *data++) > 0;
 
     uint32_t scopes_count = pm_options_read_u32(data);
     data += 4;
 
     if (scopes_count > 0) {
-        pm_options_scopes_init(options, scopes_count);
+        if (!pm_options_scopes_init(options, scopes_count)) return;
 
         for (size_t scope_index = 0; scope_index < scopes_count; scope_index++) {
             uint32_t locals_count = pm_options_read_u32(data);
             data += 4;
 
             pm_options_scope_t *scope = &options->scopes[scope_index];
-            pm_options_scope_init(scope, locals_count);
+            if (!pm_options_scope_init(scope, locals_count)) {
+                pm_options_free(options);
+                return;
+            }
+
+            uint8_t forwarding = (uint8_t) *data++;
+            pm_options_scope_forwarding_set(&options->scopes[scope_index], forwarding);
 
             for (size_t local_index = 0; local_index < locals_count; local_index++) {
                 uint32_t local_length = pm_options_read_u32(data);
@@ -211,3 +322,7 @@ pm_options_read(pm_options_t *options, const char *data) {
         }
     }
 }
+
+#if defined(__GNUC__) && (__GNUC__ >= 10)
+#pragma GCC diagnostic pop
+#endif

data/src/pack.c

@@ -1,16 +1,43 @@
 #include "prism/pack.h"
 
+// We optionally support parsing String#pack templates. For systems that don't
+// want or need this functionality, it can be turned off with the
+// PRISM_EXCLUDE_PACK define.
+#ifdef PRISM_EXCLUDE_PACK
+
+void pm_pack_parse(void) {}
+
+#else
+
 #include <stdbool.h>
 #include <errno.h>
 
 static uintmax_t
-strtoumaxc(const char **format);
+strtoumaxc(const char **format) {
+    uintmax_t value = 0;
+    while (**format >= '0' && **format <= '9') {
+        if (value > UINTMAX_MAX / 10) {
+            errno = ERANGE;
+        }
+        value = value * 10 + ((uintmax_t) (**format - '0'));
+        (*format)++;
+    }
+    return value;
+}
 
 PRISM_EXPORTED_FUNCTION pm_pack_result
-pm_pack_parse(pm_pack_variant variant, const char **format, const char *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, pm_pack_encoding *encoding) {
-
+pm_pack_parse(
+    pm_pack_variant variant,
+    const char **format,
+    const char *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,
+    pm_pack_encoding *encoding
+) {
     if (*encoding == PM_PACK_ENCODING_START) {
         *encoding = PM_PACK_ENCODING_US_ASCII;
     }
@@ -479,15 +506,4 @@ pm_size_to_native(pm_pack_size size) {
     }
 }
 
-static uintmax_t
-strtoumaxc(const char **format) {
-    uintmax_t value = 0;
-    while (**format >= '0' && **format <= '9') {
-        if (value > UINTMAX_MAX / 10) {
-            errno = ERANGE;
-        }
-        value = value * 10 + ((uintmax_t) (**format - '0'));
-        (*format)++;
-    }
-    return value;
-}
+#endif