yarp 0.6.0

data/include/yarp/defines.h

@@ -0,0 +1,54 @@
+#ifndef YARP_DEFINES_H
+#define YARP_DEFINES_H
+
+// This file should be included first by any *.h or *.c in YARP
+
+#include "yarp/config.h"
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+// YP_EXPORTED_FUNCTION
+#ifndef YP_EXPORTED_FUNCTION
+#   ifdef YP_EXPORT_SYMBOLS
+#       ifdef _WIN32
+#          define YP_EXPORTED_FUNCTION __declspec(dllexport) extern
+#       else
+#          define YP_EXPORTED_FUNCTION __attribute__((__visibility__("default"))) extern
+#       endif
+#   else
+#       define YP_EXPORTED_FUNCTION
+#   endif
+#endif
+
+// YP_ATTRIBUTE_UNUSED
+#if defined(__GNUC__)
+#   define YP_ATTRIBUTE_UNUSED __attribute__((unused))
+#else
+#   define YP_ATTRIBUTE_UNUSED
+#endif
+
+// inline
+#if defined(_MSC_VER) && !defined(inline)
+#   define inline __inline
+#endif
+
+int yp_strncasecmp(const char *string1, const char *string2, size_t length);
+
+int yp_snprintf(char *dest, YP_ATTRIBUTE_UNUSED size_t size, const char *format, ...);
+
+#if defined(HAVE_SNPRINTF)
+    // We use snprintf if it's available
+#   define yp_snprintf snprintf
+
+#else
+    // In case snprintf isn't present on the system, we provide our own that simply
+    // forwards to the less-safe sprintf.
+#   define yp_snprintf(dest, size, ...) sprintf((dest), __VA_ARGS__)
+
+#endif
+
+#endif

data/include/yarp/diagnostic.h

@@ -0,0 +1,24 @@
+#ifndef YARP_DIAGNOSTIC_H
+#define YARP_DIAGNOSTIC_H
+
+#include "yarp/defines.h"
+#include "yarp/util/yp_list.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+// This struct represents a diagnostic found during parsing.
+typedef struct {
+    yp_list_node_t node;
+    const char *start;
+    const char *end;
+    const char *message;
+} yp_diagnostic_t;
+
+// Append a diagnostic to the given list of diagnostics.
+bool yp_diagnostic_list_append(yp_list_t *list, const char *start, const char *end, const char *message);
+
+// Deallocate the internal state of the given diagnostic list.
+void yp_diagnostic_list_free(yp_list_t *list);
+
+#endif

data/include/yarp/enc/yp_encoding.h

@@ -0,0 +1,94 @@
+#ifndef YARP_ENCODING_H
+#define YARP_ENCODING_H
+
+#include "yarp/defines.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+// This struct defines the functions necessary to implement the encoding
+// interface so we can determine how many bytes the subsequent character takes.
+// Each callback should return the number of bytes, or 0 if the next bytes are
+// invalid for the encoding and type.
+typedef struct {
+    // Return the number of bytes that the next character takes if it is valid
+    // in the encoding. Does not read more than n bytes. It is assumed that n is
+    // at least 1.
+    size_t (*char_width)(const char *c, ptrdiff_t n);
+
+    // Return the number of bytes that the next character takes if it is valid
+    // in the encoding and is alphabetical. Does not read more than n bytes. It
+    // is assumed that n is at least 1.
+    size_t (*alpha_char)(const char *c, ptrdiff_t n);
+
+    // Return the number of bytes that the next character takes if it is valid
+    // in the encoding and is alphanumeric. Does not read more than n bytes. It
+    // is assumed that n is at least 1.
+    size_t (*alnum_char)(const char *c, ptrdiff_t n);
+
+    // Return true if the next character is valid in the encoding and is an
+    // uppercase character. Does not read more than n bytes. It is assumed that
+    // n is at least 1.
+    bool (*isupper_char)(const char *c, ptrdiff_t n);
+
+    // The name of the encoding. This should correspond to a value that can be
+    // passed to Encoding.find in Ruby.
+    const char *name;
+
+    // Return true if the encoding is a multibyte encoding.
+    bool multibyte;
+} yp_encoding_t;
+
+// These bits define the location of each bit of metadata within the various
+// lookup tables that are used to determine the properties of a character.
+#define YP_ENCODING_ALPHABETIC_BIT 1 << 0
+#define YP_ENCODING_ALPHANUMERIC_BIT 1 << 1
+#define YP_ENCODING_UPPERCASE_BIT 1 << 2
+
+// These functions are reused by some other encodings, so they are defined here
+// so they can be shared.
+size_t yp_encoding_ascii_alpha_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n);
+size_t yp_encoding_ascii_alnum_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n);
+bool yp_encoding_ascii_isupper_char(const char *c, YP_ATTRIBUTE_UNUSED ptrdiff_t n);
+
+// These functions are shared between the actual encoding and the fast path in
+// the parser so they need to be internally visible.
+size_t yp_encoding_utf_8_alpha_char(const char *c, ptrdiff_t n);
+size_t yp_encoding_utf_8_alnum_char(const char *c, ptrdiff_t n);
+
+// This lookup table is referenced in both the UTF-8 encoding file and the
+// parser directly in order to speed up the default encoding processing.
+extern unsigned char yp_encoding_unicode_table[256];
+
+// These are the encodings that are supported by the parser. They are defined in
+// their own files in the src/enc directory.
+extern yp_encoding_t yp_encoding_ascii;
+extern yp_encoding_t yp_encoding_ascii_8bit;
+extern yp_encoding_t yp_encoding_big5;
+extern yp_encoding_t yp_encoding_euc_jp;
+extern yp_encoding_t yp_encoding_gbk;
+extern yp_encoding_t yp_encoding_iso_8859_1;
+extern yp_encoding_t yp_encoding_iso_8859_2;
+extern yp_encoding_t yp_encoding_iso_8859_3;
+extern yp_encoding_t yp_encoding_iso_8859_4;
+extern yp_encoding_t yp_encoding_iso_8859_5;
+extern yp_encoding_t yp_encoding_iso_8859_6;
+extern yp_encoding_t yp_encoding_iso_8859_7;
+extern yp_encoding_t yp_encoding_iso_8859_8;
+extern yp_encoding_t yp_encoding_iso_8859_9;
+extern yp_encoding_t yp_encoding_iso_8859_10;
+extern yp_encoding_t yp_encoding_iso_8859_11;
+extern yp_encoding_t yp_encoding_iso_8859_13;
+extern yp_encoding_t yp_encoding_iso_8859_14;
+extern yp_encoding_t yp_encoding_iso_8859_15;
+extern yp_encoding_t yp_encoding_iso_8859_16;
+extern yp_encoding_t yp_encoding_koi8_r;
+extern yp_encoding_t yp_encoding_shift_jis;
+extern yp_encoding_t yp_encoding_utf_8;
+extern yp_encoding_t yp_encoding_windows_31j;
+extern yp_encoding_t yp_encoding_windows_1251;
+extern yp_encoding_t yp_encoding_windows_1252;
+
+#endif

data/include/yarp/node.h

@@ -0,0 +1,36 @@
+#ifndef YARP_NODE_H
+#define YARP_NODE_H
+
+#include "yarp/defines.h"
+#include "yarp/parser.h"
+
+// Append a token to the given list.
+void yp_location_list_append(yp_location_list_t *list, const yp_token_t *token);
+
+// Append a new node onto the end of the node list.
+void yp_node_list_append(yp_node_list_t *list, yp_node_t *node);
+
+// Clear the node but preserves the location.
+void yp_node_clear(yp_node_t *node);
+
+// Deallocate a node and all of its children.
+YP_EXPORTED_FUNCTION void yp_node_destroy(yp_parser_t *parser, struct yp_node *node);
+
+// This struct stores the information gathered by the yp_node_memsize function.
+// It contains both the memory footprint and additionally metadata about the
+// shape of the tree.
+typedef struct {
+    size_t memsize;
+    size_t node_count;
+} yp_memsize_t;
+
+// Calculates the memory footprint of a given node.
+YP_EXPORTED_FUNCTION void yp_node_memsize(yp_node_t *node, yp_memsize_t *memsize);
+
+// Returns a string representation of the given node type.
+YP_EXPORTED_FUNCTION const char * yp_node_type_to_str(yp_node_type_t node_type);
+
+#define YP_EMPTY_NODE_LIST ((yp_node_list_t) { .nodes = NULL, .size = 0, .capacity = 0 })
+#define YP_EMPTY_LOCATION_LIST ((yp_location_list_t) { .locations = NULL, .size = 0, .capacity = 0 })
+
+#endif // YARP_NODE_H

data/include/yarp/pack.h

@@ -0,0 +1,141 @@
+#ifndef YARP_PACK_H
+#define YARP_PACK_H
+
+#include "yarp/defines.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum yp_pack_version {
+    YP_PACK_VERSION_3_2_0
+} yp_pack_version;
+
+typedef enum yp_pack_variant {
+    YP_PACK_VARIANT_PACK,
+    YP_PACK_VARIANT_UNPACK
+} yp_pack_variant;
+
+typedef enum yp_pack_type {
+    YP_PACK_SPACE,
+    YP_PACK_COMMENT,
+    YP_PACK_INTEGER,
+    YP_PACK_UTF8,
+    YP_PACK_BER,
+    YP_PACK_FLOAT,
+    YP_PACK_STRING_SPACE_PADDED,
+    YP_PACK_STRING_NULL_PADDED,
+    YP_PACK_STRING_NULL_TERMINATED,
+    YP_PACK_STRING_MSB,
+    YP_PACK_STRING_LSB,
+    YP_PACK_STRING_HEX_HIGH,
+    YP_PACK_STRING_HEX_LOW,
+    YP_PACK_STRING_UU,
+    YP_PACK_STRING_MIME,
+    YP_PACK_STRING_BASE64,
+    YP_PACK_STRING_FIXED,
+    YP_PACK_STRING_POINTER,
+    YP_PACK_MOVE,
+    YP_PACK_BACK,
+    YP_PACK_NULL,
+    YP_PACK_END
+} yp_pack_type;
+
+typedef enum yp_pack_signed {
+    YP_PACK_UNSIGNED,
+    YP_PACK_SIGNED,
+    YP_PACK_SIGNED_NA
+} yp_pack_signed;
+
+typedef enum yp_pack_endian {
+    YP_PACK_AGNOSTIC_ENDIAN,
+    YP_PACK_LITTLE_ENDIAN,      // aka 'VAX', or 'V'
+    YP_PACK_BIG_ENDIAN,         // aka 'network', or 'N'
+    YP_PACK_NATIVE_ENDIAN,
+    YP_PACK_ENDIAN_NA
+} yp_pack_endian;
+
+typedef enum yp_pack_size {
+    YP_PACK_SIZE_SHORT,
+    YP_PACK_SIZE_INT,
+    YP_PACK_SIZE_LONG,
+    YP_PACK_SIZE_LONG_LONG,
+    YP_PACK_SIZE_8,
+    YP_PACK_SIZE_16,
+    YP_PACK_SIZE_32,
+    YP_PACK_SIZE_64,
+    YP_PACK_SIZE_P,
+    YP_PACK_SIZE_NA
+} yp_pack_size;
+
+typedef enum yp_pack_length_type {
+    YP_PACK_LENGTH_FIXED,
+    YP_PACK_LENGTH_MAX,
+    YP_PACK_LENGTH_RELATIVE,  // special case for unpack @*
+    YP_PACK_LENGTH_NA
+} yp_pack_length_type;
+
+typedef enum yp_pack_encoding {
+    YP_PACK_ENCODING_START,
+    YP_PACK_ENCODING_ASCII_8BIT,
+    YP_PACK_ENCODING_US_ASCII,
+    YP_PACK_ENCODING_UTF_8
+} yp_pack_encoding;
+
+typedef enum yp_pack_result {
+    YP_PACK_OK,
+    YP_PACK_ERROR_UNSUPPORTED_DIRECTIVE,
+    YP_PACK_ERROR_UNKNOWN_DIRECTIVE,
+    YP_PACK_ERROR_LENGTH_TOO_BIG,
+    YP_PACK_ERROR_BANG_NOT_ALLOWED,
+    YP_PACK_ERROR_DOUBLE_ENDIAN
+} yp_pack_result;
+
+// Parse a single directive from a pack or unpack format string.
+//
+// Parameters:
+//  - [in] yp_pack_version version    the version of Ruby
+//  - [in] yp_pack_variant variant    pack or unpack
+//  - [in out] const char **format    the start of the next directive to parse
+//      on calling, and advanced beyond the parsed directive on return, or as
+//      much of it as was consumed until an error was encountered
+//  - [in] const char *format_end     the end of the format string
+//  - [out] yp_pack_type *type        the type of the directive
+//  - [out] yp_pack_signed *signed_type
+//                                    whether the value is signed
+//  - [out] yp_pack_endian *endian    the endianness of the value
+//  - [out] yp_pack_size *size        the size of the value
+//  - [out] yp_pack_length_type *length_type
+//                                    what kind of length is specified
+//  - [out] size_t *length            the length of the directive
+//  - [in out] yp_pack_encoding *encoding
+//                                    takes the current encoding of the string
+//      which would result from parsing the whole format string, and returns a
+//      possibly changed directive - the encoding should be
+//      YP_PACK_ENCODING_START when yp_pack_parse is called for the first
+//      directive in a format string
+//
+// Return:
+//  - YP_PACK_OK on success
+//  - YP_PACK_ERROR_* on error
+//
+// Notes:
+//   Consult Ruby documentation for the meaning of directives.
+YP_EXPORTED_FUNCTION yp_pack_result
+yp_pack_parse(
+    yp_pack_variant variant_arg,
+    const char **format,
+    const char *format_end,
+    yp_pack_type *type,
+    yp_pack_signed *signed_type,
+    yp_pack_endian *endian,
+    yp_pack_size *size,
+    yp_pack_length_type *length_type,
+    uint64_t *length,
+    yp_pack_encoding *encoding
+);
+
+// YARP abstracts sizes away from the native system - this converts an abstract
+// size to a native size.
+YP_EXPORTED_FUNCTION size_t yp_size_to_native(yp_pack_size size);
+
+#endif