fast_xs 0.4 → 0.5

data/Rakefile

@@ -13,7 +13,7 @@ begin
   rev = Time.at(rev.split("\n")[1].to_i).strftime('%Y%m%d.%H%M%S')
 rescue
 end
-version ||= ENV['VERSION'] || '0.4' + (rev && rev.length > 0 ? ".#{rev}" : '')
+version ||= ENV['VERSION'] || '0.5' + (rev && rev.length > 0 ? ".#{rev}" : '')
 pkg = "#{name}-#{version}"
 bin = "*.{so,o}"
 archlib = "lib/#{::Config::CONFIG['arch']}"
@@ -24,7 +24,7 @@ rdoc_opts = ['--quiet', '--title', 'fast_xs notes', '--main', 'README',
              '--inline-source']
 pkg_files = %w(CHANGELOG COPYING README Rakefile) +
             Dir.glob("{test,lib}/**/*.rb") +
-            Dir.glob("ext/**/*.{c,rb}")
+            Dir.glob("ext/**/*.{c,rb,h}")
 
 
 spec = Gem::Specification.new do |s|

data/ext/fast_xs/fast_xs.c

@@ -4,11 +4,41 @@
 #include <assert.h>
 #include <sys/time.h>
 #include <sys/resource.h>
+#include "ruby_1_9_compat.h"
+
+/* I don't trust ctype.h when it comes to locale-independence: */
+static __inline__ int is_hex(const int x)
+{
+	return (((x) >= '0' && (x) <= '9') ||
+                ((x) >= 'a' && (x) <= 'f') ||
+		((x) >= 'A' && (x) <= 'F'));
+}
+
+static __inline__ int xtoupper(const int x)
+{
+	return (x >= 'a' && x <= 'f') ? (x & ~0x20) : x;
+}
+
+static __inline__ int hexchar_to_int(const int x)
+{
+	return (x < 'A') ? (x - '0') : (xtoupper(x) - 'A' + 10);
+}
+
+static __inline__ int hexpair_to_int(const int x1, const int x2)
+{
+	return ((hexchar_to_int(x1) << 4) | hexchar_to_int(x2));
+}
 
 static ID unpack_id;
 static VALUE U_fmt, C_fmt;
 static rlim_t alloca_limit = 4096; /* very small default */
 
+#define xs_alloc(size) \
+	unlikely((size) > alloca_limit) ? malloc(size) : alloca(size)
+
+#define xs_free(ptr, size) \
+	do { if (unlikely((size) > alloca_limit)) free(ptr); } while (0)
+
 /* give GCC hints for better branch prediction
  * (we layout branches so that ASCII characters are handled faster) */
 #if defined(__GNUC__) && (__GNUC__ >= 3)
@@ -128,21 +158,6 @@ static size_t escape(char *buf, int n)
 	return 1;
 }
 
-static long escaped_len(int n)
-{
-	if (likely(n < 128)) {
-		if (unlikely(n == '&'))
-			return (sizeof("&amp;") - 1);
-		if (unlikely(n == '>' || n == '<'))
-			return (sizeof("&gt;") - 1);
-		return 1;
-	}
-
-	CP_1252_ESCAPE(n);
-
-	return VALID_VALUE(n) ? bytes_for(n) : 1;
-}
-
 static VALUE unpack_utf8(VALUE self)
 {
 	return rb_funcall(self, unpack_id, 1, U_fmt);
@@ -156,26 +171,40 @@ static VALUE unpack_uchar(VALUE self)
 static VALUE fast_xs(VALUE self)
 {
 	long i;
-	struct RArray *array;
+	VALUE array;
 	char *s, *c;
-	size_t s_len = 0;
+	size_t s_len;
 	VALUE *tmp;
 	VALUE rv;
 
-	array = RARRAY(rb_rescue(unpack_utf8, self, unpack_uchar, self));
+	array = rb_rescue(unpack_utf8, self, unpack_uchar, self);
 
-	for (tmp = array->ptr, i = array->len; --i >= 0; tmp++)
-		s_len += escaped_len(NUM2INT(*tmp));
+	for (tmp = RARRAY_PTR(array), s_len = i = RARRAY_LEN(array);
+	     --i >= 0;
+	     tmp++) {
+		int n = NUM2INT(*tmp);
+		if (likely(n < 128)) {
+			if (unlikely(n == '&'))
+				s_len += (sizeof("&amp;") - 2);
+			if (unlikely(n == '>' || n == '<'))
+				s_len += (sizeof("&gt;") - 2);
+			continue;
+		}
+
+		CP_1252_ESCAPE(n);
+
+		if (VALID_VALUE(n))
+			s_len += bytes_for(n) - 1;
+	}
 
 	c = s = unlikely(s_len > alloca_limit) ? malloc(s_len) : alloca(s_len);
 
-	for (tmp = array->ptr, i = array->len; --i >= 0; tmp++)
+	for (tmp = RARRAY_PTR(array), i = RARRAY_LEN(array); --i >= 0; tmp++)
 		c += escape(c, NUM2INT(*tmp));
 
 	rv = rb_str_new(s, s_len);
 
-	if (unlikely(s_len > alloca_limit))
-		free(s);
+	xs_free(s, s_len);
 
 	return rv;
 }
@@ -188,32 +217,28 @@ static VALUE fast_xs(VALUE self)
  */
 static VALUE fast_xs_html(VALUE self)
 {
-	struct RString *string = RSTRING(self);
 	long i;
 	char *s;
-	size_t new_len = 0;
+	size_t new_len = RSTRING_LEN(self);
 	char *new_str;
 	VALUE rv;
 
-	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) {
 		if (unlikely(*s == '&'))
-			new_len += (sizeof("&amp;") - 1);
+			new_len += (sizeof("&amp;") - 2);
 		else if (unlikely(*s == '<' || *s == '>'))
-			new_len += (sizeof("&gt;") - 1);
+			new_len += (sizeof("&gt;") - 2);
 		else if (unlikely(*s == '"'))
-			new_len += (sizeof("&quot;") - 1);
-		else
-			new_len += 1;
+			new_len += (sizeof("&quot;") - 2);
 	}
 
-	new_str = unlikely(new_len > alloca_limit) ? malloc(new_len)
-	                                           : alloca(new_len);
+	new_str = xs_alloc(new_len);
 
 #define append_const(buf, x) do { \
 	buf = memcpy(buf, x, sizeof(x) - 1) + sizeof(x) - 1; \
 } while (0)
 
-	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) {
 		if (unlikely(*s == '&'))
 			append_const(new_str, "&amp;");
 		else if (unlikely(*s == '<'))
@@ -230,8 +255,7 @@ static VALUE fast_xs_html(VALUE self)
 
 	rv = rb_str_new(new_str - new_len, new_len);
 
-	if (unlikely(new_len > alloca_limit))
-		free(new_str - new_len);
+	xs_free(new_str - new_len, new_len);
 
 	return rv;
 }
@@ -244,24 +268,21 @@ static VALUE fast_xs_html(VALUE self)
 
 static inline VALUE _xs_uri_encode(VALUE self, const unsigned int space_to_plus)
 {
-	struct RString *string = RSTRING(self);
 	long i;
 	char *s;
-	size_t new_len = 0;
+	size_t new_len = RSTRING_LEN(self);
 	char *new_str;
 	VALUE rv;
 
-	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
-		if (likely(CGI_URI_OK(*s) || (space_to_plus && *s == ' ')))
-			++new_len;
-		else /* we'll only get <= "%FF" here */
-			new_len += 3;
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) {
+		if (likely(CGI_URI_OK(*s)) || (space_to_plus && *s == ' '))
+			continue;
+		new_len += 2;
 	}
 
-	new_str = unlikely(new_len > alloca_limit) ? malloc(new_len)
-	                                           : alloca(new_len);
+	new_str = xs_alloc(new_len);
 
-	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) {
 		if (likely(CGI_URI_OK(*s)))
 			*new_str++ = *s;
 		else if (space_to_plus && *s == ' ')
@@ -277,8 +298,7 @@ static inline VALUE _xs_uri_encode(VALUE self, const unsigned int space_to_plus)
 
 	rv = rb_str_new(new_str - new_len, new_len);
 
-	if (unlikely(new_len > alloca_limit))
-		free(new_str - new_len);
+	xs_free(new_str - new_len, new_len);
 
 	return rv;
 }
@@ -302,6 +322,53 @@ static VALUE fast_xs_cgi(VALUE self)
 	return _xs_uri_encode(self, 1);
 }
 
+static VALUE _uxs_uri(VALUE self, const unsigned int plus_to_space)
+{
+	char *s, *new_str;
+	long i;
+	size_t new_len = RSTRING_LEN(self);
+	VALUE rv;
+
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self);
+	     --i >= 0;
+	     ++s) {
+		if (unlikely(*s == '%') &&
+		    likely(is_hex(s[1])) &&
+		    likely(is_hex(s[2]))) {
+			new_len -= 2;
+			s += 2;
+			i -= 2;
+		}
+	}
+
+	new_str = xs_alloc(new_len);
+	for (s = RSTRING_PTR(self), i = RSTRING_LEN(self);
+	     --i >= 0;
+	     ++s, ++new_str) {
+		if (plus_to_space && unlikely(*s == '+'))
+			*new_str = ' ';
+		else if (unlikely(*s == '%') &&
+		         likely(is_hex(s[1])) &&
+			 likely(is_hex(s[2]))) {
+			*new_str = hexpair_to_int(s[1], s[2]);
+			s += 2;
+			i -= 2;
+		} else
+			*new_str = *s;
+	}
+
+	rv = rb_str_new(new_str - new_len, new_len);
+
+	xs_free(s, new_len);
+
+	return rv;
+}
+
+static VALUE fast_uxs_cgi(VALUE self)
+{
+	return _uxs_uri(self, 1);
+}
+
 void Init_fast_xs(void)
 {
 	struct rlimit rlim;
@@ -321,5 +388,6 @@ void Init_fast_xs(void)
 	rb_define_method(rb_cString, "fast_xs", fast_xs, 0);
 	rb_define_method(rb_cString, "fast_xs_html", fast_xs_html, 0);
 	rb_define_method(rb_cString, "fast_xs_cgi", fast_xs_cgi, 0);
+	rb_define_method(rb_cString, "fast_uxs_cgi", fast_uxs_cgi, 0);
 	rb_define_method(rb_cString, "fast_xs_url", fast_xs_url, 0);
 }

data/ext/fast_xs/ruby_1_9_compat.h

@@ -0,0 +1,14 @@
+/* Ruby 1.8.6+ macros (for compatibility with Ruby 1.9) */
+#ifndef RSTRING_PTR
+#  define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+

data/lib/fast_xs_monkey_patcher.rb

@@ -1,40 +1,32 @@
 require 'fast_xs'
 
-if defined?(CGI)
-
-  class CGI
-
-    def CGI::escapeHTML(value)
-      value.fast_xs_html
-    end
-
-    def CGI::escape(value)
-      value.fast_xs_cgi
-    end
-
-  end
-
-end
-
-if defined?(ERB::Util)
-
-  module ERB::Util
-
-    def html_escape(value)
-      value.to_s.fast_xs_html
-    end
-    alias h html_escape
-    module_function :h
-    module_function :html_escape
-
-    def url_encode(value)
-      value.to_s.fast_xs_url
-    end
-    alias u url_encode
-    module_function :u
-    module_function :url_encode
-
-
-  end
-
-end
+class CGI
+  def CGI::escapeHTML(value); value.fast_xs_html; end
+  def CGI::escape(value); value.fast_xs_cgi; end
+  def CGI::unescape(value); value.fast_uxs_cgi; end
+end if defined?(CGI)
+
+module ERB::Util
+  def html_escape(value); value.to_s.fast_xs_html; end
+  alias h html_escape
+  module_function :h
+  module_function :html_escape
+
+  def url_encode(value); value.to_s.fast_xs_url; end
+  alias u url_encode
+  module_function :u
+  module_function :url_encode
+end if defined?(ERB::Util)
+
+class Mongrel::HttpRequest
+  def self.unescape(s); s.fast_uxs_cgi; end
+  def self.escape(s); s.to_s.fast_xs_cgi; end
+end if defined?(Mongrel::HttpRequest)
+
+module Rack::Utils
+  def unescape(s); s.fast_uxs_cgi; end
+  module_function :unescape
+
+  def escape(s); s.to_s.fast_xs_cgi; end
+  module_function :escape
+end if defined?(Rack::Utils)

data/test/test_cgi_class_overrides.rb

@@ -31,6 +31,15 @@ class TestCgiClassOverrides < Test::Unit::TestCase
     assert_equal 'H3LL0+W0RLD', CGI::escape('H3LL0 W0RLD')
   end
 
+  def test_unescape_cgi
+    assert_equal 'hello=world', CGI::unescape('hello%3Dworld')
+    assert_equal ' ', CGI::unescape('+')
+    assert_equal '+', CGI::unescape('%2B')
+    assert_equal ',', CGI::unescape('%2C')
+    assert_equal 'hello-world', CGI::unescape('hello-world')
+    assert_equal 'H3LL0 W0RLD', CGI::unescape('H3LL0+W0RLD')
+  end
+
   def test_large_strings
     if ENV['LARGE_STRING_TEST']
       assert CGI::escape('&' * (8192 * 1024))

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4.7
 specification_version: 2
 name: fast_xs
 version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2007-12-12 00:00:00 -08:00
+  version: "0.5"
+date: 2008-01-07 00:00:00 -08:00
 summary: excessively fast escaping
 require_paths: 
 - lib/i486-linux
@@ -47,6 +47,7 @@ files:
 - lib/fast_xs_monkey_patcher.rb
 - ext/fast_xs/fast_xs.c
 - ext/fast_xs/extconf.rb
+- ext/fast_xs/ruby_1_9_compat.h
 test_files: []
 
 rdoc_options: