1#include "prism/extension.h"
16VALUE rb_cPrismLocation;
18VALUE rb_cPrismComment;
19VALUE rb_cPrismInlineComment;
20VALUE rb_cPrismEmbDocComment;
21VALUE rb_cPrismMagicComment;
22VALUE rb_cPrismParseError;
23VALUE rb_cPrismParseWarning;
25VALUE rb_cPrismParseResult;
26VALUE rb_cPrismLexResult;
27VALUE rb_cPrismParseLexResult;
28VALUE rb_cPrismStringQuery;
30VALUE rb_cPrismCurrentVersionError;
32VALUE rb_cPrismDebugEncoding;
34ID rb_id_option_attach_comments;
35ID rb_id_option_command_line;
36ID rb_id_option_encoding;
37ID rb_id_option_filepath;
38ID rb_id_option_freeze;
39ID rb_id_option_frozen_string_literal;
41ID rb_id_option_main_script;
42ID rb_id_option_partial_script;
43ID rb_id_option_raise_error;
44ID rb_id_option_scopes;
45ID rb_id_option_version;
49ID rb_id_forwarding_positionals;
50ID rb_id_forwarding_keywords;
51ID rb_id_forwarding_block;
52ID rb_id_forwarding_all;
54ID rb_id_raise_error_plain;
55ID rb_id_raise_error_style;
56ID rb_id_raise_error_color;
71result_ok(
VALUE value) {
72 return (
result_t) { .type = RESULT_OK, .value = value };
76result_err(
VALUE value) {
77 return (
result_t) { .type = RESULT_ERR, .value = value };
82 if (result.type == RESULT_OK) {
98check_string(
VALUE value) {
105 return RSTRING_PTR(value);
124 if (!pm_options_scopes_init(options, scopes_count)) {
129 for (
size_t scope_index = 0; scope_index < scopes_count; scope_index++) {
151 for (
size_t name_index = 0; name_index < names_count; name_index++) {
161 if (
id == rb_id_forwarding_positionals) {
163 }
else if (
id == rb_id_forwarding_keywords) {
165 }
else if (
id == rb_id_forwarding_block) {
167 }
else if (
id == rb_id_forwarding_all) {
170 rb_raise(rb_eArgError,
"invalid forwarding value: %" PRIsVALUE, name);
180 pm_options_scope_init(options_scope, locals_count);
183 for (
size_t local_index = 0; local_index < locals_count; local_index++) {
193 pm_string_t *scope_local = pm_options_scope_local_mut(options_scope, local_index);
194 const char *name = rb_id2name(
SYM2ID(local));
195 pm_string_init(scope_local, (
const uint8_t *) name, strlen(name));
199 pm_options_scope_forwarding_set(options_scope, forwarding);
208ruby_version_before_lowest_p(
void) {
218 if (!pm_options_version_set(options,
ruby_version, 3)) {
220 if (ruby_version_before_lowest_p()) {
221 pm_options_version_set_lowest(options);
224 pm_options_version_set_highest(options);
237 if (key_id == rb_id_option_filepath) {
238 if (!
NIL_P(value)) pm_options_filepath_set(options, check_string(value));
239 }
else if (key_id == rb_id_option_encoding) {
242 pm_options_encoding_locked_set(options,
true);
244 pm_options_encoding_set(options, rb_enc_name(rb_to_encoding(value)));
247 }
else if (key_id == rb_id_option_line) {
248 if (!
NIL_P(value)) pm_options_line_set(options,
NUM2INT(value));
249 }
else if (key_id == rb_id_option_frozen_string_literal) {
250 if (!
NIL_P(value)) pm_options_frozen_string_literal_set(options,
RTEST(value));
251 }
else if (key_id == rb_id_option_version) {
253 const char *version = check_string(value);
255 if (RSTRING_LEN(value) == 7 && strncmp(version,
"current", 7) == 0) {
256 if (!pm_options_version_set(options,
ruby_version, 3)) {
259 }
else if (RSTRING_LEN(value) == 7 && strncmp(version,
"nearest", 7) == 0) {
260 options_version_set_nearest(options);
261 }
else if (!pm_options_version_set(options, version, RSTRING_LEN(value))) {
262 rb_raise(rb_eArgError,
"invalid version: %" PRIsVALUE, value);
265 }
else if (key_id == rb_id_option_scopes) {
266 if (!
NIL_P(value)) build_options_scopes(options, value);
267 }
else if (key_id == rb_id_option_command_line) {
269 const char *
string = check_string(value);
270 uint8_t command_line = 0;
272 for (
size_t index = 0; index < strlen(
string); index++) {
273 switch (
string[index]) {
280 default: rb_raise(rb_eArgError,
"invalid command line flag: '%c'",
string[index]);
break;
284 pm_options_command_line_set(options, command_line);
286 }
else if (key_id == rb_id_option_main_script) {
287 if (!
NIL_P(value)) pm_options_main_script_set(options,
RTEST(value));
288 }
else if (key_id == rb_id_option_partial_script) {
289 if (!
NIL_P(value)) pm_options_partial_script_set(options,
RTEST(value));
290 }
else if (key_id == rb_id_option_freeze) {
291 if (!
NIL_P(value)) pm_options_freeze_set(options,
RTEST(value));
292 }
else if (key_id == rb_id_option_attach_comments) {
293 if (!
NIL_P(value)) pm_options_attach_comments_set(options,
RTEST(value));
294 }
else if (key_id == rb_id_option_raise_error) {
296 if (value ==
Qtrue) {
306 const char *no_color = getenv(
"NO_COLOR");
307 if (no_color == NULL || no_color[0] ==
'\0') {
321 if (value_id == rb_id_raise_error_plain) {
323 }
else if (value_id == rb_id_raise_error_style) {
325 }
else if (value_id == rb_id_raise_error_color) {
328 rb_raise(rb_eArgError,
"invalid raise_error value: %" PRIsVALUE, value);
333 rb_raise(rb_eArgError,
"unknown keyword: %" PRIsVALUE, key);
354build_options(
VALUE argument) {
365 pm_options_line_set(options, 1);
366 options_version_set_nearest(options);
368 if (!
NIL_P(keywords)) {
373 rb_protect(build_options, (
VALUE) argument, &state);
376 pm_options_free(options);
381 if (!
NIL_P(filepath)) {
383 pm_options_free(options);
387 pm_options_filepath_set(options, RSTRING_PTR(filepath));
401 pm_options_free(options);
405 extract_options(options,
Qnil, keywords);
419 filepath = rb_protect(rb_get_path, filepath, &state);
421 pm_options_free(options);
425 *encoded_filepath = rb_str_encode_ospath(filepath);
426 extract_options(options, *encoded_filepath, keywords);
428 const char *source = (
const char *) pm_string_source(pm_options_filepath(options));
430 pm_source_t *pm_src = pm_source_file_new(source, &result);
436 pm_options_free(options);
439 int e = rb_w32_map_errno(GetLastError());
448 pm_options_free(options);
452 pm_options_free(options);
453 rb_raise(
rb_eRuntimeError,
"Unknown error (%d) initializing file: %s", result, source);
467 if (pm_parser_errors_size(parser) == 0)
return result_ok(
Qnil);
469 uint8_t raise_error = pm_options_raise_error(options);
470 if (raise_error == 0)
return result_ok(
Qnil);
473 if (buffer == NULL) {
483 VALUE message = rb_enc_str_new(pm_buffer_value(buffer), (
long) pm_buffer_length(buffer), message_encoding);
484 pm_buffer_free(buffer);
487 switch (error_level) {
491 rb_encoding *path_encoding_normal = path_encoding == NULL ?
rb_utf8_encoding() : path_encoding;
492 VALUE path = rb_enc_str_new((
const char *) pm_string_source(pm_options_filepath(options)), pm_string_length(pm_options_filepath(options)), path_encoding_normal);
511 return result_err(error);
514#ifndef PRISM_EXCLUDE_SERIALIZATION
524dump_input(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding) {
529 result_t result = check_raise_error_option(parser, options, path_encoding);
530 if (result.type == RESULT_OK) {
533 pm_serialize(parser, node, buffer);
534 result = result_ok(
rb_str_new(pm_buffer_value(buffer), pm_buffer_length(buffer)));
535 pm_buffer_free(buffer);
544 pm_arena_free(arena);
560 VALUE string = string_options(argc, argv, options);
562 const uint8_t *source = (
const uint8_t *) RSTRING_PTR(
string);
563 size_t length = RSTRING_LEN(
string);
565#ifdef PRISM_BUILD_DEBUG
567 memcpy(dup, source, length);
568 source = (
const uint8_t *) dup;
571 result_t result = dump_input(source, length, options, NULL);
573#ifdef PRISM_BUILD_DEBUG
575 xfree_sized(dup, length);
581 pm_options_free(options);
582 return result_get(result);
597 VALUE encoded_filepath;
598 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
600 result_t result = dump_input(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath));
602 pm_options_free(options);
604 return result_get(result);
618rb_class_new_instance_freeze(
int argc,
const VALUE *argv,
VALUE klass,
bool freeze) {
628parser_location(
VALUE source,
bool freeze, uint32_t start, uint32_t length) {
630 return rb_class_new_instance_freeze(3, argv, rb_cPrismLocation, freeze);
636#define PARSER_LOCATION(source, freeze, location) \
637 parser_location(source, freeze, location.start, location.length)
646 return rb_class_new_instance_freeze(1, argv,
type, freeze);
659 rb_ary_store(comments, index++, parser_comment(source, freeze, comment));
673 VALUE key_loc = parser_location(source, freeze, key.start, key.length);
674 VALUE value_loc = parser_location(source, freeze, value.
start, value.
length);
676 VALUE argv[] = { key_loc, value_loc };
677 return rb_class_new_instance_freeze(2, argv, rb_cPrismMagicComment, freeze);
684parser_magic_comments(
const pm_parser_t *parser,
VALUE source,
bool freeze) {
692 return magic_comments;
703 if (data_loc->
length == 0) {
706 return parser_location(source, freeze, data_loc->
start, data_loc->
length);
714parser_error(
const pm_diagnostic_t *diagnostic, rb_encoding *encoding,
VALUE source,
bool freeze) {
717 VALUE location = PARSER_LOCATION(source, freeze, pm_diagnostic_location(diagnostic));
722 switch (error_level) {
724 level =
ID2SYM(rb_intern(
"syntax"));
727 level =
ID2SYM(rb_intern(
"argument"));
730 level =
ID2SYM(rb_intern(
"load"));
733 level =
ID2SYM(rb_intern(
"stack"));
739 VALUE argv[] = {
type, message, location, level };
740 return rb_class_new_instance_freeze(4, argv, rb_cPrismParseError, freeze);
747parser_errors(
const pm_parser_t *parser, rb_encoding *encoding,
VALUE source,
bool freeze) {
750 for (
const pm_diagnostic_t *error = pm_parser_errors_first(parser); error != NULL; error = pm_diagnostic_next(error)) {
751 rb_ary_push(errors, parser_error(error, encoding, source, freeze));
762parser_warning(
const pm_diagnostic_t *diagnostic, rb_encoding *encoding,
VALUE source,
bool freeze) {
765 VALUE location = PARSER_LOCATION(source, freeze, pm_diagnostic_location(diagnostic));
770 switch (warning_level) {
772 level =
ID2SYM(rb_intern(
"default"));
775 level =
ID2SYM(rb_intern(
"verbose"));
781 VALUE argv[] = {
type, message, location, level };
782 return rb_class_new_instance_freeze(4, argv, rb_cPrismParseWarning, freeze);
789parser_warnings(
const pm_parser_t *parser, rb_encoding *encoding,
VALUE source,
bool freeze) {
792 for (
const pm_diagnostic_t *warning = pm_parser_warnings_first(parser); warning != NULL; warning = pm_diagnostic_next(warning)) {
793 rb_ary_push(warnings, parser_warning(warning, encoding, source, freeze));
807 uint32_t ranges_size = pm_parser_comment_ranges_size(parser);
808 *attachments =
rb_ary_new_capa(ranges_size == 0 ? 0 : (
long) pm_parser_comments_size(parser));
809 *ranges =
rb_ary_new_capa(ranges_size == 0 ? 0 : (
long) ranges_size + 1);
821 uint32_t ranges_size = pm_parser_comment_ranges_size(parser);
823 if (ranges_size > 0) {
826 for (
long index = 0; index < size; index++) {
827 rb_ary_store(attachments, index,
RARRAY_AREF(comments, pm_parser_comment_attachment(parser, (uint32_t) index)));
830 for (uint32_t node_id = 0; node_id < ranges_size; node_id++) {
833 if (range.length > 0) {
851 VALUE result_argv[] = {
853 parser_magic_comments(parser, source, freeze),
854 parser_data_loc(parser, source, freeze),
855 parser_errors(parser, encoding, source, freeze),
856 parser_warnings(parser, encoding, source, freeze),
861 return rb_class_new_instance_freeze(7, result_argv,
class, freeze);
876 rb_encoding *encoding;
889 VALUE value = pm_token_new(parser, token, parse_lex_data->encoding, parse_lex_data->source, parse_lex_data->freeze);
899parse_lex_encoding_changed_callback(
pm_parser_t *parser) {
901 parse_lex_data->encoding = rb_enc_find(pm_parser_encoding_name(parser));
907 VALUE tokens = parse_lex_data->tokens;
910 for (
long index = 0; index <
RARRAY_LEN(tokens); index++) {
915 rb_enc_associate(next_value, parse_lex_data->encoding);
918 VALUE next_token_argv[] = {
919 parse_lex_data->source,
928 if (parse_lex_data->freeze) {
943parse_lex_input(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding,
bool return_nodes) {
946 pm_parser_encoding_changed_callback_set(parser, parse_lex_encoding_changed_callback);
953 VALUE source =
rb_funcall(rb_cPrismSource, rb_id_source_for, 6, source_string,
LONG2NUM(pm_parser_start_line(parser)), offsets, comments, attachments, ranges);
958 .encoding = rb_enc_find(pm_parser_encoding_name(parser)),
959 .freeze = pm_options_freeze(options),
963 pm_parser_lex_callback_set(parser, parse_lex_token, data);
967 result_t result = check_raise_error_option(parser, options, path_encoding);
968 if (result.type == RESULT_OK) {
972 rb_encoding *encoding = rb_enc_find(pm_parser_encoding_name(parser));
973 rb_enc_associate(source_string, encoding);
976 for (
size_t index = 0; index < line_offsets->
size; index++) {
980 rb_funcall(source, rb_intern(
"replace_checksum"), 1,
ULL2NUM(pm_parser_checksum(parser)));
982 if (pm_options_freeze(options)) {
991 uint32_t ranges_size = pm_parser_comment_ranges_size(parser);
992 rb_ary_resize(comments, (
long) pm_parser_comments_size(parser));
994 if (ranges_size > 0) {
995 rb_ary_resize(attachments, (
long) pm_parser_comments_size(parser));
999 parser_comments(parser, comments, source, pm_options_freeze(options));
1000 parser_attachments(parser, comments, attachments, ranges, pm_options_freeze(options));
1004 rb_ary_push(value, pm_ast_new(parser, node, parse_lex_data.encoding, source, pm_options_freeze(options)));
1007 result = result_ok(parse_result_create(rb_cPrismParseLexResult, parser, value, parse_lex_data.encoding, source, pm_options_freeze(options)));
1009 result = result_ok(parse_result_create(rb_cPrismLexResult, parser, parse_lex_data.tokens, parse_lex_data.encoding, source, pm_options_freeze(options)));
1014 pm_arena_free(arena);
1030 VALUE string = string_options(argc, argv, options);
1032 result_t result = parse_lex_input((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), options, NULL,
false);
1033 pm_options_free(options);
1035 return result_get(result);
1050 VALUE encoded_filepath;
1051 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1053 result_t result = parse_lex_input(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath),
false);
1054 pm_source_free(src);
1055 pm_options_free(options);
1057 return result_get(result);
1068parse_input(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding) {
1072 pm_node_t *node =
pm_parse(parser);
1074 result_t result = check_raise_error_option(parser, options, path_encoding);
1075 if (result.type == RESULT_OK) {
1076 rb_encoding *encoding = rb_enc_find(pm_parser_encoding_name(parser));
1078 bool freeze = pm_options_freeze(options);
1080 VALUE attachments, ranges;
1081 parser_attachments_new(parser, &attachments, &ranges);
1083 VALUE source = pm_source_new(parser, encoding, comments, attachments, ranges, freeze);
1084 parser_comments(parser, comments, source, freeze);
1085 parser_attachments(parser, comments, attachments, ranges, freeze);
1087 VALUE value = pm_ast_new(parser, node, encoding, source, freeze);
1088 result = result_ok(parse_result_create(rb_cPrismParseResult, parser, value, encoding, source, freeze));
1092 pm_arena_free(arena);
1164 VALUE string = string_options(argc, argv, options);
1166 const uint8_t *source = (
const uint8_t *) RSTRING_PTR(
string);
1167 size_t length = RSTRING_LEN(
string);
1169#ifdef PRISM_BUILD_DEBUG
1171 memcpy(dup, source, length);
1172 source = (
const uint8_t *) dup;
1175 result_t result = parse_input(source, length, options, NULL);
1177#ifdef PRISM_BUILD_DEBUG
1179 xfree_sized(dup, length);
1185 pm_options_free(options);
1186 return result_get(result);
1198parse_file(
int argc,
VALUE *argv,
VALUE self) {
1201 VALUE encoded_filepath;
1202 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1204 result_t result = parse_input(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath));
1205 pm_source_free(src);
1206 pm_options_free(options);
1208 return result_get(result);
1215profile_input(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding) {
1221 result_t result = check_raise_error_option(parser, options, path_encoding);
1223 pm_arena_free(arena);
1240 VALUE string = string_options(argc, argv, options);
1242 result_t result = profile_input((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), options, NULL);
1243 pm_options_free(options);
1259profile_file(
int argc,
VALUE *argv,
VALUE self) {
1262 VALUE encoded_filepath;
1263 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1265 result_t result = profile_input(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath));
1266 pm_source_free(src);
1267 pm_options_free(options);
1274parse_stream_eof(
void *stream) {
1293#define MAX_ENC_LEN 6
1301parse_stream_fgets(
char *
string,
int size,
void *stream) {
1320 const char *cstr = RSTRING_PTR(line);
1321 size_t length = (size_t) RSTRING_LEN(line);
1328 if (length > (
size_t) (size - 1)) {
1329 length = (size_t) (size - 1);
1332 memcpy(
string, cstr, length);
1333 string[length] =
'\0';
1349parse_stream(
int argc,
VALUE *argv,
VALUE self) {
1355 extract_options(options,
Qnil, keywords);
1357 pm_source_t *src = pm_source_stream_new((
void *) stream, parse_stream_fgets, parse_stream_eof);
1361 pm_node_t *node = pm_parse_stream(&parser, arena, src, options);
1363 result_t result = check_raise_error_option(parser, options, NULL);
1364 if (result.type == RESULT_OK) {
1365 rb_encoding *encoding = rb_enc_find(pm_parser_encoding_name(parser));
1368 VALUE attachments, ranges;
1369 parser_attachments_new(parser, &attachments, &ranges);
1371 VALUE source = pm_source_new(parser, encoding, comments, attachments, ranges, pm_options_freeze(options));
1372 parser_comments(parser, comments, source, pm_options_freeze(options));
1373 parser_attachments(parser, comments, attachments, ranges, pm_options_freeze(options));
1375 VALUE value = pm_ast_new(parser, node, encoding, source, pm_options_freeze(options));
1377 result = result_ok(parse_result_create(rb_cPrismParseResult, parser, value, encoding, source, pm_options_freeze(options)));
1380 pm_source_free(src);
1382 pm_arena_free(arena);
1383 pm_options_free(options);
1385 return result_get(result);
1392parse_input_comments(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding) {
1398 result_t result = check_raise_error_option(parser, options, path_encoding);
1399 if (result.type == RESULT_OK) {
1400 rb_encoding *encoding = rb_enc_find(pm_parser_encoding_name(parser));
1403 VALUE attachments, ranges;
1404 parser_attachments_new(parser, &attachments, &ranges);
1406 VALUE source = pm_source_new(parser, encoding, comments, attachments, ranges, pm_options_freeze(options));
1407 parser_comments(parser, comments, source, pm_options_freeze(options));
1408 parser_attachments(parser, comments, attachments, ranges, pm_options_freeze(options));
1410 result = result_ok(comments);
1414 pm_arena_free(arena);
1428parse_comments(
int argc,
VALUE *argv,
VALUE self) {
1430 VALUE string = string_options(argc, argv, options);
1432 result_t result = parse_input_comments((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), options, NULL);
1433 pm_options_free(options);
1435 return result_get(result);
1447parse_file_comments(
int argc,
VALUE *argv,
VALUE self) {
1450 VALUE encoded_filepath;
1451 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1453 result_t result = parse_input_comments(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath));
1454 pm_source_free(src);
1455 pm_options_free(options);
1457 return result_get(result);
1476parse_lex(
int argc,
VALUE *argv,
VALUE self) {
1478 VALUE string = string_options(argc, argv, options);
1480 result_t result = parse_lex_input((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), options, NULL,
true);
1481 pm_options_free(options);
1483 return result_get(result);
1502parse_lex_file(
int argc,
VALUE *argv,
VALUE self) {
1505 VALUE encoded_filepath;
1506 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1508 result_t result = parse_lex_input(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath),
true);
1509 pm_source_free(src);
1510 pm_options_free(options);
1512 return result_get(result);
1519parse_input_success_p(
const uint8_t *input,
size_t input_length,
const pm_options_t *options, rb_encoding *path_encoding) {
1524 result_t result = check_raise_error_option(parser, options, path_encoding);
1525 if (result.type == RESULT_OK) {
1526 result = result_ok(pm_parser_errors_size(parser) == 0 ?
Qtrue :
Qfalse);
1530 pm_arena_free(arena);
1544parse_success_p(
int argc,
VALUE *argv,
VALUE self) {
1546 VALUE string = string_options(argc, argv, options);
1548 result_t result = parse_input_success_p((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), options, NULL);
1549 pm_options_free(options);
1551 return result_get(result);
1563parse_failure_p(
int argc,
VALUE *argv,
VALUE self) {
1576parse_file_success_p(
int argc,
VALUE *argv,
VALUE self) {
1579 VALUE encoded_filepath;
1580 pm_source_t *src = file_options(argc, argv, options, &encoded_filepath);
1582 result_t result = parse_input_success_p(pm_source_source(src), pm_source_length(src), options, rb_enc_get(encoded_filepath));
1583 pm_source_free(src);
1584 pm_options_free(options);
1586 return result_get(result);
1598parse_file_failure_p(
int argc,
VALUE *argv,
VALUE self) {
1612string_query_nearest_version(
void) {
1614 return ruby_version_before_lowest_p() ?
"3.3" : NULL;
1626string_query_arguments(
int argc,
VALUE *argv,
VALUE *
string) {
1629 check_string(*
string);
1632 if (!
NIL_P(keywords)) {
1633 ID keys[1] = { rb_id_option_version };
1637 if (value ==
Qundef ||
NIL_P(value))
return string_query_nearest_version();
1640 if (strcmp(version,
"nearest") == 0)
return string_query_nearest_version();
1642 if (strcmp(version,
"current") == 0) {
1643 if (!pm_options_version_supported_p(
ruby_version, 3)) {
1661 rb_raise(rb_eArgError,
"invalid version: %s", version);
1664 rb_raise(rb_eArgError,
"Invalid or non ascii-compatible encoding");
1689string_query_local_p(
int argc,
VALUE *argv,
VALUE self) {
1691 const char *version = string_query_arguments(argc, argv, &
string);
1692 return string_query(pm_string_query_local((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), rb_enc_get(
string)->name, version), version);
1709string_query_constant_p(
int argc,
VALUE *argv,
VALUE self) {
1711 const char *version = string_query_arguments(argc, argv, &
string);
1712 return string_query(pm_string_query_constant((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), rb_enc_get(
string)->name, version), version);
1727string_query_method_name_p(
int argc,
VALUE *argv,
VALUE self) {
1729 const char *version = string_query_arguments(argc, argv, &
string);
1730 return string_query(pm_string_query_method_name((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), rb_enc_get(
string)->name, version), version);
1746string_query_keyword_p(
int argc,
VALUE *argv,
VALUE self) {
1748 const char *version = string_query_arguments(argc, argv, &
string);
1749 return string_query(pm_string_query_keyword((
const uint8_t *) RSTRING_PTR(
string), RSTRING_LEN(
string), rb_enc_get(
string)->name, version), version);
1759RUBY_FUNC_EXPORTED
void
1763 if (strcmp(
pm_version(), EXPECTED_PRISM_VERSION) != 0) {
1766 "The prism library version (%s) does not match the expected version (%s)",
1768 EXPECTED_PRISM_VERSION
1772#ifdef HAVE_RB_EXT_RACTOR_SAFE
1777 VALUE mRuby = rb_define_module(
"Ruby"); rb_cPrism = rb_define_module_under(mRuby,
"Prism");
1778 rb_cPrismNode = rb_define_class_under(rb_cPrism,
"Node",
rb_cObject);
1779 rb_cPrismSource = rb_define_class_under(rb_cPrism,
"Source",
rb_cObject);
1780 rb_cPrismToken = rb_define_class_under(rb_cPrism,
"Token",
rb_cObject);
1781 rb_cPrismLocation = rb_define_class_under(rb_cPrism,
"Location",
rb_cObject);
1782 rb_cPrismComment = rb_define_class_under(rb_cPrism,
"Comment",
rb_cObject);
1783 rb_cPrismInlineComment = rb_define_class_under(rb_cPrism,
"InlineComment", rb_cPrismComment);
1784 rb_cPrismEmbDocComment = rb_define_class_under(rb_cPrism,
"EmbDocComment", rb_cPrismComment);
1785 rb_cPrismMagicComment = rb_define_class_under(rb_cPrism,
"MagicComment",
rb_cObject);
1786 rb_cPrismParseError = rb_define_class_under(rb_cPrism,
"ParseError",
rb_cObject);
1787 rb_cPrismParseWarning = rb_define_class_under(rb_cPrism,
"ParseWarning",
rb_cObject);
1788 rb_cPrismResult = rb_define_class_under(rb_cPrism,
"Result",
rb_cObject);
1789 rb_cPrismParseResult = rb_define_class_under(rb_cPrism,
"ParseResult", rb_cPrismResult);
1790 rb_cPrismLexResult = rb_define_class_under(rb_cPrism,
"LexResult", rb_cPrismResult);
1791 rb_cPrismParseLexResult = rb_define_class_under(rb_cPrism,
"ParseLexResult", rb_cPrismResult);
1792 rb_cPrismStringQuery = rb_define_class_under(rb_cPrism,
"StringQuery",
rb_cObject);
1793 rb_cPrismScope = rb_define_class_under(rb_cPrism,
"Scope",
rb_cObject);
1795 rb_cPrismCurrentVersionError =
rb_const_get(rb_cPrism, rb_intern(
"CurrentVersionError"));
1804 rb_id_option_frozen_string_literal =
rb_intern_const(
"frozen_string_literal");
1812 rb_id_source_for = rb_intern(
"for");
1814 rb_id_forwarding_positionals = rb_intern(
"*");
1815 rb_id_forwarding_keywords = rb_intern(
"**");
1816 rb_id_forwarding_block = rb_intern(
"&");
1817 rb_id_forwarding_all = rb_intern(
"...");
1844#ifndef PRISM_EXCLUDE_SERIALIZATION
1854 Init_prism_api_node();
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_arena_t * pm_arena_new(void)
Returns a newly allocated and initialized arena.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
pm_warning_level_t
The levels of warnings generated during parsing.
@ PM_WARNING_LEVEL_DEFAULT
For warnings which should be emitted if $VERBOSE != nil.
@ PM_WARNING_LEVEL_VERBOSE
For warnings which should be emitted if $VERBOSE == true.
pm_error_level_t
The levels of errors generated during parsing.
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
@ PM_ERROR_LEVEL_STACK
For errors that should raise a system stack error.
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define ID2SYM
Old name of RB_ID2SYM.
#define ULONG2NUM
Old name of RB_ULONG2NUM.
#define SYM2ID
Old name of RB_SYM2ID.
#define xmalloc
Old name of ruby_xmalloc.
#define LONG2FIX
Old name of RB_INT2FIX.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_syserr_fail(int e, const char *mesg)
Raises appropriate exception that represents a C errno.
VALUE rb_eNoMemError
NoMemoryError exception.
VALUE rb_eLoadError
LoadError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eSysStackError
SystemStackError exception.
VALUE rb_eSyntaxError
SyntaxError exception.
VALUE rb_cObject
Object class.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_stderr
STDERR constant.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_obj_freeze(VALUE obj)
Same as RB_OBJ_FREEZE(), but returns the given object.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
rb_encoding * rb_utf8_encoding(void)
Queries the encoding that represents UTF-8.
rb_encoding * rb_locale_encoding(void)
Queries the encoding that represents the current locale.
VALUE rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_ary_entry(VALUE ary, rb_len_t off)
Queries an element of an array.
VALUE rb_ary_new_capa(rb_len_t capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
void rb_ary_store(VALUE ary, rb_len_t key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
VALUE rb_ary_resize(VALUE ary, rb_len_t len)
Expands or shrinks the passed array to the passed length.
VALUE rb_ary_replace(VALUE copy, VALUE orig)
Replaces the contents of the former object with the contents of the latter.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
void rb_ext_ractor_safe(bool flag)
Asserts that the extension library that calls this function is aware of Ractor.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
const char ruby_version[]
Stringised version.
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
static const uint8_t PM_OPTIONS_COMMAND_LINE_E
A bit representing whether or not the command line -e option was set.
static const uint8_t PM_OPTIONS_COMMAND_LINE_L
A bit representing whether or not the command line -l option was set.
static const uint8_t PM_OPTIONS_COMMAND_LINE_A
A bit representing whether or not the command line -a option was set.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_NONE
The default value for parameters.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_ALL
When the scope is forwarding with the ... parameter.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_POSITIONALS
When the scope is forwarding with the * parameter.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_KEYWORDS
When the scope is forwarding with the ** parameter.
static const uint8_t PM_OPTIONS_COMMAND_LINE_N
A bit representing whether or not the command line -n option was set.
static const uint8_t PM_OPTIONS_COMMAND_LINE_X
A bit representing whether or not the command line -x option was set.
static const uint8_t PM_OPTIONS_SCOPE_FORWARDING_BLOCK
When the scope is forwarding with the & parameter.
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_options_t * pm_options_new(void)
Allocate a new options struct.
static const uint8_t PM_OPTIONS_COMMAND_LINE_P
A bit representing whether or not the command line -p option was set.
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_parser_t * pm_parser_new(pm_arena_t *arena, const uint8_t *source, size_t size, const pm_options_t *options) PRISM_NONNULL(1)
Allocate and initialize a parser with the given start and end pointers.
PRISM_EXPORTED_FUNCTION void pm_parser_free(pm_parser_t *parser) PRISM_NONNULL(1)
Free both the memory held by the given parser and the parser itself.
PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser) PRISM_NONNULL(1)
Initiate the parser with the given parser.
comment_range comments(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept
The comments found while parsing, in source order.
diagnostic_range errors(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept
The errors found while parsing.
diagnostic_range warnings(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept
The warnings found while parsing.
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_buffer_t * pm_buffer_new(void)
Allocate and initialize a new buffer.
PRISM_EXPORTED_FUNCTION const char * pm_version(void)
The prism version and the serialization format.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
References an object in an array.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define errno
Ractor-aware version of errno.
pm_source_init_result_t
Represents the result of initializing a source from a file.
@ PM_SOURCE_INIT_ERROR_GENERIC
Indicates a generic error from a source init function, where the type of error should be read from er...
@ PM_SOURCE_INIT_SUCCESS
Indicates that the source was successfully initialized.
@ PM_SOURCE_INIT_ERROR_DIRECTORY
Indicates that the file that was attempted to be opened was a directory.
#define RTEST
This is an old name of RB_TEST.
pm_string_query_t
Represents the results of a slice query.
@ PM_STRING_QUERY_TRUE
Returned if the result of the slice query is true.
@ PM_STRING_QUERY_ERROR
Returned if the encoding given to a slice query was invalid.
@ PM_STRING_QUERY_FALSE
Returned if the result of the slice query is false.
@ PM_STRING_QUERY_ERROR_VERSION
Returned if the version given to a slice query was invalid.
We need a struct here to pass through rb_protect and it has to be a single value.
This struct gets stored in the parser and passed in to the lex callback any time a new token is found...
A list of offsets of the start of lines in a string.
uint32_t * offsets
The list of offsets.
size_t size
The number of offsets in the list.
This struct represents a slice in the source code, defined by an offset and a length.
uint32_t start
The offset of the location from the start of the source.
uint32_t length
The length of the location.
A view of a sequence of bytes.
This struct represents a token in the Ruby source.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.