wikitext 0.5 → 0.6

data/ext/ary.c

@@ -14,6 +14,69 @@
 
 #include "ary.h"
 
+ary_t *ary_new(void)
+{
+    ary_t *ary      = ALLOC_N(ary_t, 1);
+    ary->count      = 0;
+    ary->max        = DEFAULT_ENTRY_COUNT;
+    ary->entries    = ALLOC_N(int, DEFAULT_ENTRY_COUNT);
+    return ary;
+}
+
+int ary_entry(ary_t *ary, int idx)
+{
+    if (idx < 0)
+        idx = ary->count + idx;
+    return (idx >= 0 && ary->count > idx) ? ary->entries[idx] : INT_MAX;
+}
+
+void ary_clear(ary_t *ary)
+{
+    ary->count = 0;
+}
+
+int ary_pop(ary_t *ary)
+{
+    if (ary->count > 0)
+    {
+        ary->count--;
+        return 1;
+    }
+    return 0;
+}
+
+void ary_push(ary_t *ary, int val)
+{
+    if (ary->count == ary->max)
+    {
+        ary->max += DEFAULT_ENTRY_COUNT;
+        REALLOC_N(ary->entries, int, ary->max);
+    }
+    ary->entries[ary->count] = val;
+    ary->count++;
+}
+
+int ary_includes(ary_t *ary, int val)
+{
+    for (int i = 0, max = ary->count; i < max; i++)
+    {
+        if (ary->entries[i] == val)
+            return 1;
+    }
+    return 0;
+}
+
+int ary_count(ary_t *ary, int item)
+{
+    int count = 0;
+    for (int i = 0, max = ary->count; i < max; i++)
+    {
+        if (ary->entries[i] == item)
+            count++;
+    }
+    return count;
+}
+
 void ary_free(ary_t *ary)
 {
     free(ary->entries);

data/ext/ary.h

@@ -12,7 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <ruby.h>
+#include "ruby_compat.h"
 
 typedef struct
 {
@@ -28,73 +28,18 @@ typedef struct
 
 // Mark the ary struct designated by ptr as a participant in Ruby's mark-and-sweep garbage collection scheme.
 // A variable named name is placed on the C stack to prevent the structure from being prematurely collected.
-#define GC_WRAP_ARY(ptr, name) volatile VALUE name = Data_Wrap_Struct(rb_cObject, 0, ary_free, ptr)
+#define GC_WRAP_ARY(ptr, name) volatile VALUE name __attribute__((unused)) = Data_Wrap_Struct(rb_cObject, 0, ary_free, ptr)
 
-inline ary_t *ary_new(void)
-{
-    ary_t *ary      = ALLOC_N(ary_t, 1);
-    ary->count      = 0;
-    ary->max        = DEFAULT_ENTRY_COUNT;
-    ary->entries    = ALLOC_N(int, DEFAULT_ENTRY_COUNT);
-    return ary;
-}
-
-// this method not inlined so its address can be passed to the Data_Wrap_Struct function.
-void ary_free(ary_t *ary);
-
-inline int ary_entry(ary_t *ary, int idx)
-{
-    if (idx < 0)
-        idx = ary->count + idx;
-    return (idx >= 0 && ary->count > idx) ? ary->entries[idx] : INT_MAX;
-}
-
-inline void ary_clear(ary_t *ary)
-{
-    ary->count = 0;
-}
-
-inline int ary_pop(ary_t *ary)
-{
-    if (ary->count > 0)
-    {
-        ary->count--;
-        return 1;
-    }
-    return 0;
-}
-
-inline void ary_push(ary_t *ary, int val)
-{
-    if (ary->count == ary->max)
-    {
-        ary->max += DEFAULT_ENTRY_COUNT;
-        REALLOC_N(ary->entries, int, ary->max);
-    }
-    ary->entries[ary->count] = val;
-    ary->count++;
-}
-
-inline int ary_includes(ary_t *ary, int val)
-{
-    for (int i = 0, max = ary->count; i < max; i++)
-    {
-        if (ary->entries[i] == val)
-            return 1;
-    }
-    return 0;
-}
+ary_t *ary_new(void);
+int ary_entry(ary_t *ary, int idx);
+void ary_clear(ary_t *ary);
+int ary_pop(ary_t *ary);
+void ary_push(ary_t *ary, int val);
+int ary_includes(ary_t *ary, int val);
 
 // returns a count indicating the number of times the value appears in the collection
 // refactored from _Wikitext_count()
-inline int ary_count(ary_t *ary, int item)
-{
-    int count = 0;
-    for (int i = 0, max = ary->count; i < max; i++)
-    {
-        if (ary->entries[i] == item)
-            count++;
-    }
-    return count;
-}
+int ary_count(ary_t *ary, int item);
 
+// this method not inlined so its address can be passed to the Data_Wrap_Struct function.
+void ary_free(ary_t *ary);

data/ext/depend

@@ -14,11 +14,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-CFLAGS += -std=gnu99
+# don't warn about unused params because many Ruby methods accept "self" but don't use it
+CFLAGS += -std=gnu99 -Wall -Wextra -Wno-unused-parameter
 
-ary.o : ary.c ary.h
-parser.o : ary.c ary.h parser.c parser.h token.h str.c str.h wikitext.h wikitext_ragel.h
-str.o : str.c str.h
-token.o : token.c token.h wikitext.h
-wikitext.o : parser.h token.h wikitext.c wikitext.h wikitext_ragel.h
-wikitext_ragel.o : token.h wikitext.h wikitext_ragel.h wikitext_ragel.c
+ary.o : ary.c ary.h ruby_compat.h
+parser.o : ary.c ary.h parser.c parser.h ruby_compat.h str.c str.h token.h wikitext.h wikitext_ragel.h
+str.o : ruby_compat.h str.c str.h
+token.o : ruby_compat.h token.c token.h wikitext.h
+wikitext.o : parser.h ruby_compat.h token.h wikitext.c wikitext.h wikitext_ragel.h
+wikitext_ragel.o : ruby_compat.h token.h wikitext.h wikitext_ragel.h wikitext_ragel.c

data/ext/parser.c

@@ -158,7 +158,7 @@ VALUE Wikitext_parser_benchmarking_tokenize(VALUE self, VALUE string)
 }
 
 // we downcase "in place", overwriting the original contents of the buffer and returning the same string
-inline VALUE _Wikitext_downcase(VALUE string)
+VALUE _Wikitext_downcase(VALUE string)
 {
     char *ptr   = RSTRING_PTR(string);
     long len    = RSTRING_LEN(string);
@@ -170,7 +170,7 @@ inline VALUE _Wikitext_downcase(VALUE string)
     return string;
 }
 
-inline VALUE _Wikitext_hyperlink(VALUE link_prefix, VALUE link_target, VALUE link_text, VALUE link_class)
+VALUE _Wikitext_hyperlink(VALUE link_prefix, VALUE link_target, VALUE link_text, VALUE link_class)
 {
     VALUE string = rb_str_new(a_start, sizeof(a_start) - 1);        // <a href="
     if (!NIL_P(link_prefix))
@@ -187,7 +187,7 @@ inline VALUE _Wikitext_hyperlink(VALUE link_prefix, VALUE link_target, VALUE lin
     return string;
 }
 
-inline void _Wikitext_append_img(parser_t *parser, char *token_ptr, int token_len)
+void _Wikitext_append_img(parser_t *parser, char *token_ptr, int token_len)
 {
     rb_str_cat(parser->output, img_start, sizeof(img_start) - 1);   // <img src="
     if (!NIL_P(parser->img_prefix))
@@ -201,7 +201,7 @@ inline void _Wikitext_append_img(parser_t *parser, char *token_ptr, int token_le
 // will emit indentation only if we are about to emit any of:
 //      <blockquote>, <p>, <ul>, <ol>, <li>, <h1> etc, <pre>
 // each time we enter one of those spans must ++ the indentation level
-inline void _Wikitext_indent(parser_t *parser)
+void _Wikitext_indent(parser_t *parser)
 {
     int space_count = parser->current_indent + parser->base_indent;
     if (space_count > 0)
@@ -220,7 +220,7 @@ inline void _Wikitext_indent(parser_t *parser)
     parser->current_indent += 2;
 }
 
-inline void _Wikitext_dedent(parser_t *parser, VALUE emit)
+void _Wikitext_dedent(parser_t *parser, VALUE emit)
 {
     parser->current_indent -= 2;
     if (emit != Qtrue)
@@ -393,7 +393,7 @@ void _Wikitext_pop_from_stack_up_to(parser_t *parser, VALUE target, int item, VA
     } while (continue_looping);
 }
 
-inline void _Wikitext_start_para_if_necessary(parser_t *parser)
+void _Wikitext_start_para_if_necessary(parser_t *parser)
 {
     if (!NIL_P(parser->capture))    // we don't do anything if in capturing mode
         return;
@@ -442,7 +442,7 @@ inline void _Wikitext_start_para_if_necessary(parser_t *parser)
 // on the line scope.
 // Luckily, BLOCKQUOTE_START tokens can only appear at the start of the scope array, so we can check for them first before
 // entering the for loop.
-void inline _Wikitext_pop_excess_elements(parser_t *parser)
+void _Wikitext_pop_excess_elements(parser_t *parser)
 {
     if (!NIL_P(parser->capture)) // we don't pop anything if in capturing mode
         return;
@@ -471,7 +471,7 @@ void inline _Wikitext_pop_excess_elements(parser_t *parser)
 // the number of bytes in the UTF-8 character (between 1 and 4) is returned by reference in width_out
 // raises a RangeError if the supplied character is invalid UTF-8
 // (in which case it also frees the block of memory indicated by dest_ptr if it is non-NULL)
-inline uint32_t _Wikitext_utf8_to_utf32(char *src, char *end, long *width_out, void *dest_ptr)
+uint32_t _Wikitext_utf8_to_utf32(char *src, char *end, long *width_out, void *dest_ptr)
 {
     uint32_t dest;
     if ((unsigned char)src[0] <= 0x7f)                      // ASCII
@@ -515,7 +515,7 @@ inline uint32_t _Wikitext_utf8_to_utf32(char *src, char *end, long *width_out, v
     return dest;
 }
 
-inline VALUE _Wikitext_utf32_char_to_entity(uint32_t character)
+VALUE _Wikitext_utf32_char_to_entity(uint32_t character)
 {
     // TODO: consider special casing some entities (ie. quot, amp, lt, gt etc)?
     char hex_string[8]  = { '&', '#', 'x', 0, 0, 0, 0, ';' };
@@ -530,7 +530,7 @@ inline VALUE _Wikitext_utf32_char_to_entity(uint32_t character)
     return rb_str_new((const char *)hex_string, sizeof(hex_string));
 }
 
-inline VALUE _Wikitext_parser_trim_link_target(VALUE string)
+VALUE _Wikitext_parser_trim_link_target(VALUE string)
 {
     string              = StringValue(string);
     char    *src        = RSTRING_PTR(string);
@@ -544,7 +544,7 @@ inline VALUE _Wikitext_parser_trim_link_target(VALUE string)
         if (*src == ' ')
         {
             if (src == left)
-                *left++;
+                left++;
         }
         else
             non_space = src;
@@ -560,7 +560,7 @@ inline VALUE _Wikitext_parser_trim_link_target(VALUE string)
 // - QUOT and AMP characters converted to named entities
 // - if rollback is Qtrue, there is no special treatment of spaces
 // - if rollback is Qfalse, leading and trailing whitespace trimmed if trimmed
-inline VALUE _Wikitext_parser_sanitize_link_target(parser_t *parser, VALUE rollback)
+VALUE _Wikitext_parser_sanitize_link_target(parser_t *parser, VALUE rollback)
 {
     VALUE string        = StringValue(parser->link_target); // raises if string is nil or doesn't quack like a string
     char    *src        = RSTRING_PTR(string);
@@ -667,7 +667,7 @@ VALUE Wikitext_parser_sanitize_link_target(VALUE self, VALUE string)
 //         thing. [[Foo]] was...
 // this is also where we check treat_slash_as_special is true and act accordingly
 // basically any link target matching /\A[a-z]+\/\d+\z/ is flagged as special
-inline static void _Wikitext_parser_encode_link_target(parser_t *parser)
+static void _Wikitext_parser_encode_link_target(parser_t *parser)
 {
     VALUE in                = StringValue(parser->link_target);
     char        *input      = RSTRING_PTR(in);
@@ -784,8 +784,7 @@ VALUE Wikitext_parser_encode_special_link_target(VALUE self, VALUE in)
     return parser.link_target;
 }
 
-// not sure whether these rollback functions should be inline: could refactor them into a single non-inlined function
-inline void _Wikitext_rollback_failed_link(parser_t *parser)
+void _Wikitext_rollback_failed_link(parser_t *parser)
 {
     if (!IN(LINK_START))
         return; // nothing to do!
@@ -808,7 +807,7 @@ inline void _Wikitext_rollback_failed_link(parser_t *parser)
     parser->link_text   = Qnil;
 }
 
-inline void _Wikitext_rollback_failed_external_link(parser_t *parser)
+void _Wikitext_rollback_failed_external_link(parser_t *parser)
 {
     if (!IN(EXT_LINK_START))
         return; // nothing to do!
@@ -880,6 +879,7 @@ VALUE Wikitext_parser_profiling_parse(VALUE self, VALUE string)
 {
     for (int i = 0; i < 100000; i++)
         Wikitext_parser_parse(1, &string, self);
+    return Qnil;
 }
 
 VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
@@ -970,9 +970,6 @@ VALUE Wikitext_parser_parse(int argc, VALUE *argv, VALUE self)
         }
         int type = token->type;
 
-        // many restrictions depend on what is at the top of the stack
-        int top = ary_entry(parser->scope, -1);
-
         // can't declare new variables inside a switch statement, so predeclare them here
         long remove_strong          = -1;
         long remove_em              = -1;

data/ext/parser.h

@@ -12,7 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <ruby.h>
+#include "ruby_compat.h"
 
 VALUE Wikitext_parser_initialize(int argc, VALUE *argv, VALUE self);
 

data/ext/ruby_compat.h

@@ -0,0 +1,25 @@
+// Copyright 2008 Wincent Colaiuta
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <ruby.h>
+
+// for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_PTR
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+// for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_LEN
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif

data/ext/str.c

@@ -14,6 +14,99 @@
 
 #include "str.h"
 
+str_t *str_new(void)
+{
+    str_t *str      = ALLOC_N(str_t, 1);
+    str->ptr        = NULL;
+    str->len        = 0;
+    str->capacity   = 0;
+    return str;
+}
+
+str_t *str_new_size(long len)
+{
+    str_t *str      = ALLOC_N(str_t, 1);
+    str->ptr        = ALLOC_N(char, len);
+    str->len        = 0;
+    str->capacity   = len;
+    return str;
+}
+
+str_t *str_new_copy(char *src, long len)
+{
+    str_t *str      = ALLOC_N(str_t, 1);
+    str->ptr        = ALLOC_N(char, len);
+    memcpy(str->ptr, src, len);
+    str->len        = len;
+    str->capacity   = len;
+    return str;
+}
+
+str_t *str_new_no_copy(char *src, long len)
+{
+    str_t *str      = ALLOC_N(str_t, 1);
+    str->ptr        = src;
+    str->len        = len;
+    str->capacity   = len;
+    return str;
+}
+
+str_t *str_new_from_string(VALUE string)
+{
+    string = StringValue(string);
+    return str_new_copy(RSTRING_PTR(string), RSTRING_LEN(string));
+}
+
+VALUE string_from_str(str_t *str)
+{
+    return rb_str_new(str->ptr, str->len);
+}
+
+void str_grow(str_t *str, long len)
+{
+    if (str->capacity < len)
+    {
+        if (str->ptr)
+            REALLOC_N(str->ptr, char, len);
+        else
+            str->ptr = ALLOC_N(char, len);
+        str->capacity = len;
+    }
+}
+
+void str_append(str_t *str, char *src, long len)
+{
+    long new_len = str->len + len;
+    if (str->capacity < new_len)
+    {
+        if (str->ptr)
+            REALLOC_N(str->ptr, char, new_len);
+        else
+            str->ptr = ALLOC_N(char, new_len);
+        str->capacity = new_len;
+    }
+    memcpy(str->ptr + str->len, src, len);
+    str->len = new_len;
+}
+
+void str_append_str(str_t *str, str_t *other)
+{
+    str_append(str, other->ptr, other->len);
+}
+
+void str_swap(str_t **a, str_t **b)
+{
+    str_t *c;
+    c = *a;
+    *a = *b;
+    *b = c;
+}
+
+void str_clear(str_t *str)
+{
+    str->len = 0;
+}
+
 void str_free(str_t *str)
 {
     if (str->ptr)

data/ext/str.h

@@ -12,7 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <ruby.h>
+#include "ruby_compat.h"
 
 typedef struct
 {
@@ -23,113 +23,41 @@ typedef struct
 
 // Mark the str struct designated by ptr as a participant in Ruby's mark-and-sweep garbage collection scheme.
 // A variable named name is placed on the C stack to prevent the structure from being prematurely collected.
-#define GC_WRAP_STR(ptr, name) volatile VALUE name = Data_Wrap_Struct(rb_cObject, 0, str_free, ptr)
+#define GC_WRAP_STR(ptr, name) volatile VALUE name __attribute__((unused)) = Data_Wrap_Struct(rb_cObject, 0, str_free, ptr)
 
 // create a new, empty string struct
-inline str_t *str_new(void)
-{
-    str_t *str      = ALLOC_N(str_t, 1);
-    str->ptr        = NULL;
-    str->len        = 0;
-    str->capacity   = 0;
-    return str;
-}
+str_t *str_new(void);
 
 // create a new, empty string struct with capacity len
-inline str_t *str_new_size(long len)
-{
-    str_t *str      = ALLOC_N(str_t, 1);
-    str->ptr        = ALLOC_N(char, len);
-    str->len        = 0;
-    str->capacity   = len;
-    return str;
-}
+str_t *str_new_size(long len);
 
 // create a new string struct and initialize it with a copy of the buffer of length len pointed to by src
-inline str_t *str_new_copy(char *src, long len)
-{
-    str_t *str      = ALLOC_N(str_t, 1);
-    str->ptr        = ALLOC_N(char, len);
-    memcpy(str->ptr, src, len);
-    str->len        = len;
-    str->capacity   = len;
-    return str;
-}
+str_t *str_new_copy(char *src, long len);
 
 // create a new string struct and initialize it with the buffer of length len pointed to by src
 // no copy is made; the struct takes ownership of the buffer and will free it when the struct is disposed of
-inline str_t *str_new_no_copy(char *src, long len)
-{
-    str_t *str      = ALLOC_N(str_t, 1);
-    str->ptr        = src;
-    str->len        = len;
-    str->capacity   = len;
-    return str;
-}
+str_t *str_new_no_copy(char *src, long len);
 
 // convenience method for testing
-inline str_t *str_new_from_string(VALUE string)
-{
-    string = StringValue(string);
-    return str_new_copy(RSTRING_PTR(string), RSTRING_LEN(string));
-}
+str_t *str_new_from_string(VALUE string);
 
 // convenience method for testing
-inline VALUE string_from_str(str_t *str)
-{
-    return rb_str_new(str->ptr, str->len);
-}
+VALUE string_from_str(str_t *str);
 
 // grows a string's capacity to the specified length
-inline void str_grow(str_t *str, long len)
-{
-    if (str->capacity < len)
-    {
-        if (str->ptr)
-            REALLOC_N(str->ptr, char, len);
-        else
-            str->ptr = ALLOC_N(char, len);
-        str->capacity = len;
-    }
-}
+void str_grow(str_t *str, long len);
 
-inline void str_append(str_t *str, char *src, long len)
-{
-    long new_len = str->len + len;
-    if (str->capacity < new_len)
-    {
-        if (str->ptr)
-            REALLOC_N(str->ptr, char, new_len);
-        else
-            str->ptr = ALLOC_N(char, new_len);
-        str->capacity = new_len;
-    }
-    memcpy(str->ptr + str->len, src, len);
-    str->len = new_len;
-}
+void str_append(str_t *str, char *src, long len);
 
 // appends the "other" string struct onto str
-inline void str_append_str(str_t *str, str_t *other)
-{
-    str_append(str, other->ptr, other->len);
-}
+void str_append_str(str_t *str, str_t *other);
 
 // this is a temporary convenience measure
 // later on if I develop in-place variants of some functions this won't be needed
-inline void str_swap(str_t **a, str_t **b)
-{
-    str_t *c;
-    c = *a;
-    *a = *b;
-    *b = c;
-}
+void str_swap(str_t **a, str_t **b);
 
 // don't actually free the memory yet
 // this makes str structs very useful when reusing buffers because it avoids reallocation
-inline void str_clear(str_t *str)
-{
-    str->len = 0;
-}
+void str_clear(str_t *str);
 
-// this method not inlined so its address can be passed to the Data_Wrap_Struct function.
 void str_free(str_t *str);

data/ext/token.h

@@ -12,7 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <ruby.h>
+#include "ruby_compat.h"
 #include <stdint.h>     /* uint32_t */
 
 #define TOKEN_TEXT(token)   rb_str_new((const char *)token->start, (token->stop - token->start))

data/ext/wikitext.h

@@ -12,7 +12,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include <ruby.h>
+#include "ruby_compat.h"
 #include <stdint.h>
 
 #define ruby_inspect(obj) rb_funcall(rb_mKernel, rb_intern("p"), 1, obj)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wikitext
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: "0.6"
 platform: ruby
 authors: 
 - Wincent Colaiuta
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-23 00:00:00 +01:00
+date: 2008-02-29 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -61,6 +61,7 @@ files:
 - ext/wikitext_ragel.c
 - ext/ary.h
 - ext/parser.h
+- ext/ruby_compat.h
 - ext/str.h
 - ext/token.h
 - ext/wikitext.h