yarp 0.7.0 → 0.8.0

data/src/serialize.c

@@ -58,6 +58,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             serialize_location(parser, &((yp_and_node_t *)node)->operator_loc, buffer);
             break;
         }
+        case YP_NODE_AND_WRITE_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_and_write_node_t *)node)->target, buffer);
+            yp_serialize_node(parser, (yp_node_t *)((yp_and_write_node_t *)node)->value, buffer);
+            serialize_location(parser, &((yp_and_write_node_t *)node)->operator_loc, buffer);
+            break;
+        }
         case YP_NODE_ARGUMENTS_NODE: {
             uint32_t arguments_size = yp_sizet_to_u32(((yp_arguments_node_t *)node)->arguments.size);
             yp_buffer_append_u32(buffer, arguments_size);
@@ -203,10 +209,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_block_node_t *)node)->parameters, buffer);
             }
-            if (((yp_block_node_t *)node)->statements == NULL) {
+            if (((yp_block_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_block_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_block_node_t *)node)->body, buffer);
             }
             serialize_location(parser, &((yp_block_node_t *)node)->opening_loc, buffer);
             serialize_location(parser, &((yp_block_node_t *)node)->closing_loc, buffer);
@@ -366,33 +372,14 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->superclass, buffer);
             }
-            if (((yp_class_node_t *)node)->statements == NULL) {
+            if (((yp_class_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->body, buffer);
             }
             serialize_location(parser, &((yp_class_node_t *)node)->end_keyword_loc, buffer);
             break;
         }
-        case YP_NODE_CLASS_VARIABLE_OPERATOR_AND_WRITE_NODE: {
-            serialize_location(parser, &((yp_class_variable_operator_and_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_class_variable_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_operator_and_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CLASS_VARIABLE_OPERATOR_OR_WRITE_NODE: {
-            serialize_location(parser, &((yp_class_variable_operator_or_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_class_variable_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_operator_or_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
-            serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->operator));
-            break;
-        }
         case YP_NODE_CLASS_VARIABLE_READ_NODE: {
             break;
         }
@@ -411,25 +398,6 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             }
             break;
         }
-        case YP_NODE_CONSTANT_OPERATOR_AND_WRITE_NODE: {
-            serialize_location(parser, &((yp_constant_operator_and_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_constant_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_and_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CONSTANT_OPERATOR_OR_WRITE_NODE: {
-            serialize_location(parser, &((yp_constant_operator_or_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_constant_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_or_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
-            serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->operator));
-            break;
-        }
         case YP_NODE_CONSTANT_PATH_NODE: {
             if (((yp_constant_path_node_t *)node)->parent == NULL) {
                 yp_buffer_append_u8(buffer, 0);
@@ -440,25 +408,6 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             serialize_location(parser, &((yp_constant_path_node_t *)node)->delimiter_loc, buffer);
             break;
         }
-        case YP_NODE_CONSTANT_PATH_OPERATOR_AND_WRITE_NODE: {
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_and_write_node_t *)node)->target, buffer);
-            serialize_location(parser, &((yp_constant_path_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_and_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CONSTANT_PATH_OPERATOR_OR_WRITE_NODE: {
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_or_write_node_t *)node)->target, buffer);
-            serialize_location(parser, &((yp_constant_path_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_or_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, buffer);
-            serialize_location(parser, &((yp_constant_path_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_path_operator_write_node_t *)node)->operator));
-            break;
-        }
         case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
             yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target, buffer);
             if (((yp_constant_path_write_node_t *)node)->operator_loc.start == NULL) {
@@ -508,10 +457,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_def_node_t *)node)->parameters, buffer);
             }
-            if (((yp_def_node_t *)node)->statements == NULL) {
+            if (((yp_def_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_def_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_def_node_t *)node)->body, buffer);
             }
             uint32_t locals_size = yp_sizet_to_u32(((yp_def_node_t *)node)->locals.size);
             yp_buffer_append_u32(buffer, locals_size);
@@ -692,25 +641,6 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             }
             break;
         }
-        case YP_NODE_GLOBAL_VARIABLE_OPERATOR_AND_WRITE_NODE: {
-            serialize_location(parser, &((yp_global_variable_operator_and_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_global_variable_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_and_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_GLOBAL_VARIABLE_OPERATOR_OR_WRITE_NODE: {
-            serialize_location(parser, &((yp_global_variable_operator_or_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_global_variable_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_or_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
-            serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->operator));
-            break;
-        }
         case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
             break;
         }
@@ -815,25 +745,6 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             }
             break;
         }
-        case YP_NODE_INSTANCE_VARIABLE_OPERATOR_AND_WRITE_NODE: {
-            serialize_location(parser, &((yp_instance_variable_operator_and_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_instance_variable_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_operator_and_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_INSTANCE_VARIABLE_OPERATOR_OR_WRITE_NODE: {
-            serialize_location(parser, &((yp_instance_variable_operator_or_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_instance_variable_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_operator_or_write_node_t *)node)->value, buffer);
-            break;
-        }
-        case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
-            serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->operator));
-            break;
-        }
         case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
             break;
         }
@@ -955,35 +866,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             } else {
                 yp_serialize_node(parser, (yp_node_t *)((yp_lambda_node_t *)node)->parameters, buffer);
             }
-            if (((yp_lambda_node_t *)node)->statements == NULL) {
+            if (((yp_lambda_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_lambda_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_lambda_node_t *)node)->body, buffer);
             }
             break;
         }
-        case YP_NODE_LOCAL_VARIABLE_OPERATOR_AND_WRITE_NODE: {
-            serialize_location(parser, &((yp_local_variable_operator_and_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_local_variable_operator_and_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_and_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_and_write_node_t *)node)->constant_id));
-            break;
-        }
-        case YP_NODE_LOCAL_VARIABLE_OPERATOR_OR_WRITE_NODE: {
-            serialize_location(parser, &((yp_local_variable_operator_or_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_local_variable_operator_or_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_or_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_or_write_node_t *)node)->constant_id));
-            break;
-        }
-        case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
-            serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->name_loc, buffer);
-            serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->operator_loc, buffer);
-            yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, buffer);
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_write_node_t *)node)->constant_id));
-            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_operator_write_node_t *)node)->operator_id));
-            break;
-        }
         case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
             yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_read_node_t *)node)->constant_id));
             yp_buffer_append_u32(buffer, ((yp_local_variable_read_node_t *)node)->depth);
@@ -1029,10 +918,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             }
             serialize_location(parser, &((yp_module_node_t *)node)->module_keyword_loc, buffer);
             yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->constant_path, buffer);
-            if (((yp_module_node_t *)node)->statements == NULL) {
+            if (((yp_module_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->body, buffer);
             }
             serialize_location(parser, &((yp_module_node_t *)node)->end_keyword_loc, buffer);
             break;
@@ -1088,6 +977,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
         case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
             break;
         }
+        case YP_NODE_OPERATOR_WRITE_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->target, buffer);
+            serialize_location(parser, &((yp_operator_write_node_t *)node)->operator_loc, buffer);
+            yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_operator_write_node_t *)node)->operator));
+            yp_serialize_node(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->value, buffer);
+            break;
+        }
         case YP_NODE_OPTIONAL_PARAMETER_NODE: {
             yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_optional_parameter_node_t *)node)->constant_id));
             serialize_location(parser, &((yp_optional_parameter_node_t *)node)->name_loc, buffer);
@@ -1101,6 +997,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             serialize_location(parser, &((yp_or_node_t *)node)->operator_loc, buffer);
             break;
         }
+        case YP_NODE_OR_WRITE_NODE: {
+            yp_serialize_node(parser, (yp_node_t *)((yp_or_write_node_t *)node)->target, buffer);
+            yp_serialize_node(parser, (yp_node_t *)((yp_or_write_node_t *)node)->value, buffer);
+            serialize_location(parser, &((yp_or_write_node_t *)node)->operator_loc, buffer);
+            break;
+        }
         case YP_NODE_PARAMETERS_NODE: {
             uint32_t requireds_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->requireds.size);
             yp_buffer_append_u32(buffer, requireds_size);
@@ -1140,10 +1042,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             break;
         }
         case YP_NODE_PARENTHESES_NODE: {
-            if (((yp_parentheses_node_t *)node)->statements == NULL) {
+            if (((yp_parentheses_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_parentheses_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_parentheses_node_t *)node)->body, buffer);
             }
             serialize_location(parser, &((yp_parentheses_node_t *)node)->opening_loc, buffer);
             serialize_location(parser, &((yp_parentheses_node_t *)node)->closing_loc, buffer);
@@ -1308,10 +1210,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
             serialize_location(parser, &((yp_singleton_class_node_t *)node)->class_keyword_loc, buffer);
             serialize_location(parser, &((yp_singleton_class_node_t *)node)->operator_loc, buffer);
             yp_serialize_node(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->expression, buffer);
-            if (((yp_singleton_class_node_t *)node)->statements == NULL) {
+            if (((yp_singleton_class_node_t *)node)->body == NULL) {
                 yp_buffer_append_u8(buffer, 0);
             } else {
-                yp_serialize_node(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->statements, buffer);
+                yp_serialize_node(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->body, buffer);
             }
             serialize_location(parser, &((yp_singleton_class_node_t *)node)->end_keyword_loc, buffer);
             break;
@@ -1526,7 +1428,7 @@ void yp_serialize_comment(yp_parser_t *parser, yp_comment_t *comment, yp_buffer_
 }
 
 void yp_serialize_comment_list(yp_parser_t *parser, yp_list_t list, yp_buffer_t *buffer) {
-    yp_buffer_append_u32(buffer, yp_list_size(&list));
+    yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(&list)));
 
     yp_comment_t *comment;
     for (comment = (yp_comment_t *) list.head; comment != NULL; comment = (yp_comment_t *) comment->node.next) {
@@ -1546,7 +1448,7 @@ void yp_serialize_diagnostic(yp_parser_t *parser, yp_diagnostic_t *diagnostic, y
 }
 
 void yp_serialize_diagnostic_list(yp_parser_t *parser, yp_list_t list, yp_buffer_t *buffer) {
-    yp_buffer_append_u32(buffer, yp_list_size(&list));
+    yp_buffer_append_u32(buffer, yp_sizet_to_u32(yp_list_size(&list)));
 
     yp_diagnostic_t *diagnostic;
     for (diagnostic = (yp_diagnostic_t *) list.head; diagnostic != NULL; diagnostic = (yp_diagnostic_t *) diagnostic->node.next) {

data/src/unescape.c

@@ -180,22 +180,6 @@ unescape_char(const unsigned char value, const unsigned char flags) {
 static const char *
 unescape(char *dest, size_t *dest_length, const char *backslash, const char *end, yp_list_t *error_list, const unsigned char flags, bool write_to_str) {
     switch (backslash[1]) {
-        // \a \b \e \f \n \r \s \t \v
-        case '\r': {
-            // if this is an \r\n we need to escape both
-            if (write_to_str) {
-                dest[(*dest_length)++] = (char) unescape_char(unescape_chars[(unsigned char) backslash[1]], flags);
-            }
-
-            if (backslash + 2 < end && backslash[2] == '\n') {
-                if (write_to_str) {
-                    dest[(*dest_length)++] = (char) unescape_char(unescape_chars[(unsigned char) backslash[2]], flags);
-                }
-                return backslash + 3;
-            }
-
-            return backslash + 2;
-        }
         case 'a':
         case 'b':
         case 'e':
@@ -398,14 +382,23 @@ unescape(char *dest, size_t *dest_length, const char *backslash, const char *end
             yp_diagnostic_list_append(error_list, backslash, backslash + 2, "Invalid meta escape sequence");
             return backslash + 3;
         }
+        // \n
+        case '\n':
+            return backslash + 2;
+        // \r
+        case '\r':
+            if (backslash + 2 < end && backslash[2] == '\n') {
+                return backslash + 3;
+            }
+
+            /* fallthrough */
         // In this case we're escaping something that doesn't need escaping.
-        default:
-            {
-                if (write_to_str) {
-                    dest[(*dest_length)++] = backslash[1];
-                }
-                return backslash + 2;
+        default: {
+            if (write_to_str) {
+                dest[(*dest_length)++] = backslash[1];
             }
+            return backslash + 2;
+        }
     }
 }
 
@@ -438,26 +431,24 @@ unescape(char *dest, size_t *dest_length, const char *backslash, const char *end
 // \c? or \C-?    delete, ASCII 7Fh (DEL)
 //
 YP_EXPORTED_FUNCTION void
-yp_unescape_manipulate_string(yp_parser_t *parser, const char *value, size_t length, yp_string_t *string, yp_unescape_type_t unescape_type, yp_list_t *error_list) {
+yp_unescape_manipulate_string(yp_parser_t *parser, yp_string_t *string, yp_unescape_type_t unescape_type, yp_list_t *error_list) {
     if (unescape_type == YP_UNESCAPE_NONE) {
         // If we're not unescaping then we can reference the source directly.
-        yp_string_shared_init(string, value, value + length);
         return;
     }
 
-    const char *backslash = yp_memchr(value, '\\', length, parser->encoding_changed, &parser->encoding);
+    const char *backslash = yp_memchr(string->source, '\\', string->length, parser->encoding_changed, &parser->encoding);
 
     if (backslash == NULL) {
         // Here there are no escapes, so we can reference the source directly.
-        yp_string_shared_init(string, value, value + length);
         return;
     }
 
     // Here we have found an escape character, so we need to handle all escapes
     // within the string.
-    char *allocated = malloc(length);
+    char *allocated = malloc(string->length);
     if (allocated == NULL) {
-        yp_diagnostic_list_append(error_list, value, value + length, "Failed to allocate memory for unescaping.");
+        yp_diagnostic_list_append(error_list, string->source, string->source + string->length, "Failed to allocate memory for unescaping.");
         return;
     }
 
@@ -468,13 +459,13 @@ yp_unescape_manipulate_string(yp_parser_t *parser, const char *value, size_t len
     // This is the current position in the source string that we're looking at.
     // It's going to move along behind the backslash so that we can copy each
     // segment of the string that doesn't contain an escape.
-    const char *cursor = value;
-    const char *end = value + length;
+    const char *cursor = string->source;
+    const char *end = string->source + string->length;
 
     // For each escape found in the source string, we will handle it and update
     // the moving cursor->backslash window.
     while (backslash != NULL && backslash + 1 < end) {
-        assert(dest_length < length);
+        assert(dest_length < string->length);
 
         // This is the size of the segment of the string from the previous escape
         // or the start of the string to the current escape.
@@ -520,6 +511,10 @@ yp_unescape_manipulate_string(yp_parser_t *parser, const char *value, size_t len
         cursor = end;
     }
 
+    // If the string was already allocated, then we need to free that memory
+    // here. That's because we're about to override it with the escaped string.
+    yp_string_free(string);
+
     // We also need to update the length at the end. This is because every escape
     // reduces the length of the final string, and we don't want garbage at the
     // end.
@@ -530,13 +525,12 @@ YP_EXPORTED_FUNCTION bool
 yp_unescape_string(const char *start, size_t length, yp_unescape_type_t unescape_type, yp_string_t *result) {
     bool success;
 
-    yp_list_t error_list;
-    yp_list_init(&error_list);
-
     yp_parser_t parser;
     yp_parser_init(&parser, start, length, "");
 
-    yp_unescape_manipulate_string(&parser, start, length, result, unescape_type, &error_list);
+    yp_list_t error_list = YP_LIST_EMPTY;
+    yp_string_shared_init(result, start, start + length);
+    yp_unescape_manipulate_string(&parser, result, unescape_type, &error_list);
     success = yp_list_empty_p(&error_list);
 
     yp_list_free(&error_list);

data/src/util/yp_buffer.c

@@ -2,6 +2,12 @@
 
 #define YP_BUFFER_INITIAL_SIZE 1024
 
+// Return the size of the yp_buffer_t struct.
+size_t
+yp_buffer_sizeof(void) {
+    return sizeof(yp_buffer_t);
+}
+
 // Initialize a yp_buffer_t with its default values.
 bool
 yp_buffer_init(yp_buffer_t *buffer) {
@@ -12,6 +18,18 @@ yp_buffer_init(yp_buffer_t *buffer) {
     return buffer->value != NULL;
 }
 
+// Return the value of the buffer.
+char *
+yp_buffer_value(yp_buffer_t *buffer) {
+    return buffer->value;
+}
+
+// Return the length of the buffer.
+size_t
+yp_buffer_length(yp_buffer_t *buffer) {
+    return buffer->length;
+}
+
 // Append the given amount of space to the buffer.
 static inline void
 yp_buffer_append_length(yp_buffer_t *buffer, size_t length) {

data/src/util/yp_list.c

@@ -1,28 +1,15 @@
 #include "yarp/util/yp_list.h"
 
-// Initializes a new list.
-YP_EXPORTED_FUNCTION void
-yp_list_init(yp_list_t *list) {
-    *list = (yp_list_t) { .head = NULL, .tail = NULL };
-}
-
 // Returns true if the given list is empty.
 YP_EXPORTED_FUNCTION bool
 yp_list_empty_p(yp_list_t *list) {
     return list->head == NULL;
 }
 
-YP_EXPORTED_FUNCTION uint32_t
+// Returns the size of the list.
+YP_EXPORTED_FUNCTION size_t
 yp_list_size(yp_list_t *list) {
-    yp_list_node_t *node = list->head;
-    uint32_t length = 0;
-
-    while (node != NULL) {
-        length++;
-        node = node->next;
-    }
-
-    return length;
+    return list->size;
 }
 
 // Append a node to the given list.
@@ -33,7 +20,9 @@ yp_list_append(yp_list_t *list, yp_list_node_t *node) {
     } else {
         list->tail->next = node;
     }
+
     list->tail = node;
+    list->size++;
 }
 
 // Deallocate the internal state of the given list.
@@ -47,4 +36,6 @@ yp_list_free(yp_list_t *list) {
         free(node);
         node = next;
     }
+
+    list->size = 0;
 }

data/src/util/yp_state_stack.c

@@ -1,11 +1,5 @@
 #include "yarp/util/yp_state_stack.h"
 
-// Initializes the state stack to an empty stack.
-void
-yp_state_stack_init(yp_state_stack_t *stack) {
-    *stack = 0;
-}
-
 // Pushes a value onto the stack.
 void
 yp_state_stack_push(yp_state_stack_t *stack, bool value) {