habaki 0.5.0

data/ext/katana/src/foundation.c

@@ -0,0 +1,237 @@
+//
+//  foundation.c
+//  Katana
+//
+//  Created by QFish on 3/19/15.
+//  Copyright (c) 2015 QFish. All rights reserved.
+//
+
+#include "foundation.h"
+#include "parser.h"
+
+#include <string.h>
+#include <strings.h>
+#include <stdbool.h>
+#include <assert.h>
+
+//#undef	assert
+//#define assert(x)
+
+struct KatanaInternalParser;
+
+const KatanaParserString kKatanaAsteriskString = {"*", 1};
+
+static const size_t kDefaultStringBufferSize = 12;
+
+static void maybe_resize_string(struct KatanaInternalParser* parser,
+                                size_t additional_chars,
+                                KatanaParserString* str) {
+    size_t new_length = str->length + additional_chars;
+    size_t new_capacity = str->capacity;
+    while (new_capacity < new_length) {
+        new_capacity *= 2;
+    }
+    if (new_capacity != str->capacity) {
+        char* new_data = katana_parser_allocate(parser, new_capacity);
+        memset(new_data, 0, str->length);
+        memcpy(new_data, str->data, str->length);
+        katana_parser_deallocate(parser, str->data);
+        str->data = new_data;
+        str->capacity = new_capacity;
+    }
+}
+
+void katana_string_init(struct KatanaInternalParser* parser,
+                        KatanaParserString* output) {
+    output->data = katana_parser_allocate(parser, kDefaultStringBufferSize);
+    memset( output->data, 0, sizeof(kDefaultStringBufferSize) );
+    output->length = 0;
+    output->capacity = kDefaultStringBufferSize;
+}
+
+void katana_string_append_characters(struct KatanaInternalParser* parser,
+                                     const char* str, KatanaParserString* output)
+{
+    size_t len = strlen(str);
+    maybe_resize_string(parser, len, output);
+    memcpy(output->data + output->length, str, len);
+    output->length += len;
+}
+
+void katana_string_prepend_characters(struct KatanaInternalParser* parser,
+                                      const char* str,
+                                      KatanaParserString* output)
+{
+    size_t len = strlen(str);
+    size_t new_length = output->length + len;
+    char* new_data = katana_parser_allocate(parser, new_length);
+    memcpy(new_data, str, len);
+    memcpy(new_data+len, output->data, output->length);
+    katana_parser_deallocate(parser, output->data);
+    output->data = new_data;
+    output->length = new_length;
+    output->capacity = new_length;
+}
+
+void katana_string_append_string(struct KatanaInternalParser* parser,
+                                 KatanaParserString* str,
+                                 KatanaParserString* output) {
+    maybe_resize_string(parser, str->length, output);
+    memcpy(output->data + output->length, str->data, str->length);
+    output->length += str->length;
+}
+
+bool katana_string_has_prefix(const char* str, const char* prefix)
+{
+    size_t pre_len = strlen(prefix);
+    size_t str_len = strlen(str);
+    return pre_len <= str_len && strncasecmp(prefix, str, pre_len);
+}
+
+void katana_string_to_lowercase(struct KatanaInternalParser* parser,
+                                KatanaParserString* str)
+{
+    if ( !str )
+        return;
+    // FIXME: @(QFish) the char* in string piece is const, to find a better way
+    char *c = (char*)str->data;
+    for (int i=0; i < str->length; i++) {
+        *c = tolower(*c);
+        c++;
+    }
+}
+
+
+
+const char* katana_string_to_characters(struct KatanaInternalParser * parser, const KatanaParserString* str)
+{
+    assert(NULL != str);
+    if (NULL == str)
+        return NULL;
+    
+    char* buffer = katana_parser_allocate(parser, sizeof(char) * (str->length + 1));
+    memcpy(buffer, str->data, str->length);
+    buffer[str->length] = '\0';
+    return buffer;
+}
+
+const char* katana_string_to_characters_with_prefix_char(struct KatanaInternalParser * parser, const KatanaParserString* str, const char prefix)
+{
+    assert(str);
+    if (NULL == str)
+        return NULL;
+    
+    char* buffer = katana_parser_allocate(parser, sizeof(char) * (str->length + 2));
+    memcpy((buffer + 1), str->data, str->length);
+    buffer[0] = prefix;
+    buffer[str->length] = '\0';
+    return buffer;
+}
+
+/**
+ * Array
+ */
+void katana_array_init(struct KatanaInternalParser* parser,
+                       size_t initial_capacity, KatanaArray* array) {
+    array->length = 0;
+    array->capacity = (unsigned int)initial_capacity;
+    if (initial_capacity > 0) {
+        array->data = katana_parser_allocate(parser, sizeof(void*) * initial_capacity);
+    } else {
+        array->data = NULL;
+    }
+}
+
+void katana_array_destroy(struct KatanaInternalParser* parser,
+                          KatanaArray* array) {
+    if (array->capacity > 0) {
+        katana_parser_deallocate(parser, array->data);
+    }
+}
+
+static void enlarge_array_if_full(struct KatanaInternalParser* parser,
+                                  KatanaArray* array) {
+    if (array->length >= array->capacity) {
+        if (array->capacity) {
+            size_t old_num_bytes = sizeof(void*) * array->capacity;
+            array->capacity *= 2;
+            size_t num_bytes = sizeof(void*) * array->capacity;
+            void** temp = katana_parser_allocate(parser, num_bytes);
+            memcpy(temp, array->data, old_num_bytes);
+            katana_parser_deallocate(parser, array->data);
+            array->data = temp;
+        } else {
+            // 0-capacity array; no previous array to deallocate.
+            array->capacity = 2;
+            array->data = katana_parser_allocate(parser, sizeof(void*) * array->capacity);
+        }
+    }
+}
+
+void katana_array_add(struct KatanaInternalParser* parser,
+                      void* element, KatanaArray* array) {
+    enlarge_array_if_full(parser, array);
+    assert(array->data);
+    assert(array->length < array->capacity);
+    array->data[array->length++] = element;
+}
+
+void* katana_array_pop(struct KatanaInternalParser* parser,
+                       KatanaArray* array) {
+    if (array->length == 0) {
+        return NULL;
+    }
+    return array->data[--array->length];
+}
+
+int katana_array_index_of(KatanaArray* array, void* element) {
+    for (int i = 0; i < array->length; ++i) {
+        if (array->data[i] == element) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+void katana_array_insert_at(struct KatanaInternalParser* parser,
+                            void* element, int index,
+                            KatanaArray* array) {
+    assert(index >= 0);
+    assert(index <= array->length);
+    enlarge_array_if_full(parser, array);
+    ++array->length;
+    memmove(&array->data[index + 1], &array->data[index],
+            sizeof(void*) * (array->length - index - 1));
+    array->data[index] = element;
+}
+
+void katana_array_remove(struct KatanaInternalParser* parser,
+                         void* node, KatanaArray* array) {
+    int index = katana_array_index_of(array, node);
+    if (index == -1) {
+        return;
+    }
+    katana_array_remove_at(parser, index, array);
+}
+
+void* katana_array_remove_at(struct KatanaInternalParser* parser,
+                             int index, KatanaArray* array) {
+    assert(index >= 0);
+    assert(index < array->length);
+    void* result = array->data[index];
+    memmove(&array->data[index], &array->data[index + 1],
+            sizeof(void*) * (array->length - index - 1));
+    --array->length;
+    return result;
+}
+
+/**
+ *  An alloc / free method
+ */
+void* katana_parser_allocate(struct KatanaInternalParser* parser, size_t size) {
+    return parser->options->allocator(parser->options->userdata, size);
+}
+
+void katana_parser_deallocate(struct KatanaInternalParser* parser, void* ptr) {
+    parser->options->deallocator(parser->options->userdata, ptr);
+}

data/ext/katana/src/foundation.h

@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2015 QFish <im@qfi.sh>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __Katana__foundation__
+#define __Katana__foundation__
+
+#include <stdio.h>
+#include <ctype.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "katana.h"
+    
+struct KatanaInternalParser;
+
+/**
+ *  String
+ */
+typedef struct {
+    char* data;
+    size_t length;
+    size_t capacity;
+} KatanaParserString;
+
+extern const KatanaParserString kKatanaAsteriskString;
+
+void katana_string_to_lowercase(struct KatanaInternalParser* parser, KatanaParserString* string);
+
+// Initializes a new KatanaParserString.
+void katana_string_init(struct KatanaInternalParser* parser, KatanaParserString* output);
+
+// Appends some characters onto the end of the KatanaParserString.
+void katana_string_append_characters(struct KatanaInternalParser* parser, const char* str, KatanaParserString* output);
+
+// Prepends some characters at the start of the KatanaParserString.
+void katana_string_prepend_characters(struct KatanaInternalParser* parser, const char* str, KatanaParserString* output);
+
+// Transforms a KatanaParserString to characters.
+const char* katana_string_to_characters(struct KatanaInternalParser * parser, const KatanaParserString* str);
+// Transforms a KatanaParserString to characters with a char prepended at the start of the KatanaParserString.
+const char* katana_string_to_characters_with_prefix_char(struct KatanaInternalParser * parser, const KatanaParserString* str, const char prefix);
+    
+// Appends a string onto the end of the KatanaParserString.
+void katana_string_append_string(struct KatanaInternalParser* parser, KatanaParserString* str, KatanaParserString* output);
+// Returns a bool value that indicates whether a given string matches the beginning characters of the receiver.
+bool katana_string_has_prefix(const char* str, const char* prefix);
+
+/**
+ *  Number
+ */
+typedef struct {
+    KatanaParserString raw;
+    double val;
+} KatanaParserNumber;
+
+/**
+ *  Array 
+ */
+// Initializes a new KatanaArray with the specified initial capacity.
+void katana_array_init(struct KatanaInternalParser* parser, size_t initial_capacity,
+                       KatanaArray* array);
+
+// Frees the memory used by an KatanaArray.  Does not free the contained
+// pointers, but you should free the pointers if necessary.
+void katana_array_destroy(struct KatanaInternalParser* parser, KatanaArray* array);
+
+// Adds a new element to an KatanaArray.
+void katana_array_add(struct KatanaInternalParser* parser, void* element, KatanaArray* array);
+
+// Removes and returns the element most recently added to the KatanaArray.
+// Ownership is transferred to caller.  Capacity is unchanged.  If the array is
+// empty, NULL is returned.
+void* katana_array_pop(struct KatanaInternalParser* parser, KatanaArray* array);
+
+// Inserts an element at a specific index.  This is potentially O(N) time, but
+// is necessary for some of the spec's behavior.
+void katana_array_insert_at(struct KatanaInternalParser* parser, void* element, int index,
+                            KatanaArray* array);
+
+// Removes an element from the array, or does nothing if the element is not in
+// the array.
+void katana_array_remove(struct KatanaInternalParser* parser, void* element, KatanaArray* array);
+
+// Removes and returns an element at a specific index.  Note that this is
+// potentially O(N) time and should be used sparingly.
+void* katana_array_remove_at(struct KatanaInternalParser* parser, int index, KatanaArray* array);
+
+/**
+ *  An alloc / free method wrapper
+ */
+void* katana_parser_allocate(struct KatanaInternalParser* parser, size_t size);
+void katana_parser_deallocate(struct KatanaInternalParser* parser, void* ptr);
+    
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* defined(__Katana__foundation__) */