parser.c

#include "prism/internal/parser.h"
 
#include "prism/internal/allocator.h"
#include "prism/internal/comments.h"
#include "prism/internal/diagnostic.h"
#include "prism/internal/encoding.h"
#include "prism/internal/magic_comments.h"
#include "prism/internal/xxh3.h"
 
#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
void
pm_parser_encoding_changed_callback_set(pm_parser_t *parser, pm_encoding_changed_callback_t callback) {
    parser->encoding_changed_callback = callback;
}
 
void
pm_parser_lex_callback_set(pm_parser_t *parser, pm_lex_callback_t callback, void *data) {
    parser->lex_callback.callback = callback;
    parser->lex_callback.data = data;
}
 
void *
pm_parser_lex_callback_data(const pm_parser_t *parser) {
    return parser->lex_callback.data;
}
 
const uint8_t *
pm_parser_start(const pm_parser_t *parser) {
    return parser->start;
}
 
const uint8_t *
pm_parser_end(const pm_parser_t *parser) {
    return parser->end;
}
 
int32_t
pm_parser_start_line(const pm_parser_t *parser) {
    return parser->start_line;
}
 
const char *
pm_parser_encoding_name(const pm_parser_t *parser) {
    return parser->encoding->name;
}
 
size_t
pm_parser_encoding_char_width(const pm_parser_t *parser, const uint8_t *start, ptrdiff_t remaining) {
    return parser->encoding->char_width(start, remaining);
}
 
bool
pm_parser_encoding_us_ascii(const pm_parser_t *parser) {
    return parser->encoding == PM_ENCODING_US_ASCII_ENTRY;
}
 
const pm_string_t *
pm_parser_filepath(const pm_parser_t *parser) {
    return &parser->filepath;
}
 
pm_constant_id_t
pm_parser_constant_find(const pm_parser_t *parser, const uint8_t *start, size_t length) {
    return pm_constant_pool_find(&parser->constant_pool, start, length);
}
 
pm_constant_id_t
pm_parser_constant_insert(pm_parser_t *parser, const uint8_t *start, size_t length) {
    pm_constant_id_t id = pm_constant_pool_find(&parser->constant_pool, start, length);
    if (id != PM_CONSTANT_ID_UNSET) return id;
 
    const uint8_t *copy = (const uint8_t *) pm_arena_memdup(&parser->metadata_arena, start, length, PRISM_ALIGNOF(uint8_t));
    return pm_constant_pool_insert_constant(&parser->metadata_arena, &parser->constant_pool, copy, length);
}
 
int8_t
pm_parser_frozen_string_literal(const pm_parser_t *parser) {
    return parser->frozen_string_literal;
}
 
const pm_line_offset_list_t *
pm_parser_line_offsets(const pm_parser_t *parser) {
    return &parser->line_offsets;
}
 
const pm_location_t *
pm_parser_data_loc(const pm_parser_t *parser) {
    return &parser->data_loc;
}
 
uint64_t
pm_parser_checksum(const pm_parser_t *parser) {
    const uint8_t *end = parser->end;
 
    if (parser->data_loc.length != 0) {
        const uint8_t *cursor = parser->start + parser->data_loc.start;
        const uint8_t *newline = memchr(cursor, '\n', (size_t) (end - cursor));
        if (newline != NULL) end = newline + 1;
    }
 
    return pm_xxh3(parser->start, (size_t) (end - parser->start));
}
 
bool
pm_parser_continuable(const pm_parser_t *parser) {
    return parser->continuable;
}
 
int
pm_parser_lex_state(const pm_parser_t *parser) {
    return (int) parser->lex_state;
}
 
pm_location_t
pm_comment_location(const pm_comment_t *comment) {
    return comment->location;
}
 
pm_comment_type_t
pm_comment_type(const pm_comment_t *comment) {
    return comment->type;
}
 
const pm_comment_t *
pm_comment_next(const pm_comment_t *comment) {
    return (const pm_comment_t *) comment->node.next;
}
 
size_t
pm_parser_comments_size(const pm_parser_t *parser) {
    return parser->comment_list.size;
}
 
const pm_comment_t *
pm_parser_comments_first(const pm_parser_t *parser) {
    return (const pm_comment_t *) parser->comment_list.head;
}
 
uint32_t
pm_node_comments_size(const pm_parser_t *parser, const pm_node_t *node) {
    return pm_parser_comment_range(parser, node->node_id).length;
}
 
const pm_comment_t *
pm_node_comment(const pm_parser_t *parser, const pm_node_t *node, uint32_t index) {
    pm_comment_range_t range = pm_parser_comment_range(parser, node->node_id);
    if (index >= range.length) return NULL;
 
    return parser->comment_attachments.comments[parser->comment_attachments.attachments[range.index + index]];
}
 
uint32_t
pm_parser_comment_attachment(const pm_parser_t *parser, uint32_t index) {
    if (parser->comment_attachments.attachments == NULL || index >= parser->comment_list.size) return UINT32_MAX;
    return parser->comment_attachments.attachments[index];
}
 
uint32_t
pm_parser_comment_ranges_size(const pm_parser_t *parser) {
    return parser->comment_attachments.ranges_size;
}
 
pm_comment_range_t
pm_parser_comment_range(const pm_parser_t *parser, uint32_t node_id) {
    if (node_id >= parser->comment_attachments.ranges_size) return (pm_comment_range_t) { .index = 0, .length = 0 };
    return parser->comment_attachments.ranges[node_id];
}
 
pm_location_t
pm_magic_comment_key(const pm_magic_comment_t *magic_comment) {
    return magic_comment->key;
}
 
pm_location_t
pm_magic_comment_value(const pm_magic_comment_t *magic_comment) {
    return magic_comment->value;
}
 
const pm_magic_comment_t *
pm_magic_comment_next(const pm_magic_comment_t *magic_comment) {
    return (const pm_magic_comment_t *) magic_comment->node.next;
}
 
size_t
pm_parser_magic_comments_size(const pm_parser_t *parser) {
    return parser->magic_comment_list.size;
}
 
const pm_magic_comment_t *
pm_parser_magic_comments_first(const pm_parser_t *parser) {
    return (const pm_magic_comment_t *) parser->magic_comment_list.head;
}
 
size_t
pm_parser_errors_size(const pm_parser_t *parser) {
    return parser->error_list.size;
}
 
size_t
pm_parser_warnings_size(const pm_parser_t *parser) {
    return parser->warning_list.size;
}
 
const pm_diagnostic_t *
pm_parser_errors_first(const pm_parser_t *parser) {
    return (const pm_diagnostic_t *) parser->error_list.head;
}
 
const pm_diagnostic_t *
pm_parser_warnings_first(const pm_parser_t *parser) {
    return (const pm_diagnostic_t *) parser->warning_list.head;
}
 
size_t
pm_parser_constants_size(const pm_parser_t *parser) {
    return parser->constant_pool.size;
}
 
const pm_constant_t *
pm_parser_constant_at(const pm_parser_t *parser, size_t index) {
    assert(index < parser->constant_pool.size);
    return &parser->constant_pool.constants[index];
}
 
const pm_constant_t *
pm_parser_constant(const pm_parser_t *parser, pm_constant_id_t constant_id) {
    return pm_constant_pool_id_to_constant(&parser->constant_pool, constant_id);
}