prism 0.16.0 → 0.17.0

data/src/options.c

@@ -0,0 +1,170 @@
+#include "prism/options.h"
+
+/**
+ * Set the filepath option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_filepath_set(pm_options_t *options, const char *filepath) {
+    pm_string_constant_init(&options->filepath, filepath, strlen(filepath));
+}
+
+/**
+ * Set the encoding option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_encoding_set(pm_options_t *options, const char *encoding) {
+    pm_string_constant_init(&options->encoding, encoding, strlen(encoding));
+}
+
+/**
+ * Set the line option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_line_set(pm_options_t *options, uint32_t line) {
+    options->line = line;
+}
+
+/**
+ * Set the frozen string literal option on the given options struct.
+ */
+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;
+}
+
+/**
+ * Set the suppress warnings option on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_suppress_warnings_set(pm_options_t *options, bool suppress_warnings) {
+    options->suppress_warnings = suppress_warnings;
+}
+
+/**
+ * Allocate and zero out the scopes array on the given options struct.
+ */
+PRISM_EXPORTED_FUNCTION void
+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();
+}
+
+/**
+ * Return a pointer to the scope at the given index within the given options.
+ */
+PRISM_EXPORTED_FUNCTION const pm_options_scope_t *
+pm_options_scope_get(const pm_options_t *options, size_t index) {
+    return &options->scopes[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
+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();
+}
+
+/**
+ * Return a pointer to the local at the given index within the given scope.
+ */
+PRISM_EXPORTED_FUNCTION const pm_string_t *
+pm_options_scope_local_get(const pm_options_scope_t *scope, size_t index) {
+    return &scope->locals[index];
+}
+
+/**
+ * Free the internal memory associated with the options.
+ */
+PRISM_EXPORTED_FUNCTION void
+pm_options_free(pm_options_t *options) {
+    pm_string_free(&options->filepath);
+    pm_string_free(&options->encoding);
+
+    for (size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
+        pm_options_scope_t *scope = &options->scopes[scope_index];
+
+        for (size_t local_index = 0; local_index < scope->locals_count; local_index++) {
+            pm_string_free(&scope->locals[local_index]);
+        }
+
+        free(scope->locals);
+    }
+
+    free(options->scopes);
+}
+
+/**
+ * Read a 32-bit unsigned integer from a pointer. This function is used to read
+ * the options that are passed into the parser from the Ruby implementation. It
+ * handles aligned and unaligned reads.
+ */
+static uint32_t
+pm_options_read_u32(const char *data) {
+    if (((uintptr_t) data) % sizeof(uint32_t) == 0) {
+        return *((uint32_t *) data);
+    } else {
+        uint32_t value;
+        memcpy(&value, data, sizeof(uint32_t));
+        return value;
+    }
+}
+
+/**
+ * Deserialize an options struct from the given binary string. This is used to
+ * pass options to the parser from an FFI call so that consumers of the library
+ * from an FFI perspective don't have to worry about the structure of our
+ * options structs. Since the source of these calls will be from Ruby
+ * implementation internals we assume it is from a trusted source.
+ */
+void
+pm_options_read(pm_options_t *options, const char *data) {
+    uint32_t filepath_length = pm_options_read_u32(data);
+    data += 4;
+
+    if (filepath_length > 0) {
+        pm_string_constant_init(&options->filepath, data, filepath_length);
+        data += filepath_length;
+    }
+
+    options->line = pm_options_read_u32(data);
+    data += 4;
+
+    uint32_t encoding_length = pm_options_read_u32(data);
+    data += 4;
+
+    if (encoding_length > 0) {
+        pm_string_constant_init(&options->encoding, data, encoding_length);
+        data += encoding_length;
+    }
+
+    options->frozen_string_literal = *data++;
+    options->suppress_warnings = *data++;
+
+    uint32_t scopes_count = pm_options_read_u32(data);
+    data += 4;
+
+    if (scopes_count > 0) {
+        pm_options_scopes_init(options, scopes_count);
+
+        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);
+
+            for (size_t local_index = 0; local_index < locals_count; local_index++) {
+                uint32_t local_length = pm_options_read_u32(data);
+                data += 4;
+
+                pm_string_constant_init(&scope->locals[local_index], data, local_length);
+                data += local_length;
+            }
+        }
+    }
+}

data/src/prettyprint.c

@@ -5123,52 +5123,6 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
-        case PM_KEYWORD_PARAMETER_NODE: {
-            pm_keyword_parameter_node_t *cast = (pm_keyword_parameter_node_t *) node;
-            pm_buffer_append_string(output_buffer, "@ KeywordParameterNode (location: ", 34);
-            prettyprint_location(output_buffer, parser, &node->location);
-            pm_buffer_append_string(output_buffer, ")\n", 2);
-
-            // name
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "├── name:", 15);
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_constant(output_buffer, parser, cast->name);
-                pm_buffer_append_byte(output_buffer, '\n');
-            }
-
-            // name_loc
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "├── name_loc:", 19);
-                pm_location_t *location = &cast->name_loc;
-                pm_buffer_append_byte(output_buffer, ' ');
-                prettyprint_location(output_buffer, parser, location);
-                pm_buffer_append_string(output_buffer, " = \"", 4);
-                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
-                pm_buffer_append_string(output_buffer, "\"\n", 2);
-            }
-
-            // value
-            {
-                pm_buffer_concat(output_buffer, prefix_buffer);
-                pm_buffer_append_string(output_buffer, "└── value:", 16);
-                if (cast->value == NULL) {
-                    pm_buffer_append_string(output_buffer, " ∅\n", 5);
-                } else {
-                    pm_buffer_append_byte(output_buffer, '\n');
-
-                    size_t prefix_length = prefix_buffer->length;
-                    pm_buffer_append_string(prefix_buffer, "    ", 4);
-                    pm_buffer_concat(output_buffer, prefix_buffer);
-                    prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
-                    prefix_buffer->length = prefix_length;
-                }
-            }
-
-            break;
-        }
         case PM_KEYWORD_REST_PARAMETER_NODE: {
             pm_keyword_rest_parameter_node_t *cast = (pm_keyword_rest_parameter_node_t *) node;
             pm_buffer_append_string(output_buffer, "@ KeywordRestParameterNode (location: ", 38);
@@ -6256,6 +6210,48 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
+        case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
+            pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ OptionalKeywordParameterNode (location: ", 42);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // name
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "├── name:", 15);
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_constant(output_buffer, parser, cast->name);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
+            // name_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "├── name_loc:", 19);
+                pm_location_t *location = &cast->name_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            // value
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "└── value:", 16);
+                pm_buffer_append_byte(output_buffer, '\n');
+
+                size_t prefix_length = prefix_buffer->length;
+                pm_buffer_append_string(prefix_buffer, "    ", 4);
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
+                prefix_buffer->length = prefix_length;
+            }
+
+            break;
+        }
         case PM_OPTIONAL_PARAMETER_NODE: {
             pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
             pm_buffer_append_string(output_buffer, "@ OptionalParameterNode (location: ", 35);
@@ -7007,6 +7003,35 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
 
             break;
         }
+        case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
+            pm_required_keyword_parameter_node_t *cast = (pm_required_keyword_parameter_node_t *) node;
+            pm_buffer_append_string(output_buffer, "@ RequiredKeywordParameterNode (location: ", 42);
+            prettyprint_location(output_buffer, parser, &node->location);
+            pm_buffer_append_string(output_buffer, ")\n", 2);
+
+            // name
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "├── name:", 15);
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_constant(output_buffer, parser, cast->name);
+                pm_buffer_append_byte(output_buffer, '\n');
+            }
+
+            // name_loc
+            {
+                pm_buffer_concat(output_buffer, prefix_buffer);
+                pm_buffer_append_string(output_buffer, "└── name_loc:", 19);
+                pm_location_t *location = &cast->name_loc;
+                pm_buffer_append_byte(output_buffer, ' ');
+                prettyprint_location(output_buffer, parser, location);
+                pm_buffer_append_string(output_buffer, " = \"", 4);
+                prettyprint_source(output_buffer, location->start, (size_t) (location->end - location->start));
+                pm_buffer_append_string(output_buffer, "\"\n", 2);
+            }
+
+            break;
+        }
         case PM_REQUIRED_PARAMETER_NODE: {
             pm_required_parameter_node_t *cast = (pm_required_parameter_node_t *) node;
             pm_buffer_append_string(output_buffer, "@ RequiredParameterNode (location: ", 35);
@@ -8211,7 +8236,9 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
     }
 }
 
-// Pretty-prints the AST represented by the given node to the given buffer.
+/**
+ * Pretty-prints the AST represented by the given node to the given buffer.
+ */
 PRISM_EXPORTED_FUNCTION void
 pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node) {
     pm_buffer_t prefix_buffer = { 0 };