yarp 0.6.0

data/src/util/yp_string.c

@@ -0,0 +1,207 @@
+#include "yarp/util/yp_string.h"
+
+// The following headers are necessary to read files using demand paging.
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+// Initialize a shared string that is based on initial input.
+void
+yp_string_shared_init(yp_string_t *string, const char *start, const char *end) {
+    assert(start <= end);
+    *string = (yp_string_t) {
+        .type = YP_STRING_SHARED,
+        .source = (char*) start,
+        .length = (size_t) (end - start)
+    };
+}
+
+// Initialize an owned string that is responsible for freeing allocated memory.
+void
+yp_string_owned_init(yp_string_t *string, char *source, size_t length) {
+    *string = (yp_string_t) {
+        .type = YP_STRING_OWNED,
+        .source = source,
+        .length = length
+    };
+}
+
+// Initialize a constant string that doesn't own its memory source.
+void
+yp_string_constant_init(yp_string_t *string, const char *source, size_t length) {
+    *string = (yp_string_t) {
+        .type = YP_STRING_CONSTANT,
+        .source = (char*) source,
+        .length = length
+    };
+}
+
+static void
+yp_string_mapped_init_internal(yp_string_t *string, char *source, size_t length) {
+    *string = (yp_string_t) {
+        .type = YP_STRING_MAPPED,
+        .source = source,
+        .length = length
+    };
+}
+
+// Returns the memory size associated with the string.
+size_t
+yp_string_memsize(const yp_string_t *string) {
+    size_t size = sizeof(yp_string_t);
+    if (string->type == YP_STRING_OWNED) {
+        size += string->length;
+    }
+    return size;
+}
+
+// Ensure the string is owned. If it is not, then reinitialize it as owned and
+// copy over the previous source.
+void
+yp_string_ensure_owned(yp_string_t *string) {
+    if (string->type == YP_STRING_OWNED) return;
+
+    size_t length = yp_string_length(string);
+    const char *source = yp_string_source(string);
+
+    char *memory = malloc(length);
+    if (!memory) return;
+
+    yp_string_owned_init(string, memory, length);
+    memcpy(string->source, source, length);
+}
+
+// Returns the length associated with the string.
+YP_EXPORTED_FUNCTION size_t
+yp_string_length(const yp_string_t *string) {
+    return string->length;
+}
+
+// Returns the start pointer associated with the string.
+YP_EXPORTED_FUNCTION const char *
+yp_string_source(const yp_string_t *string) {
+    return string->source;
+}
+
+// Free the associated memory of the given string.
+YP_EXPORTED_FUNCTION void
+yp_string_free(yp_string_t *string) {
+    if (string->type == YP_STRING_OWNED) {
+        free(string->source);
+    } else if (string->type == YP_STRING_MAPPED && string->length) {
+        void *memory = (void *) string->source;
+        #if defined(_WIN32)
+        UnmapViewOfFile(memory);
+        #elif defined(HAVE_MMAP)
+        munmap(memory, string->length);
+        #else
+        free(memory);
+        #endif
+    }
+}
+
+bool
+yp_string_mapped_init(yp_string_t *string, const char *filepath) {
+#ifdef _WIN32
+    // Open the file for reading.
+    HANDLE file = CreateFile(filepath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+    if (file == INVALID_HANDLE_VALUE) {
+        perror("CreateFile failed");
+        return false;
+    }
+
+    // Get the file size.
+    DWORD file_size = GetFileSize(file, NULL);
+    if (file_size == INVALID_FILE_SIZE) {
+        CloseHandle(file);
+        perror("GetFileSize failed");
+        return false;
+    }
+
+    // If the file is empty, then we don't need to do anything else, we'll set
+    // the source to a constant empty string and return.
+    if (file_size == 0) {
+        CloseHandle(file);
+        char empty_string[] = "";
+        yp_string_mapped_init_internal(string, empty_string, 0);
+        return true;
+    }
+
+    // Create a mapping of the file.
+    HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
+    if (mapping == NULL) {
+        CloseHandle(file);
+        perror("CreateFileMapping failed");
+        return false;
+    }
+
+    // Map the file into memory.
+    char *source = (char *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
+    CloseHandle(mapping);
+    CloseHandle(file);
+
+    if (source == NULL) {
+        perror("MapViewOfFile failed");
+        return false;
+    }
+
+    yp_string_mapped_init_internal(string, source, (size_t) file_size);
+    return true;
+#else
+    // Open the file for reading
+    int fd = open(filepath, O_RDONLY);
+    if (fd == -1) {
+        perror("open");
+        return false;
+    }
+
+    // Stat the file to get the file size
+    struct stat sb;
+    if (fstat(fd, &sb) == -1) {
+        close(fd);
+        perror("fstat");
+        return false;
+    }
+
+    // mmap the file descriptor to virtually get the contents
+    size_t size = (size_t) sb.st_size;
+    char *source = NULL;
+
+    if (size == 0) {
+        close(fd);
+        char empty_string[] = "";
+        yp_string_mapped_init_internal(string, empty_string, 0);
+        return true;
+    }
+
+#ifdef HAVE_MMAP
+    source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (source == MAP_FAILED) {
+        perror("Map failed");
+        return false;
+    }
+#else
+    source = malloc(size);
+    if (source == NULL) {
+        return false;
+    }
+
+    ssize_t read_size = read(fd, (void *) source, size);
+    if (read_size < 0 || (size_t)read_size != size) {
+        perror("Read size is incorrect");
+        free((void *) source);
+        return false;
+    }
+#endif
+
+    close(fd);
+    yp_string_mapped_init_internal(string, source, size);
+    return true;
+#endif
+}

data/src/util/yp_string_list.c

@@ -0,0 +1,32 @@
+#include "yarp/util/yp_string_list.h"
+
+// Allocate a new yp_string_list_t.
+yp_string_list_t *
+yp_string_list_alloc(void) {
+    return (yp_string_list_t *) malloc(sizeof(yp_string_list_t));
+}
+
+// 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) {
+        string_list->capacity *= 2;
+        string_list->strings = (yp_string_t *) realloc(string_list->strings, string_list->capacity * sizeof(yp_string_t));
+    }
+
+    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);
+}

data/src/util/yp_strncasecmp.c

@@ -0,0 +1,20 @@
+#include <ctype.h>
+#include <stddef.h>
+
+int
+yp_strncasecmp(const char *string1, const char *string2, size_t length) {
+    size_t offset = 0;
+    int difference = 0;
+
+    while (offset < length && string1[offset] != '\0') {
+        if (string2[offset] == '\0') return string1[offset];
+
+        unsigned char left = (unsigned char) string1[offset];
+        unsigned char right = (unsigned char) string2[offset];
+
+        if ((difference = tolower(left) - tolower(right)) != 0) return difference;
+        offset++;
+    }
+
+    return difference;
+}

data/src/util/yp_strpbrk.c

@@ -0,0 +1,66 @@
+#include "yarp/util/yp_strpbrk.h"
+
+// This is the slow path that does care about the encoding.
+static inline const char *
+yp_strpbrk_multi_byte(yp_parser_t *parser, const char *source, const char *charset, size_t maximum) {
+    size_t index = 0;
+
+    while (index < maximum) {
+        if (strchr(charset, source[index]) != NULL) {
+            return source + index;
+        }
+
+        size_t width = parser->encoding.char_width(source + index, (ptrdiff_t) (maximum - index));
+        if (width == 0) {
+            return NULL;
+        }
+
+        index += width;
+    }
+
+    return NULL;
+}
+
+// This is the fast path that does not care about the encoding.
+static inline const char *
+yp_strpbrk_single_byte(const char *source, const char *charset, size_t maximum) {
+    size_t index = 0;
+
+    while (index < maximum) {
+        if (strchr(charset, source[index]) != NULL) {
+            return source + index;
+        }
+
+        index++;
+    }
+
+    return NULL;
+}
+
+// Here we have rolled our own version of strpbrk. The standard library strpbrk
+// has undefined behavior when the source string is not null-terminated. We want
+// to support strings that are not null-terminated because yp_parse does not
+// have the contract that the string is null-terminated. (This is desirable
+// because it means the extension can call yp_parse with the result of a call to
+// mmap).
+//
+// The standard library strpbrk also does not support passing a maximum length
+// to search. We want to support this for the reason mentioned above, but we
+// also don't want it to stop on null bytes. Ruby actually allows null bytes
+// within strings, comments, regular expressions, etc. So we need to be able to
+// skip past them.
+//
+// Finally, we want to support encodings wherein the charset could contain
+// characters that are trailing bytes of multi-byte characters. For example, in
+// Shift-JIS, the backslash character can be a trailing byte. In that case we
+// need to take a slower path and iterate one multi-byte character at a time.
+const char *
+yp_strpbrk(yp_parser_t *parser, const char *source, const char *charset, ptrdiff_t length) {
+    if (length <= 0) {
+        return NULL;
+    } else if (parser->encoding_changed && parser->encoding.multibyte) {
+        return yp_strpbrk_multi_byte(parser, source, charset, (size_t) length);
+    } else {
+        return yp_strpbrk_single_byte(source, charset, (size_t) length);
+    }
+}