yarp 0.12.0 → 0.13.0

data/include/yarp.h

@@ -1,82 +0,0 @@
-#ifndef YARP_H
-#define YARP_H
-
-#include "yarp/defines.h"
-#include "yarp/ast.h"
-#include "yarp/diagnostic.h"
-#include "yarp/node.h"
-#include "yarp/pack.h"
-#include "yarp/parser.h"
-#include "yarp/regexp.h"
-#include "yarp/unescape.h"
-#include "yarp/util/yp_buffer.h"
-#include "yarp/util/yp_char.h"
-#include "yarp/util/yp_memchr.h"
-#include "yarp/util/yp_strpbrk.h"
-#include "yarp/version.h"
-
-#include <assert.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef _WIN32
-#include <strings.h>
-#endif
-
-void yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer);
-
-void yp_print_node(yp_parser_t *parser, yp_node_t *node);
-
-void yp_parser_metadata(yp_parser_t *parser, const char *metadata);
-
-// Generate a scope node from the given node.
-void yp_scope_node_init(yp_node_t *node, yp_scope_node_t *dest);
-
-// The YARP version and the serialization format.
-YP_EXPORTED_FUNCTION const char * yp_version(void);
-
-// Initialize a parser with the given start and end pointers.
-YP_EXPORTED_FUNCTION void yp_parser_init(yp_parser_t *parser, const uint8_t *source, size_t size, const char *filepath);
-
-// Register a callback that will be called whenever YARP changes the encoding it
-// is using to parse based on the magic comment.
-YP_EXPORTED_FUNCTION void yp_parser_register_encoding_changed_callback(yp_parser_t *parser, yp_encoding_changed_callback_t callback);
-
-// Register a callback that will be called when YARP encounters a magic comment
-// with an encoding referenced that it doesn't understand. The callback should
-// return NULL if it also doesn't understand the encoding or it should return a
-// pointer to a yp_encoding_t struct that contains the functions necessary to
-// parse identifiers.
-YP_EXPORTED_FUNCTION void yp_parser_register_encoding_decode_callback(yp_parser_t *parser, yp_encoding_decode_callback_t callback);
-
-// Free any memory associated with the given parser.
-YP_EXPORTED_FUNCTION void yp_parser_free(yp_parser_t *parser);
-
-// Parse the Ruby source associated with the given parser and return the tree.
-YP_EXPORTED_FUNCTION yp_node_t * yp_parse(yp_parser_t *parser);
-
-// Pretty-prints the AST represented by the given node to the given buffer.
-YP_EXPORTED_FUNCTION void yp_prettyprint(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer);
-
-// Serialize the AST represented by the given node to the given buffer.
-YP_EXPORTED_FUNCTION void yp_serialize(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer);
-
-// Parse the given source to the AST and serialize the AST to the given buffer.
-YP_EXPORTED_FUNCTION void yp_parse_serialize(const uint8_t *source, size_t size, yp_buffer_t *buffer, const char *metadata);
-
-// Lex the given source and serialize to the given buffer.
-YP_EXPORTED_FUNCTION void yp_lex_serialize(const uint8_t *source, size_t size, const char *filepath, yp_buffer_t *buffer);
-
-// Parse and serialize both the AST and the tokens represented by the given
-// source to the given buffer.
-YP_EXPORTED_FUNCTION void yp_parse_lex_serialize(const uint8_t *source, size_t size, yp_buffer_t *buffer, const char *metadata);
-
-// Returns a string representation of the given token type.
-YP_EXPORTED_FUNCTION const char * yp_token_type_to_str(yp_token_type_t token_type);
-
-#endif

data/src/enc/yp_big5.c

@@ -1,52 +0,0 @@
-#include "yarp/enc/yp_encoding.h"
-
-static size_t
-yp_encoding_big5_char_width(const uint8_t *b, ptrdiff_t n) {
-    // These are the single byte characters.
-    if (*b < 0x80) {
-        return 1;
-    }
-
-    // These are the double byte characters.
-    if ((n > 1) && (b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0x40 && b[1] <= 0xFE)) {
-        return 2;
-    }
-
-    return 0;
-}
-
-static size_t
-yp_encoding_big5_alpha_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_big5_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alpha_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static size_t
-yp_encoding_big5_alnum_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_big5_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alnum_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static bool
-yp_encoding_big5_isupper_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_big5_char_width(b, n) == 1) {
-        return yp_encoding_ascii_isupper_char(b, n);
-    } else {
-        return false;
-    }
-}
-
-yp_encoding_t yp_encoding_big5 = {
-    .name = "big5",
-    .char_width = yp_encoding_big5_char_width,
-    .alnum_char = yp_encoding_big5_alnum_char,
-    .alpha_char = yp_encoding_big5_alpha_char,
-    .isupper_char = yp_encoding_big5_isupper_char,
-    .multibyte = true
-};

data/src/enc/yp_euc_jp.c

@@ -1,58 +0,0 @@
-#include "yarp/enc/yp_encoding.h"
-
-static size_t
-yp_encoding_euc_jp_char_width(const uint8_t *b, ptrdiff_t n) {
-    // These are the single byte characters.
-    if (*b < 0x80) {
-        return 1;
-    }
-
-    // These are the double byte characters.
-    if (
-        (n > 1) &&
-        (
-            ((b[0] == 0x8E) && (b[1] >= 0xA1 && b[1] <= 0xFE)) ||
-            ((b[0] >= 0xA1 && b[0] <= 0xFE) && (b[1] >= 0xA1 && b[1] <= 0xFE))
-        )
-    ) {
-        return 2;
-    }
-
-    return 0;
-}
-
-static size_t
-yp_encoding_euc_jp_alpha_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alpha_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static size_t
-yp_encoding_euc_jp_alnum_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alnum_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static bool
-yp_encoding_euc_jp_isupper_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_euc_jp_char_width(b, n) == 1) {
-        return yp_encoding_ascii_isupper_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-yp_encoding_t yp_encoding_euc_jp = {
-    .name = "euc-jp",
-    .char_width = yp_encoding_euc_jp_char_width,
-    .alnum_char = yp_encoding_euc_jp_alnum_char,
-    .alpha_char = yp_encoding_euc_jp_alpha_char,
-    .isupper_char = yp_encoding_euc_jp_isupper_char,
-    .multibyte = true
-};

data/src/enc/yp_shift_jis.c

@@ -1,56 +0,0 @@
-#include "yarp/enc/yp_encoding.h"
-
-static size_t
-yp_encoding_shift_jis_char_width(const uint8_t *b, ptrdiff_t n) {
-    // These are the single byte characters.
-    if (*b < 0x80 || (*b >= 0xA1 && *b <= 0xDF)) {
-        return 1;
-    }
-
-    // These are the double byte characters.
-    if (
-        (n > 1) &&
-        ((b[0] >= 0x81 && b[0] <= 0x9F) || (b[0] >= 0xE0 && b[0] <= 0xFC)) &&
-        (b[1] >= 0x40 && b[1] <= 0xFC)
-    ) {
-        return 2;
-    }
-
-    return 0;
-}
-
-static size_t
-yp_encoding_shift_jis_alpha_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alpha_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static size_t
-yp_encoding_shift_jis_alnum_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alnum_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static bool
-yp_encoding_shift_jis_isupper_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_shift_jis_char_width(b, n) == 1) {
-        return yp_encoding_ascii_isupper_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-yp_encoding_t yp_encoding_shift_jis = {
-    .name = "shift_jis",
-    .char_width = yp_encoding_shift_jis_char_width,
-    .alnum_char = yp_encoding_shift_jis_alnum_char,
-    .alpha_char = yp_encoding_shift_jis_alpha_char,
-    .isupper_char = yp_encoding_shift_jis_isupper_char,
-    .multibyte = true
-};

data/src/enc/yp_windows_31j.c

@@ -1,56 +0,0 @@
-#include "yarp/enc/yp_encoding.h"
-
-static size_t
-yp_encoding_windows_31j_char_width(const uint8_t *b, ptrdiff_t n) {
-    // These are the single byte characters.
-    if (*b < 0x80 || (*b >= 0xA1 && *b <= 0xDF)) {
-        return 1;
-    }
-
-    // These are the double byte characters.
-    if (
-        (n > 1) &&
-        ((b[0] >= 0x81 && b[0] <= 0x9F) || (b[0] >= 0xE0 && b[0] <= 0xFC)) &&
-        (b[1] >= 0x40 && b[1] <= 0xFC)
-    ) {
-        return 2;
-    }
-
-    return 0;
-}
-
-static size_t
-yp_encoding_windows_31j_alpha_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_windows_31j_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alpha_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static size_t
-yp_encoding_windows_31j_alnum_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_windows_31j_char_width(b, n) == 1) {
-        return yp_encoding_ascii_alnum_char(b, n);
-    } else {
-        return 0;
-    }
-}
-
-static bool
-yp_encoding_windows_31j_isupper_char(const uint8_t *b, ptrdiff_t n) {
-    if (yp_encoding_windows_31j_char_width(b, n) == 1) {
-        return yp_encoding_ascii_isupper_char(b, n);
-    } else {
-        return false;
-    }
-}
-
-yp_encoding_t yp_encoding_windows_31j = {
-    .name = "windows-31j",
-    .char_width = yp_encoding_windows_31j_char_width,
-    .alnum_char = yp_encoding_windows_31j_alnum_char,
-    .alpha_char = yp_encoding_windows_31j_alpha_char,
-    .isupper_char = yp_encoding_windows_31j_isupper_char,
-    .multibyte = true
-};

data/src/util/yp_buffer.c

@@ -1,101 +0,0 @@
-#include "yarp/util/yp_buffer.h"
-
-#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) {
-    buffer->length = 0;
-    buffer->capacity = YP_BUFFER_INITIAL_SIZE;
-
-    buffer->value = (char *) malloc(YP_BUFFER_INITIAL_SIZE);
-    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) {
-    size_t next_length = buffer->length + length;
-
-    if (next_length > buffer->capacity) {
-        do {
-            buffer->capacity *= 2;
-        } while (next_length > buffer->capacity);
-
-        buffer->value = realloc(buffer->value, buffer->capacity);
-    }
-
-    buffer->length = next_length;
-}
-
-// Append a generic pointer to memory to the buffer.
-static inline void
-yp_buffer_append(yp_buffer_t *buffer, const void *source, size_t length) {
-    yp_buffer_append_length(buffer, length);
-    memcpy(buffer->value + (buffer->length - length), source, length);
-}
-
-// Append the given amount of space as zeroes to the buffer.
-void
-yp_buffer_append_zeroes(yp_buffer_t *buffer, size_t length) {
-    yp_buffer_append_length(buffer, length);
-    memset(buffer->value + (buffer->length - length), 0, length);
-}
-
-// Append a string to the buffer.
-void
-yp_buffer_append_str(yp_buffer_t *buffer, const char *value, size_t length) {
-    yp_buffer_append(buffer, value, length);
-}
-
-// Append a list of bytes to the buffer.
-void
-yp_buffer_append_bytes(yp_buffer_t *buffer, const uint8_t *value, size_t length) {
-    yp_buffer_append(buffer, (const char *) value, length);
-}
-
-// Append a single byte to the buffer.
-void
-yp_buffer_append_u8(yp_buffer_t *buffer, uint8_t value) {
-    const void *source = &value;
-    yp_buffer_append(buffer, source, sizeof(uint8_t));
-}
-
-// Append a 32-bit unsigned integer to the buffer.
-void
-yp_buffer_append_u32(yp_buffer_t *buffer, uint32_t value) {
-    if (value < 128) {
-        yp_buffer_append_u8(buffer, (uint8_t) value);
-    } else {
-        uint32_t n = value;
-        while (n >= 128) {
-            yp_buffer_append_u8(buffer, (uint8_t) (n | 128));
-            n >>= 7;
-        }
-        yp_buffer_append_u8(buffer, (uint8_t) n);
-    }
-}
-
-// Free the memory associated with the buffer.
-void
-yp_buffer_free(yp_buffer_t *buffer) {
-    free(buffer->value);
-}

data/src/util/yp_string_list.c

@@ -1,29 +0,0 @@
-#include "yarp/util/yp_string_list.h"
-
-// Initialize a yp_string_list_t with its default values.
-void
-yp_string_list_init(yp_string_list_t *string_list) {
-    string_list->strings = (yp_string_t *) malloc(sizeof(yp_string_t));
-    string_list->length = 0;
-    string_list->capacity = 1;
-}
-
-// Append a yp_string_t to the given string list.
-void
-yp_string_list_append(yp_string_list_t *string_list, yp_string_t *string) {
-    if (string_list->length + 1 > string_list->capacity) {
-        yp_string_t *original_string = string_list->strings;
-        string_list->capacity *= 2;
-        string_list->strings = (yp_string_t *) malloc(string_list->capacity * sizeof(yp_string_t));
-        memcpy(string_list->strings, original_string, (string_list->length) * sizeof(yp_string_t));
-        free(original_string);
-    }
-
-    string_list->strings[string_list->length++] = *string;
-}
-
-// Free the memory associated with the string list.
-void
-yp_string_list_free(yp_string_list_t *string_list) {
-    free(string_list->strings);
-}