1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[ruby/prism] Get general prettyprint structure working

Browse Source 
https://github.com/ruby/prism/commit/7c9cf63d4c
This commit is contained in:
Kevin Newton 2023-10-24 10:04:48 -04:00
parent 9792be3610
commit e9aa2398b9
6 changed files with 249 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
prism/extension.c
View File

@ -554,6 +554,27 @@ parse_serialize_file_metadata(VALUE self, VALUE filepath, VALUE metadata) {
return result; return result;
} }
static VALUE
rb_prism_debug_inspect_node(VALUE self, VALUE source) {
pm_string_t input;
input_load_string(&input, source);
pm_parser_t parser;
pm_parser_init(&parser, pm_string_source(&input), pm_string_length(&input), NULL);
pm_node_t *node = pm_parse(&parser);
pm_buffer_t buffer = { 0 };
pm_prettyprint(&parser, node, &buffer);
VALUE string = rb_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer));
pm_buffer_free(&buffer);
pm_node_destroy(&parser, node);
pm_parser_free(&parser);
return string;
}
/******************************************************************************/ /******************************************************************************/
/* Initialization of the extension */ /* Initialization of the extension */
/******************************************************************************/ /******************************************************************************/
@ -607,6 +628,8 @@ Init_prism(void) {
rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1); rb_define_singleton_method(rb_cPrismDebug, "profile_file", profile_file, 1);
rb_define_singleton_method(rb_cPrismDebug, "parse_serialize_file_metadata", parse_serialize_file_metadata, 2); rb_define_singleton_method(rb_cPrismDebug, "parse_serialize_file_metadata", parse_serialize_file_metadata, 2);
rb_define_singleton_method(rb_cPrismDebug, "inspect_node", rb_prism_debug_inspect_node, 1);
// Next, initialize the other APIs. // Next, initialize the other APIs.
Init_prism_api_node(); Init_prism_api_node();
Init_prism_pack(); Init_prism_pack();

80
prism/prism.c
View File

@ -6343,24 +6343,24 @@ escape_byte(uint8_t value, const uint8_t flags) {
static inline void static inline void
escape_write_unicode(pm_parser_t *parser, pm_buffer_t *buffer, const uint8_t *start, const uint8_t *end, uint32_t value) { escape_write_unicode(pm_parser_t *parser, pm_buffer_t *buffer, const uint8_t *start, const uint8_t *end, uint32_t value) {
if (value <= 0x7F) { // 0xxxxxxx if (value <= 0x7F) { // 0xxxxxxx
pm_buffer_append_u8(buffer, (uint8_t) value); pm_buffer_append_byte(buffer, (uint8_t) value);
} else if (value <= 0x7FF) { // 110xxxxx 10xxxxxx } else if (value <= 0x7FF) { // 110xxxxx 10xxxxxx
pm_buffer_append_u8(buffer, (uint8_t) (0xC0 | (value >> 6))); pm_buffer_append_byte(buffer, (uint8_t) (0xC0 | (value >> 6)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | (value & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | (value & 0x3F)));
} else if (value <= 0xFFFF) { // 1110xxxx 10xxxxxx 10xxxxxx } else if (value <= 0xFFFF) { // 1110xxxx 10xxxxxx 10xxxxxx
pm_buffer_append_u8(buffer, (uint8_t) (0xE0 | (value >> 12))); pm_buffer_append_byte(buffer, (uint8_t) (0xE0 | (value >> 12)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | ((value >> 6) & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | ((value >> 6) & 0x3F)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | (value & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | (value & 0x3F)));
} else if (value <= 0x10FFFF) { // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx } else if (value <= 0x10FFFF) { // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
pm_buffer_append_u8(buffer, (uint8_t) (0xF0 | (value >> 18))); pm_buffer_append_byte(buffer, (uint8_t) (0xF0 | (value >> 18)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | ((value >> 12) & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | ((value >> 12) & 0x3F)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | ((value >> 6) & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | ((value >> 6) & 0x3F)));
pm_buffer_append_u8(buffer, (uint8_t) (0x80 | (value & 0x3F))); pm_buffer_append_byte(buffer, (uint8_t) (0x80 | (value & 0x3F)));
} else { } else {
pm_parser_err(parser, start, end, PM_ERR_ESCAPE_INVALID_UNICODE); pm_parser_err(parser, start, end, PM_ERR_ESCAPE_INVALID_UNICODE);
pm_buffer_append_u8(buffer, 0xEF); pm_buffer_append_byte(buffer, 0xEF);
pm_buffer_append_u8(buffer, 0xBF); pm_buffer_append_byte(buffer, 0xBF);
pm_buffer_append_u8(buffer, 0xBD); pm_buffer_append_byte(buffer, 0xBD);
} }
} }
@ -6386,18 +6386,18 @@ escape_write_byte(pm_buffer_t *buffer, uint8_t flags, uint8_t byte) {
uint8_t byte2 = (uint8_t) (byte & 0xF); uint8_t byte2 = (uint8_t) (byte & 0xF);
if (byte1 >= 0xA) { if (byte1 >= 0xA) {
pm_buffer_append_u8(buffer, (uint8_t) ((byte1 - 0xA) + 'A')); pm_buffer_append_byte(buffer, (uint8_t) ((byte1 - 0xA) + 'A'));
} else { } else {
pm_buffer_append_u8(buffer, (uint8_t) (byte1 + '0')); pm_buffer_append_byte(buffer, (uint8_t) (byte1 + '0'));
} }
if (byte2 >= 0xA) { if (byte2 >= 0xA) {
pm_buffer_append_u8(buffer, (uint8_t) (byte2 - 0xA + 'A')); pm_buffer_append_byte(buffer, (uint8_t) (byte2 - 0xA + 'A'));
} else { } else {
pm_buffer_append_u8(buffer, (uint8_t) (byte2 + '0')); pm_buffer_append_byte(buffer, (uint8_t) (byte2 + '0'));
} }
} else { } else {
pm_buffer_append_u8(buffer, byte); pm_buffer_append_byte(buffer, byte);
} }
} }
@ -6407,57 +6407,57 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, uint8_t flags) {
switch (peek(parser)) { switch (peek(parser)) {
case '\\': { case '\\': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\\'); pm_buffer_append_byte(buffer, '\\');
return; return;
} }
case '\'': { case '\'': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\''); pm_buffer_append_byte(buffer, '\'');
return; return;
} }
case 'a': { case 'a': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\a'); pm_buffer_append_byte(buffer, '\a');
return; return;
} }
case 'b': { case 'b': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\b'); pm_buffer_append_byte(buffer, '\b');
return; return;
} }
case 'e': { case 'e': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\033'); pm_buffer_append_byte(buffer, '\033');
return; return;
} }
case 'f': { case 'f': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\f'); pm_buffer_append_byte(buffer, '\f');
return; return;
} }
case 'n': { case 'n': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\n'); pm_buffer_append_byte(buffer, '\n');
return; return;
} }
case 'r': { case 'r': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\r'); pm_buffer_append_byte(buffer, '\r');
return; return;
} }
case 's': { case 's': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, ' '); pm_buffer_append_byte(buffer, ' ');
return; return;
} }
case 't': { case 't': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\t'); pm_buffer_append_byte(buffer, '\t');
return; return;
} }
case 'v': { case 'v': {
parser->current.end++; parser->current.end++;
pm_buffer_append_u8(buffer, '\v'); pm_buffer_append_byte(buffer, '\v');
return; return;
} }
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': {
@ -6474,7 +6474,7 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, uint8_t flags) {
} }
} }
pm_buffer_append_u8(buffer, value); pm_buffer_append_byte(buffer, value);
return; return;
} }
case 'x': { case 'x': {
@ -6496,7 +6496,7 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, uint8_t flags) {
if (flags & PM_ESCAPE_FLAG_REGEXP) { if (flags & PM_ESCAPE_FLAG_REGEXP) {
pm_buffer_append_bytes(buffer, start, (size_t) (parser->current.end - start)); pm_buffer_append_bytes(buffer, start, (size_t) (parser->current.end - start));
} else { } else {
pm_buffer_append_u8(buffer, value); pm_buffer_append_byte(buffer, value);
} }
} else { } else {
pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_HEXADECIMAL); pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_HEXADECIMAL);
@ -6690,14 +6690,14 @@ escape_read(pm_parser_t *parser, pm_buffer_t *buffer, uint8_t flags) {
case '\r': { case '\r': {
if (peek_offset(parser, 1) == '\n') { if (peek_offset(parser, 1) == '\n') {
parser->current.end += 2; parser->current.end += 2;
pm_buffer_append_u8(buffer, '\n'); pm_buffer_append_byte(buffer, '\n');
return; return;
} }
} }
/* fallthrough */ /* fallthrough */
default: { default: {
if (parser->current.end < parser->end) { if (parser->current.end < parser->end) {
pm_buffer_append_u8(buffer, *parser->current.end++); pm_buffer_append_byte(buffer, *parser->current.end++);
} }
return; return;
} }
@ -6951,7 +6951,7 @@ typedef struct {
// Push the given byte into the token buffer. // Push the given byte into the token buffer.
static inline void static inline void
pm_token_buffer_push(pm_token_buffer_t *token_buffer, uint8_t byte) { pm_token_buffer_push(pm_token_buffer_t *token_buffer, uint8_t byte) {
pm_buffer_append_u8(&token_buffer->buffer, byte); pm_buffer_append_byte(&token_buffer->buffer, byte);
} }
// When we're about to return from lexing the current token and we know for sure // When we're about to return from lexing the current token and we know for sure
@ -15592,14 +15592,14 @@ pm_parse(pm_parser_t *parser) {
PRISM_EXPORTED_FUNCTION void PRISM_EXPORTED_FUNCTION void
pm_serialize(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_serialize(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
pm_buffer_append_str(buffer, "PRISM", 5); pm_buffer_append_string(buffer, "PRISM", 5);
pm_buffer_append_u8(buffer, PRISM_VERSION_MAJOR); pm_buffer_append_byte(buffer, PRISM_VERSION_MAJOR);
pm_buffer_append_u8(buffer, PRISM_VERSION_MINOR); pm_buffer_append_byte(buffer, PRISM_VERSION_MINOR);
pm_buffer_append_u8(buffer, PRISM_VERSION_PATCH); pm_buffer_append_byte(buffer, PRISM_VERSION_PATCH);
pm_buffer_append_u8(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0); pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0);
pm_serialize_content(parser, node, buffer); pm_serialize_content(parser, node, buffer);
pm_buffer_append_str(buffer, "\0", 1); pm_buffer_append_string(buffer, "\0", 1);
} }
// Parse and serialize the AST represented by the given source to the given // Parse and serialize the AST represented by the given source to the given

173
prism/templates/src/prettyprint.c.erb
View File

@ -7,86 +7,134 @@
#include "prism/util/pm_buffer.h" #include "prism/util/pm_buffer.h"
static void static void
prettyprint_location(pm_buffer_t *buffer, pm_parser_t *parser, pm_location_t *location) { prettyprint_node(pm_buffer_t *output_buffer, pm_parser_t *parser, pm_node_t *node, pm_buffer_t *prefix_buffer);
static void
prettyprint_location(pm_buffer_t *output_buffer, pm_parser_t *parser, pm_location_t *location) {
char printed[] = "[0000-0000]"; char printed[] = "[0000-0000]";
snprintf(printed, sizeof(printed), "[%04ld-%04ld]", (long int)(location->start - parser->start), (long int)(location->end - parser->start)); snprintf(printed, sizeof(printed), "[%04ld-%04ld]", (long int) (location->start - parser->start), (long int) (location->end - parser->start));
pm_buffer_append_str(buffer, printed, strlen(printed)); pm_buffer_append_string(output_buffer, printed, strlen(printed));
} }
static void static void
prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) { prettyprint_node(pm_buffer_t *output_buffer, pm_parser_t *parser, pm_node_t *node, pm_buffer_t *prefix_buffer) {
switch (PM_NODE_TYPE(node)) { switch (PM_NODE_TYPE(node)) {
// We do not need to print a ScopeNode as it's not part
// of the AST
case PM_SCOPE_NODE: case PM_SCOPE_NODE:
// We do not need to print a ScopeNode as it's not part of the AST.
return; return;
<%- nodes.each do |node| -%> <%- nodes.each do |node| -%>
case <%= node.type %>: { case <%= node.type %>: {
pm_buffer_append_str(buffer, "<%= node.name %>(", <%= node.name.length + 1 %>); <%- if node.fields.any? { |field| !field.is_a?(Prism::FlagsField) } -%>
pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;
<%- end -%>
pm_buffer_append_string(output_buffer, "@ <%= node.name %> (location: ()-())\n", <%= node.name.length + 21 %>);
<%- node.fields.each_with_index do |field, index| -%> <%- node.fields.each_with_index do |field, index| -%>
<%= "pm_buffer_append_str(buffer, \", \", 2);" if index != 0 -%> <%- pointer, preadd = index == node.fields.length - 1 ? ["└── ", " "] : ["├── ", "│ "] -%>
// <%= field.name %>
{
pm_buffer_concat(output_buffer, prefix_buffer);
pm_buffer_append_string(output_buffer, "<%= pointer %><%= field.name %>:", <%= pointer.bytesize + field.name.length + 1 %>);
<%- case field -%> <%- case field -%>
<%- when Prism::NodeField -%> <%- when Prism::NodeField -%>
prettyprint_node(buffer, parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>); pm_buffer_append_byte(output_buffer, '\n');
size_t prefix_length = prefix_buffer->length;
pm_buffer_append_string(prefix_buffer, "<%= preadd %>", <%= preadd.bytesize %>);
pm_buffer_concat(output_buffer, prefix_buffer);
prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer);
prefix_buffer->length = prefix_length;
<%- when Prism::OptionalNodeField -%> <%- when Prism::OptionalNodeField -%>
if (((pm_<%= node.human %>_t *)node)-><%= field.name %> == NULL) { if (cast-><%= field.name %> == NULL) {
pm_buffer_append_str(buffer, "nil", 3); pm_buffer_append_string(output_buffer, " ∅\n", 5);
} else { } else {
prettyprint_node(buffer, parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>); pm_buffer_append_byte(output_buffer, '\n');
}
size_t prefix_length = prefix_buffer->length;
pm_buffer_append_string(prefix_buffer, "<%= preadd %>", <%= preadd.bytesize %>);
pm_buffer_concat(output_buffer, prefix_buffer);
prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>, prefix_buffer);
prefix_buffer->length = prefix_length;
}
<%- when Prism::StringField -%> <%- when Prism::StringField -%>
pm_buffer_append_str(buffer, "\"", 1); pm_buffer_append_string(output_buffer, " \"", 2);
pm_buffer_append_bytes(buffer, pm_string_source(&((pm_<%= node.human %>_t *)node)-><%= field.name %>), pm_string_length(&((pm_<%= node.human %>_t *)node)-><%= field.name %>)); pm_buffer_append_bytes(output_buffer, pm_string_source(&cast-><%= field.name %>), pm_string_length(&cast-><%= field.name %>));
pm_buffer_append_str(buffer, "\"", 1); pm_buffer_append_string(output_buffer, "\"\n", 2);
<%- when Prism::NodeListField -%> <%- when Prism::NodeListField -%>
pm_buffer_append_str(buffer, "[", 1); pm_buffer_append_string(output_buffer, " (length: )\n", 13);
for (uint32_t index = 0; index < ((pm_<%= node.human %>_t *)node)-><%= field.name %>.size; index++) { size_t last_index = cast-><%= field.name %>.size - 1;
if (index != 0) pm_buffer_append_str(buffer, ", ", 2); for (uint32_t index = 0; index <= last_index; index++) {
prettyprint_node(buffer, parser, (pm_node_t *) ((pm_<%= node.human %>_t *) node)-><%= field.name %>.nodes[index]); size_t prefix_length = prefix_buffer->length;
} pm_buffer_append_string(prefix_buffer, " ", 4);
pm_buffer_append_str(buffer, "]", 1); pm_buffer_concat(output_buffer, prefix_buffer);
if (index == last_index) {
pm_buffer_append_string(output_buffer, "└── ", 10);
pm_buffer_append_string(prefix_buffer, " ", 4);
} else {
pm_buffer_append_string(output_buffer, "├── ", 10);
pm_buffer_append_string(prefix_buffer, "│ ", 6);
}
prettyprint_node(output_buffer, parser, (pm_node_t *) cast-><%= field.name %>.nodes[index], prefix_buffer);
prefix_buffer->length = prefix_length;
}
pm_buffer_append_string(output_buffer, "\n", 1);
<%- when Prism::ConstantField -%> <%- when Prism::ConstantField -%>
char <%= field.name %>_buffer[12]; char <%= field.name %>_buffer[12];
snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", ((pm_<%= node.human %>_t *)node)-><%= field.name %>); snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", cast-><%= field.name %>);
pm_buffer_append_str(buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer)); pm_buffer_append_byte(output_buffer, ' ');
pm_buffer_append_string(output_buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer));
pm_buffer_append_byte(output_buffer, '\n');
<%- when Prism::OptionalConstantField -%> <%- when Prism::OptionalConstantField -%>
if (((pm_<%= node.human %>_t *)node)-><%= field.name %> == 0) { if (cast-><%= field.name %> == 0) {
pm_buffer_append_str(buffer, "nil", 3); pm_buffer_append_string(output_buffer, " ∅\n", 5);
} else { } else {
char <%= field.name %>_buffer[12]; char <%= field.name %>_buffer[12];
snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", ((pm_<%= node.human %>_t *)node)-><%= field.name %>); snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", cast-><%= field.name %>);
pm_buffer_append_str(buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer)); pm_buffer_append_byte(output_buffer, ' ');
} pm_buffer_append_string(output_buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer));
pm_buffer_append_byte(output_buffer, '\n');
}
<%- when Prism::ConstantListField -%> <%- when Prism::ConstantListField -%>
pm_buffer_append_str(buffer, "[", 1); pm_buffer_append_string(output_buffer, " [", 2);
for (uint32_t index = 0; index < ((pm_<%= node.human %>_t *)node)-><%= field.name %>.size; index++) { for (uint32_t index = 0; index < cast-><%= field.name %>.size; index++) {
if (index != 0) pm_buffer_append_str(buffer, ", ", 2); if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
char <%= field.name %>_buffer[12]; char <%= field.name %>_buffer[12];
snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", ((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index]); snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "%u", cast-><%= field.name %>.ids[index]);
pm_buffer_append_str(buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer)); pm_buffer_append_string(output_buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer));
} }
pm_buffer_append_str(buffer, "]", 1); pm_buffer_append_string(output_buffer, "]\n", 2);
<%- when Prism::LocationField -%> <%- when Prism::LocationField -%>
prettyprint_location(buffer, parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>); pm_buffer_append_byte(output_buffer, ' ');
prettyprint_location(output_buffer, parser, &cast-><%= field.name %>);
pm_buffer_append_byte(output_buffer, '\n');
<%- when Prism::OptionalLocationField -%> <%- when Prism::OptionalLocationField -%>
if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.start == NULL) { if (cast-><%= field.name %>.start == NULL) {
pm_buffer_append_str(buffer, "nil", 3); pm_buffer_append_string(output_buffer, " ∅\n", 5);
} else { } else {
prettyprint_location(buffer, parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>); pm_buffer_append_byte(output_buffer, ' ');
} prettyprint_location(output_buffer, parser, &cast-><%= field.name %>);
pm_buffer_append_byte(output_buffer, '\n');
}
<%- when Prism::UInt32Field -%> <%- when Prism::UInt32Field -%>
char <%= field.name %>_buffer[12]; char <%= field.name %>_buffer[12];
snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "+%d", ((pm_<%= node.human %>_t *)node)-><%= field.name %>); snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "+%d", cast-><%= field.name %>);
pm_buffer_append_str(buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer)); pm_buffer_append_byte(output_buffer, ' ');
pm_buffer_append_string(output_buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer));
pm_buffer_append_byte(output_buffer, '\n');
<%- when Prism::FlagsField -%> <%- when Prism::FlagsField -%>
char <%= field.name %>_buffer[12]; char <%= field.name %>_buffer[12];
snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK)); snprintf(<%= field.name %>_buffer, sizeof(<%= field.name %>_buffer), "+%d", (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
pm_buffer_append_str(buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer)); pm_buffer_append_byte(output_buffer, ' ');
pm_buffer_append_string(output_buffer, <%= field.name %>_buffer, strlen(<%= field.name %>_buffer));
pm_buffer_append_byte(output_buffer, '\n');
<%- else -%> <%- else -%>
<%- raise -%> <%- raise -%>
<%- end -%> <%- end -%>
}
<%- end -%> <%- end -%>
pm_buffer_append_str(buffer, ")", 1);
break; break;
} }
<%- end -%> <%- end -%>
@ -95,17 +143,20 @@ prettyprint_node(pm_buffer_t *buffer, pm_parser_t *parser, pm_node_t *node) {
void void
pm_print_node(pm_parser_t *parser, pm_node_t *node) { pm_print_node(pm_parser_t *parser, pm_node_t *node) {
pm_buffer_t buffer; pm_buffer_t output_buffer = { 0 };
if (!pm_buffer_init(&buffer)) return; pm_buffer_t prefix_buffer = { 0 };
prettyprint_node(&buffer, parser, node); prettyprint_node(&output_buffer, parser, node, &prefix_buffer);
printf("%.*s\n", (int) buffer.length, buffer.value); printf("%.*s\n", (int) output_buffer.length, output_buffer.value);
pm_buffer_free(&buffer); pm_buffer_free(&output_buffer);
pm_buffer_free(&prefix_buffer);
} }
// 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 PRISM_EXPORTED_FUNCTION void
pm_prettyprint(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_prettyprint(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *output_buffer) {
prettyprint_node(buffer, parser, node); pm_buffer_t prefix_buffer = { 0 };
prettyprint_node(output_buffer, parser, node, &prefix_buffer);
pm_buffer_free(&prefix_buffer);
} }

82
prism/templates/src/serialize.c.erb
View File

@ -20,24 +20,24 @@ pm_serialize_location(pm_parser_t *parser, pm_location_t *location, pm_buffer_t
assert(location->end); assert(location->end);
assert(location->start <= location->end); assert(location->start <= location->end);
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(location->start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(location->start - parser->start));
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(location->end - location->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(location->end - location->start));
} }
static void static void
pm_serialize_string(pm_parser_t *parser, pm_string_t *string, pm_buffer_t *buffer) { pm_serialize_string(pm_parser_t *parser, pm_string_t *string, pm_buffer_t *buffer) {
switch (string->type) { switch (string->type) {
case PM_STRING_SHARED: { case PM_STRING_SHARED: {
pm_buffer_append_u8(buffer, 1); pm_buffer_append_byte(buffer, 1);
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
pm_buffer_append_u32(buffer, pm_sizet_to_u32(pm_string_length(string))); pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_string_length(string)));
break; break;
} }
case PM_STRING_OWNED: case PM_STRING_OWNED:
case PM_STRING_CONSTANT: { case PM_STRING_CONSTANT: {
uint32_t length = pm_sizet_to_u32(pm_string_length(string)); uint32_t length = pm_sizet_to_u32(pm_string_length(string));
pm_buffer_append_u8(buffer, 2); pm_buffer_append_byte(buffer, 2);
pm_buffer_append_u32(buffer, length); pm_buffer_append_varint(buffer, length);
pm_buffer_append_bytes(buffer, pm_string_source(string), length); pm_buffer_append_bytes(buffer, pm_string_source(string), length);
break; break;
} }
@ -49,7 +49,7 @@ pm_serialize_string(pm_parser_t *parser, pm_string_t *string, pm_buffer_t *buffe
void void
pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
pm_buffer_append_u8(buffer, (uint8_t) PM_NODE_TYPE(node)); pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
size_t offset = buffer->length; size_t offset = buffer->length;
@ -66,7 +66,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
// serialize length // serialize length
// encoding of location u32s make us need to save this offset. // encoding of location u32s make us need to save this offset.
size_t length_offset = buffer->length; size_t length_offset = buffer->length;
pm_buffer_append_str(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */ pm_buffer_append_string(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
<%- end -%> <%- end -%>
<%- node.fields.each do |field| -%> <%- node.fields.each do |field| -%>
<%- case field -%> <%- case field -%>
@ -74,7 +74,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
<%- when Prism::OptionalNodeField -%> <%- when Prism::OptionalNodeField -%>
if (((pm_<%= node.human %>_t *)node)-><%= field.name %> == NULL) { if (((pm_<%= node.human %>_t *)node)-><%= field.name %> == NULL) {
pm_buffer_append_u8(buffer, 0); pm_buffer_append_byte(buffer, 0);
} else { } else {
pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
} }
@ -82,17 +82,17 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
pm_serialize_string(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); pm_serialize_string(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
<%- when Prism::NodeListField -%> <%- when Prism::NodeListField -%>
uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size); uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
pm_buffer_append_u32(buffer, <%= field.name %>_size); pm_buffer_append_varint(buffer, <%= field.name %>_size);
for (uint32_t index = 0; index < <%= field.name %>_size; index++) { for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
pm_serialize_node(parser, (pm_node_t *) ((pm_<%= node.human %>_t *)node)-><%= field.name %>.nodes[index], buffer); pm_serialize_node(parser, (pm_node_t *) ((pm_<%= node.human %>_t *)node)-><%= field.name %>.nodes[index], buffer);
} }
<%- when Prism::ConstantField, Prism::OptionalConstantField -%> <%- when Prism::ConstantField, Prism::OptionalConstantField -%>
pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>)); pm_buffer_append_varint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>));
<%- when Prism::ConstantListField -%> <%- when Prism::ConstantListField -%>
uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size); uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size);
pm_buffer_append_u32(buffer, <%= field.name %>_size); pm_buffer_append_varint(buffer, <%= field.name %>_size);
for (uint32_t index = 0; index < <%= field.name %>_size; index++) { for (uint32_t index = 0; index < <%= field.name %>_size; index++) {
pm_buffer_append_u32(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index])); pm_buffer_append_varint(buffer, pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.ids[index]));
} }
<%- when Prism::LocationField -%> <%- when Prism::LocationField -%>
<%- if field.should_be_serialized? -%> <%- if field.should_be_serialized? -%>
@ -101,16 +101,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
<%- when Prism::OptionalLocationField -%> <%- when Prism::OptionalLocationField -%>
<%- if field.should_be_serialized? -%> <%- if field.should_be_serialized? -%>
if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.start == NULL) { if (((pm_<%= node.human %>_t *)node)-><%= field.name %>.start == NULL) {
pm_buffer_append_u8(buffer, 0); pm_buffer_append_byte(buffer, 0);
} else { } else {
pm_buffer_append_u8(buffer, 1); pm_buffer_append_byte(buffer, 1);
pm_serialize_location(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); pm_serialize_location(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer);
} }
<%- end -%> <%- end -%>
<%- when Prism::UInt32Field -%> <%- when Prism::UInt32Field -%>
pm_buffer_append_u32(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>); pm_buffer_append_varint(buffer, ((pm_<%= node.human %>_t *)node)-><%= field.name %>);
<%- when Prism::FlagsField -%> <%- when Prism::FlagsField -%>
pm_buffer_append_u32(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK)); pm_buffer_append_varint(buffer, (uint32_t)(node->flags & ~PM_NODE_FLAG_COMMON_MASK));
<%- else -%> <%- else -%>
<%- raise -%> <%- raise -%>
<%- end -%> <%- end -%>
@ -129,16 +129,16 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
static void static void
pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *buffer) { pm_serialize_comment(pm_parser_t *parser, pm_comment_t *comment, pm_buffer_t *buffer) {
// serialize type // serialize type
pm_buffer_append_u8(buffer, (uint8_t) comment->type); pm_buffer_append_byte(buffer, (uint8_t) comment->type);
// serialize location // serialize location
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(comment->start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(comment->start - parser->start));
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(comment->end - comment->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(comment->end - comment->start));
} }
static void static void
pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) { pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
pm_buffer_append_u32(buffer, pm_sizet_to_u32(pm_list_size(list))); pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
pm_comment_t *comment; pm_comment_t *comment;
for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) { for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
@ -149,17 +149,17 @@ pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buf
static void static void
pm_serialize_magic_comment(pm_parser_t *parser, pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) { pm_serialize_magic_comment(pm_parser_t *parser, pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
// serialize key location // serialize key location
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(magic_comment->key_start - parser->start));
pm_buffer_append_u32(buffer, pm_sizet_to_u32(magic_comment->key_length)); pm_buffer_append_varint(buffer, pm_sizet_to_u32(magic_comment->key_length));
// serialize value location // serialize value location
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(magic_comment->value_start - parser->start));
pm_buffer_append_u32(buffer, pm_sizet_to_u32(magic_comment->value_length)); pm_buffer_append_varint(buffer, pm_sizet_to_u32(magic_comment->value_length));
} }
static void static void
pm_serialize_magic_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) { pm_serialize_magic_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
pm_buffer_append_u32(buffer, pm_sizet_to_u32(pm_list_size(list))); pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
pm_magic_comment_t *magic_comment; pm_magic_comment_t *magic_comment;
for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) { for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
@ -171,17 +171,17 @@ static void
pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) { pm_serialize_diagnostic(pm_parser_t *parser, pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
// serialize message // serialize message
size_t message_length = strlen(diagnostic->message); size_t message_length = strlen(diagnostic->message);
pm_buffer_append_u32(buffer, pm_sizet_to_u32(message_length)); pm_buffer_append_varint(buffer, pm_sizet_to_u32(message_length));
pm_buffer_append_str(buffer, diagnostic->message, message_length); pm_buffer_append_string(buffer, diagnostic->message, message_length);
// serialize location // serialize location
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(diagnostic->start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(diagnostic->start - parser->start));
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(diagnostic->end - diagnostic->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(diagnostic->end - diagnostic->start));
} }
static void static void
pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) { pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer) {
pm_buffer_append_u32(buffer, pm_sizet_to_u32(pm_list_size(list))); pm_buffer_append_varint(buffer, pm_sizet_to_u32(pm_list_size(list)));
pm_diagnostic_t *diagnostic; pm_diagnostic_t *diagnostic;
for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) { for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
@ -192,8 +192,8 @@ pm_serialize_diagnostic_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *
static void static void
pm_serialize_encoding(pm_encoding_t *encoding, pm_buffer_t *buffer) { pm_serialize_encoding(pm_encoding_t *encoding, pm_buffer_t *buffer) {
size_t encoding_length = strlen(encoding->name); size_t encoding_length = strlen(encoding->name);
pm_buffer_append_u32(buffer, pm_sizet_to_u32(encoding_length)); pm_buffer_append_varint(buffer, pm_sizet_to_u32(encoding_length));
pm_buffer_append_str(buffer, encoding->name, encoding_length); pm_buffer_append_string(buffer, encoding->name, encoding_length);
} }
#line <%= __LINE__ + 1 %> "<%= File.basename(__FILE__) %>" #line <%= __LINE__ + 1 %> "<%= File.basename(__FILE__) %>"
@ -213,7 +213,7 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
pm_buffer_append_zeroes(buffer, 4); pm_buffer_append_zeroes(buffer, 4);
// Next, encode the length of the constant pool. // Next, encode the length of the constant pool.
pm_buffer_append_u32(buffer, parser->constant_pool.size); pm_buffer_append_varint(buffer, parser->constant_pool.size);
// Now we're going to serialize the content of the node. // Now we're going to serialize the content of the node.
pm_serialize_node(parser, node, buffer); pm_serialize_node(parser, node, buffer);
@ -268,10 +268,10 @@ static void
serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) { serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
pm_buffer_t *buffer = (pm_buffer_t *) data; pm_buffer_t *buffer = (pm_buffer_t *) data;
pm_buffer_append_u32(buffer, token->type); pm_buffer_append_varint(buffer, token->type);
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(token->start - parser->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
pm_buffer_append_u32(buffer, pm_ptrdifft_to_u32(token->end - token->start)); pm_buffer_append_varint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
pm_buffer_append_u32(buffer, parser->lex_state); pm_buffer_append_varint(buffer, parser->lex_state);
} }
PRISM_EXPORTED_FUNCTION void PRISM_EXPORTED_FUNCTION void
@ -288,7 +288,7 @@ pm_lex_serialize(const uint8_t *source, size_t size, const char *filepath, pm_bu
pm_node_t *node = pm_parse(&parser); pm_node_t *node = pm_parse(&parser);
// Append 0 to mark end of tokens // Append 0 to mark end of tokens
pm_buffer_append_u8(buffer, 0); pm_buffer_append_byte(buffer, 0);
pm_serialize_encoding(&parser.encoding, buffer); pm_serialize_encoding(&parser.encoding, buffer);
pm_serialize_comment_list(&parser, &parser.comment_list, buffer); pm_serialize_comment_list(&parser, &parser.comment_list, buffer);
@ -316,7 +316,7 @@ pm_parse_lex_serialize(const uint8_t *source, size_t size, pm_buffer_t *buffer,
parser.lex_callback = &lex_callback; parser.lex_callback = &lex_callback;
pm_node_t *node = pm_parse(&parser); pm_node_t *node = pm_parse(&parser);
pm_buffer_append_u8(buffer, 0); pm_buffer_append_byte(buffer, 0);
pm_serialize(&parser, node, buffer); pm_serialize(&parser, node, buffer);
pm_node_destroy(&parser, node); pm_node_destroy(&parser, node);

38
prism/util/pm_buffer.c
View File

@ -40,9 +40,13 @@ pm_buffer_append_length(pm_buffer_t *buffer, size_t length) {
size_t next_length = buffer->length + length; size_t next_length = buffer->length + length;
if (next_length > buffer->capacity) { if (next_length > buffer->capacity) {
do { if (buffer->capacity == 0) {
buffer->capacity = 1;
}
while (next_length > buffer->capacity) {
buffer->capacity *= 2; buffer->capacity *= 2;
} while (next_length > buffer->capacity); }
buffer->value = realloc(buffer->value, buffer->capacity); buffer->value = realloc(buffer->value, buffer->capacity);
} }
@ -53,20 +57,22 @@ pm_buffer_append_length(pm_buffer_t *buffer, size_t length) {
// Append a generic pointer to memory to the buffer. // Append a generic pointer to memory to the buffer.
static inline void static inline void
pm_buffer_append(pm_buffer_t *buffer, const void *source, size_t length) { pm_buffer_append(pm_buffer_t *buffer, const void *source, size_t length) {
size_t cursor = buffer->length;
pm_buffer_append_length(buffer, length); pm_buffer_append_length(buffer, length);
memcpy(buffer->value + (buffer->length - length), source, length); memcpy(buffer->value + cursor, source, length);
} }
// Append the given amount of space as zeroes to the buffer. // Append the given amount of space as zeroes to the buffer.
void void
pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length) { pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length) {
size_t cursor = buffer->length;
pm_buffer_append_length(buffer, length); pm_buffer_append_length(buffer, length);
memset(buffer->value + (buffer->length - length), 0, length); memset(buffer->value + cursor, 0, length);
} }
// Append a string to the buffer. // Append a string to the buffer.
void void
pm_buffer_append_str(pm_buffer_t *buffer, const char *value, size_t length) { pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length) {
pm_buffer_append(buffer, value, length); pm_buffer_append(buffer, value, length);
} }
@ -78,27 +84,35 @@ pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length)
// Append a single byte to the buffer. // Append a single byte to the buffer.
void void
pm_buffer_append_u8(pm_buffer_t *buffer, uint8_t value) { pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value) {
const void *source = &value; const void *source = &value;
pm_buffer_append(buffer, source, sizeof(uint8_t)); pm_buffer_append(buffer, source, sizeof(uint8_t));
} }
// Append a 32-bit unsigned integer to the buffer. // Append a 32-bit unsigned integer to the buffer as a variable-length integer.
void void
pm_buffer_append_u32(pm_buffer_t *buffer, uint32_t value) { pm_buffer_append_varint(pm_buffer_t *buffer, uint32_t value) {
if (value < 128) { if (value < 128) {
pm_buffer_append_u8(buffer, (uint8_t) value); pm_buffer_append_byte(buffer, (uint8_t) value);
} else { } else {
uint32_t n = value; uint32_t n = value;
while (n >= 128) { while (n >= 128) {
pm_buffer_append_u8(buffer, (uint8_t) (n | 128)); pm_buffer_append_byte(buffer, (uint8_t) (n | 128));
n >>= 7; n >>= 7;
} }
pm_buffer_append_u8(buffer, (uint8_t) n); pm_buffer_append_byte(buffer, (uint8_t) n);
} }
} }
// Free the memory associated with the buffer. // Concatenate one buffer onto another.
void
pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source) {
if (source->length > 0) {
pm_buffer_append(destination, source->value, source->length);
}
}
// Free the internal memory associated with the buffer.
void void
pm_buffer_free(pm_buffer_t *buffer) { pm_buffer_free(pm_buffer_t *buffer) {
free(buffer->value); free(buffer->value);

11
prism/util/pm_buffer.h
View File

@ -13,9 +13,9 @@
// block of memory. It is used to store the serialized representation of a // block of memory. It is used to store the serialized representation of a
// prism tree. // prism tree.
typedef struct { typedef struct {
char *value;
size_t length; size_t length;
size_t capacity; size_t capacity;
char *value;
} pm_buffer_t; } pm_buffer_t;
// Return the size of the pm_buffer_t struct. // Return the size of the pm_buffer_t struct.
@ -37,16 +37,19 @@ PRISM_EXPORTED_FUNCTION size_t pm_buffer_length(pm_buffer_t *buffer);
void pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length); void pm_buffer_append_zeroes(pm_buffer_t *buffer, size_t length);
// Append a string to the buffer. // Append a string to the buffer.
void pm_buffer_append_str(pm_buffer_t *buffer, const char *value, size_t length); void pm_buffer_append_string(pm_buffer_t *buffer, const char *value, size_t length);
// Append a list of bytes to the buffer. // Append a list of bytes to the buffer.
void pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length); void pm_buffer_append_bytes(pm_buffer_t *buffer, const uint8_t *value, size_t length);
// Append a single byte to the buffer. // Append a single byte to the buffer.
void pm_buffer_append_u8(pm_buffer_t *buffer, uint8_t value); void pm_buffer_append_byte(pm_buffer_t *buffer, uint8_t value);
// Append a 32-bit unsigned integer to the buffer. // Append a 32-bit unsigned integer to the buffer.
void pm_buffer_append_u32(pm_buffer_t *buffer, uint32_t value); void pm_buffer_append_varint(pm_buffer_t *buffer, uint32_t value);
// Append one buffer onto another.
void pm_buffer_concat(pm_buffer_t *destination, const pm_buffer_t *source);
// Free the memory associated with the buffer. // Free the memory associated with the buffer.
PRISM_EXPORTED_FUNCTION void pm_buffer_free(pm_buffer_t *buffer); PRISM_EXPORTED_FUNCTION void pm_buffer_free(pm_buffer_t *buffer);