1#include "prism/internal/options.h"
5#include "prism/internal/allocator.h"
6#include "prism/internal/char.h"
7#include "prism/internal/oom.h"
8#include "prism/internal/stringy.h"
20 if (options == NULL) PRISM_OOM();
23 options->stack_budget = SIZE_MAX;
32 for (
size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
34 xfree_sized(scope->locals, scope->locals_count *
sizeof(
pm_string_t));
47 pm_options_cleanup(options);
56 options->shebang_callback = shebang_callback;
57 options->shebang_callback_data = shebang_callback_data;
65 return &options->filepath;
72pm_options_filepath_set(
pm_options_t *options,
const char *filepath) {
73 pm_string_init(&options->filepath, (
const uint8_t *) filepath, strlen(filepath));
80pm_options_encoding_set(
pm_options_t *options,
const char *encoding) {
81 pm_string_init(&options->encoding, (
const uint8_t *) encoding, strlen(encoding));
88pm_options_encoding_locked_set(
pm_options_t *options,
bool encoding_locked) {
89 options->encoding_locked = encoding_locked;
104pm_options_frozen_string_literal_set(
pm_options_t *options,
bool frozen_string_literal) {
112pm_options_command_line_set(
pm_options_t *options, uint8_t command_line) {
113 options->command_line = command_line;
120is_number(
const char *
string,
size_t length) {
121 return pm_strspn_decimal_digit((
const uint8_t *)
string, (ptrdiff_t) length) == length;
130pm_options_version_set(
pm_options_t *options,
const char *version,
size_t length) {
131 if (version == NULL) {
132 options->version = PM_OPTIONS_VERSION_LATEST;
137 if (memcmp(version,
"3.3", 3) == 0) {
138 options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
142 if (memcmp(version,
"3.4", 3) == 0) {
143 options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
147 if (memcmp(version,
"3.5", 3) == 0 || memcmp(version,
"4.0", 3) == 0) {
148 options->version = PM_OPTIONS_VERSION_CRUBY_4_0;
152 if (memcmp(version,
"4.1", 3) == 0) {
153 options->version = PM_OPTIONS_VERSION_CRUBY_4_1;
160 if (length >= 4 && is_number(version + 4, length - 4)) {
161 if (memcmp(version,
"3.3.", 4) == 0) {
162 options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
166 if (memcmp(version,
"3.4.", 4) == 0) {
167 options->version = PM_OPTIONS_VERSION_CRUBY_3_4;
171 if (memcmp(version,
"3.5.", 4) == 0 || memcmp(version,
"4.0.", 4) == 0) {
172 options->version = PM_OPTIONS_VERSION_CRUBY_4_0;
176 if (memcmp(version,
"4.1.", 4) == 0) {
177 options->version = PM_OPTIONS_VERSION_CRUBY_4_1;
183 if (memcmp(version,
"latest", 6) == 0) {
184 options->version = PM_OPTIONS_VERSION_LATEST;
198 options->version = PM_OPTIONS_VERSION_CRUBY_3_3;
207 options->version = PM_OPTIONS_VERSION_LATEST;
215 options->main_script = main_script;
222pm_options_partial_script_set(
pm_options_t *options,
bool partial_script) {
223 options->partial_script = partial_script;
231 return options->freeze;
239 options->freeze = freeze;
247 return options->attach_comments;
254pm_options_attach_comments_set(
pm_options_t *options,
bool attach_comments) {
255 options->attach_comments = attach_comments;
262 return options->raise_error;
268void pm_options_raise_error_set(
pm_options_t *options, uint8_t raise_error) {
269 options->raise_error = raise_error;
276pm_options_stack_budget_set(
pm_options_t *options,
size_t stack_budget) {
277 options->stack_budget = stack_budget;
283#if defined(__GNUC__) && (__GNUC__ >= 10)
284#pragma GCC diagnostic push
285#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
293 options->scopes_count = scopes_count;
295 return options->scopes != NULL;
304 return &options->scopes[index];
313 return &options->scopes[index];
322 scope->locals_count = locals_count;
325 if (scope->locals == NULL) PRISM_OOM();
334 return &scope->locals[index];
343 return &scope->locals[index];
351 scope->forwarding = forwarding;
360pm_options_read_u32(
const char *data) {
361 if (((uintptr_t) data) %
sizeof(uint32_t) == 0) {
362 return *((uint32_t *) data);
365 memcpy(&value, data,
sizeof(uint32_t));
376pm_options_read_s32(
const char *data) {
377 if (((uintptr_t) data) %
sizeof(int32_t) == 0) {
378 return *((int32_t *) data);
381 memcpy(&value, data,
sizeof(int32_t));
394pm_options_read(
pm_options_t *options,
const char *data) {
396 options->stack_budget = SIZE_MAX;
397 if (data == NULL)
return;
399 uint32_t filepath_length = pm_options_read_u32(data);
402 if (filepath_length > 0) {
403 pm_string_init(&options->filepath, (
const uint8_t *) data, filepath_length);
404 data += filepath_length;
407 options->line = pm_options_read_s32(data);
410 uint32_t encoding_length = pm_options_read_u32(data);
413 if (encoding_length > 0) {
414 pm_string_init(&options->encoding, (
const uint8_t *) data, encoding_length);
415 data += encoding_length;
418 options->frozen_string_literal = (int8_t) *data++;
419 options->command_line = (uint8_t) *data++;
420 options->version = (pm_options_version_t) *data++;
421 options->encoding_locked = ((uint8_t) *data++) > 0;
422 options->main_script = ((uint8_t) *data++) > 0;
423 options->partial_script = ((uint8_t) *data++) > 0;
424 options->freeze = ((uint8_t) *data++) > 0;
425 options->attach_comments = ((uint8_t) *data++) > 0;
427 uint32_t scopes_count = pm_options_read_u32(data);
430 if (scopes_count > 0) {
431 if (!pm_options_scopes_init(options, scopes_count))
return;
433 for (
size_t scope_index = 0; scope_index < scopes_count; scope_index++) {
434 uint32_t locals_count = pm_options_read_u32(data);
438 pm_options_scope_init(scope, locals_count);
440 uint8_t forwarding = (uint8_t) *data++;
441 pm_options_scope_forwarding_set(&options->scopes[scope_index], forwarding);
443 for (
size_t local_index = 0; local_index < locals_count; local_index++) {
444 uint32_t local_length = pm_options_read_u32(data);
447 pm_string_init(&scope->locals[local_index], (
const uint8_t *) data, local_length);
448 data += local_length;
454#if defined(__GNUC__) && (__GNUC__ >= 10)
455#pragma GCC diagnostic pop
#define xcalloc
Old name of ruby_xcalloc.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_NONE
The default value for parameters.
#define PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED
String literals should not be frozen.
#define PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED
String literals should be made frozen.
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_options_t * pm_options_new(void)
Allocate a new options struct.
void(* pm_options_shebang_callback_t)(pm_options_t *options, const uint8_t *source, size_t length, void *shebang_callback_data)
The callback called when additional switches are found in a shebang comment that need to be processed...
A view of a sequence of bytes.