clj 0.0.5.6 → 0.0.6

data/ext/clj/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+	$CFLAGS << ' -O3'
+end
+
+if CONFIG['CC'] =~ /gcc/
+	$CFLAGS << ' -Wall' << ' -std=c99'
+
+	if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+		$CFLAGS << ' -O0 -ggdb'
+	end
+end
+
+create_makefile 'clj/parser_ext'

data/ext/clj/io_parser.c

@@ -0,0 +1,18 @@
+/**
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *                    Version 2, December 2004
+ *
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+ *
+ *  0. You just DO WHAT THE FUCK YOU WANT TO.
+ **/
+
+#ifdef _INSIDE_PARSER
+
+static VALUE io_parse (VALUE self)
+{
+	return Qnil;
+}
+
+#endif

data/ext/clj/parser.c

@@ -0,0 +1,127 @@
+/**
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *                    Version 2, December 2004
+ *
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+ *
+ *  0. You just DO WHAT THE FUCK YOU WANT TO.
+ **/
+
+#include <stdbool.h>
+#include <ctype.h>
+
+#include "ruby.h"
+
+static VALUE cClojure;
+static VALUE cParser;
+
+static VALUE UNICODE_REGEX;
+static VALUE OCTAL_REGEX;
+
+#define _INSIDE_PARSER
+typedef enum {
+	NODE_METADATA,
+	NODE_NUMBER,
+	NODE_BOOLEAN,
+	NODE_NIL,
+	NODE_CHAR,
+	NODE_KEYWORD,
+	NODE_STRING,
+	NODE_MAP,
+	NODE_LIST,
+	NODE_VECTOR,
+	NODE_INSTANT,
+	NODE_SET,
+	NODE_REGEXP
+} NodeType;
+
+#include "string_parser.c"
+#include "io_parser.c"
+#undef _INSIDE_PARSER
+
+static VALUE t_init (int argc, VALUE* argv, VALUE self)
+{
+	VALUE tmp;
+	VALUE source;
+	VALUE options;
+
+	if (argc < 1) {
+		rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+	}
+	else if (argc > 2) {
+		rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
+	}
+
+	if (!rb_obj_is_kind_of(argv[0], rb_cString) && !rb_obj_is_kind_of(argv[0], rb_cIO)) {
+		rb_raise(rb_eArgError, "you have to pass a String or an IO");
+	}
+
+	source  = argv[0];
+	options = argc == 2 ? argv[1] : rb_hash_new();
+
+	rb_iv_set(self, "@source", source);
+	rb_iv_set(self, "@options", options);
+
+	if (!NIL_P(tmp = rb_hash_aref(options, rb_intern("map_class")))) {
+		rb_iv_set(self, "@map_class", tmp);
+	}
+	else {
+		rb_iv_set(self, "@map_class", rb_const_get(cClojure, rb_intern("Map")));
+	}
+
+	if (!NIL_P(tmp = rb_hash_aref(options, rb_intern("vector_class")))) {
+		rb_iv_set(self, "@vector_class", tmp);
+	}
+	else {
+		rb_iv_set(self, "@vector_class", rb_const_get(cClojure, rb_intern("Vector")));
+	}
+
+	if (!NIL_P(tmp = rb_hash_aref(options, rb_intern("list_class")))) {
+		rb_iv_set(self, "@list_class", tmp);
+	}
+	else {
+		rb_iv_set(self, "@list_class", rb_const_get(cClojure, rb_intern("Vector")));
+	}
+
+	if (!NIL_P(tmp = rb_hash_aref(options, rb_intern("set_class")))) {
+		rb_iv_set(self, "@set_class", tmp);
+	}
+	else {
+		rb_iv_set(self, "@set_class", rb_const_get(cClojure, rb_intern("Vector")));
+	}
+
+	return self;
+}
+
+static VALUE t_parse (VALUE self)
+{
+	VALUE source = rb_iv_get(self, "@source");
+
+	if (rb_obj_is_kind_of(source, rb_cString)) {
+		return string_parse(self);
+	}
+	else if (rb_obj_is_kind_of(source, rb_cIO)) {
+		return io_parse(self);
+	}
+}
+
+void
+Init_parser_ext (void)
+{
+	cClojure = rb_const_get(rb_cObject, rb_intern("Clojure"));
+	cParser  = rb_define_class_under(cClojure, "Parser", rb_cObject);
+
+	rb_define_method(cParser, "initialize", t_init, -1);
+	rb_define_method(cParser, "parse", t_parse, 0);
+
+	VALUE args[] = { Qnil };
+
+	args[0]       = rb_str_new2("[0-9|a-f|A-F]{4}");
+	UNICODE_REGEX = rb_class_new_instance(1, args, rb_cRegexp);
+	rb_define_const(cClojure, "UNICODE_REGEX", UNICODE_REGEX);
+
+	args[0]     = rb_str_new2("[0-3]?[0-7]?[0-7]");
+	OCTAL_REGEX = rb_class_new_instance(1, args, rb_cRegexp);
+	rb_define_const(cClojure, "OCTAL_REGEX", OCTAL_REGEX);
+}

data/ext/clj/string_parser.c

@@ -0,0 +1,460 @@
+/**
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *                    Version 2, December 2004
+ *
+ *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+ *   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+ *
+ *  0. You just DO WHAT THE FUCK YOU WANT TO.
+ **/
+
+#ifdef _INSIDE_PARSER
+#define IS_EOF (string[*position] == '\0')
+#define IS_EOF_AFTER(n) (string[*position + (n)] == '\0')
+#define CURRENT (string[*position])
+#define CURRENT_PTR (&string[*position])
+#define AFTER(n) (string[*position + (n)])
+#define AFTER_PTR(n) (&string[*position + (n)])
+#define BEFORE(n) (string[*position - (n)])
+#define BEFORE_PTR(n) (&string[*position - (n)])
+#define SEEK(n) (*position += (n))
+#define IS_IGNORED(ch) (isspace(ch) || ch == ',')
+#define IS_BOTH(ch) (ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\n' || ch == '\r' || ch == '\t')
+#define IS_KEYWORD(ch) (ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\'' || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == '\n' || ch == '\r' || ch == '\t')
+#define IS_NOT_EOF_UP_TO(n) (is_not_eof_up_to(string, position, n))
+#define IS_EQUAL_UP_TO(str, n) (strncmp(CURRENT_PTR, str, (n)) == 0)
+#define IS_EQUAL(str) IS_EQUAL_UP_TO(str, strlen(str))
+#define CALL(what) (what(self, string, position))
+
+static VALUE string_read_next (VALUE self, char* string, size_t* position);
+
+static inline bool is_not_eof_up_to (char* string, size_t* position, size_t n)
+{
+	for (size_t i = 0; i < n; i++) {
+		if (IS_EOF_AFTER(i)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static void string_ignore (VALUE self, char* string, size_t* position)
+{
+	while (!IS_EOF && IS_IGNORED(CURRENT)) {
+		SEEK(1);
+	}
+}
+
+static NodeType string_next_type (VALUE self, char* string, size_t* position)
+{
+	if (isdigit(CURRENT) || CURRENT == '-' || CURRENT == '+') {
+		return NODE_NUMBER;
+	}
+
+	switch (CURRENT) {
+		case '^':           return NODE_METADATA;
+		case 't': case 'f': return NODE_BOOLEAN;
+		case 'n':           return NODE_NIL;
+		case '\\':          return NODE_CHAR;
+		case ':':           return NODE_KEYWORD;
+		case '"':           return NODE_STRING;
+		case '{':           return NODE_MAP;
+		case '(':           return NODE_LIST;
+		case '[':           return NODE_VECTOR;
+	}
+
+	if (CURRENT == '#') {
+		if (IS_EOF_AFTER(1)) {
+			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		}
+
+		switch (AFTER(1)) {
+			case 'i': return NODE_INSTANT;
+			case '{': return NODE_SET;
+			case '"': return NODE_REGEXP;
+		}
+	}
+
+	rb_raise(rb_eSyntaxError, "unknown type");
+}
+
+static VALUE string_read_metadata (VALUE self, char* string, size_t* position)
+{
+	VALUE  result;
+	VALUE* metadatas = NULL;
+	size_t length    = 0;
+
+	while (CURRENT == '^') {
+		metadatas = realloc(metadatas, ++length * sizeof(VALUE));
+
+		SEEK(1);
+
+		metadatas[length - 1] = CALL(string_read_next);
+	}
+
+	result = CALL(string_read_next);
+
+	if (!rb_respond_to(result, rb_intern("metadata="))) {
+		free(metadatas);
+
+		rb_raise(rb_eSyntaxError, "the object cannot hold metadata");
+	}
+
+	// FIXME: this could lead to a memleak if #metadata= raises
+	for (size_t i = 0; i < length; i++) {
+		rb_funcall(result, rb_intern("metadata="), 1, metadatas[i]);
+	}
+
+	free(metadatas);
+
+	return result;
+}
+
+static VALUE string_read_nil (VALUE self, char* string, size_t* position)
+{
+	if (!IS_NOT_EOF_UP_TO(3)) {
+		rb_raise(rb_eSyntaxError, "unexpected EOF");
+	}
+
+	if (!IS_EQUAL_UP_TO("nil", 3)) {
+		rb_raise(rb_eSyntaxError, "expected nil, got n%c%c", AFTER(1), AFTER(2));
+	}
+
+	SEEK(3);
+
+	return Qnil;
+}
+
+static VALUE string_read_boolean (VALUE self, char* string, size_t* position)
+{
+	if (CURRENT == 't') {
+		if (!IS_NOT_EOF_UP_TO(4)) {
+			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		}
+
+		if (!IS_EQUAL_UP_TO("true", 4)) {
+			rb_raise(rb_eSyntaxError, "expected true, got t%c%c%c", AFTER(1), AFTER(2), AFTER(3));
+		}
+
+		SEEK(4);
+
+		return Qtrue;
+	}
+	else {
+		if (!IS_NOT_EOF_UP_TO(5)) {
+			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		}
+
+		if (!IS_EQUAL_UP_TO("false", 5)) {
+			rb_raise(rb_eSyntaxError, "expected false, got f%c%c%c%c", AFTER(1), AFTER(2), AFTER(3), AFTER(4));
+		}
+
+		SEEK(5);
+
+		return Qfalse;
+	}
+}
+
+static VALUE string_read_number (VALUE self, char* string, size_t* position)
+{
+	size_t length = 0;
+	VALUE  rbPiece;
+	char*  cPiece;
+	char*  tmp;
+
+	while (!IS_EOF_AFTER(length) && !IS_BOTH(AFTER(length))) {
+		length++;
+	}
+
+	SEEK(length);
+
+	rbPiece = rb_str_new(BEFORE_PTR(length), length);
+	cPiece  = StringValueCStr(rbPiece);
+
+	if (strchr(cPiece, '/')) {
+		return rb_funcall(rb_cObject, rb_intern("Rational"), 1, rbPiece);
+	}
+	else if ((tmp = strchr(cPiece, 'r')) || (tmp = strchr(cPiece, 'R'))) {
+		return rb_funcall(rb_str_new2(tmp + 1), rb_intern("to_i"), 1,
+			rb_funcall(rb_str_new(cPiece, tmp - cPiece), rb_intern("to_i"), 0));
+	}
+	else if (strchr(cPiece, '.') || strchr(cPiece, 'e') || strchr(cPiece, 'E') || cPiece[length - 1] == 'M') {
+		if (cPiece[length - 1] == 'M') {
+			return rb_funcall(rb_cObject, rb_intern("BigDecimal"), 1, rbPiece);
+		}
+		else {
+			return rb_funcall(rb_cObject, rb_intern("Float"), 1, rbPiece);
+		}
+	}
+	else {
+		if (cPiece[length - 1] == 'N') {
+			rb_str_set_len(rbPiece, length - 1);
+		}
+
+		return rb_funcall(rb_cObject, rb_intern("Integer"), 1, rbPiece);
+	}
+}
+
+static VALUE string_read_char (VALUE self, char* string, size_t* position)
+{
+	SEEK(1);
+
+	if (IS_EOF_AFTER(1) || IS_BOTH(AFTER(1))) {
+		SEEK(1); return rb_str_new(BEFORE_PTR(1), 1);
+	}
+	else if (IS_NOT_EOF_UP_TO(7) && IS_EQUAL_UP_TO("newline", 7) && (IS_EOF_AFTER(7) || IS_BOTH(AFTER(7)))) {
+		SEEK(7); return rb_str_new2("\n");
+	}
+	else if (IS_NOT_EOF_UP_TO(5) && IS_EQUAL_UP_TO("space", 5) && (IS_EOF_AFTER(5) || IS_BOTH(AFTER(5)))) {
+		SEEK(5); return rb_str_new2(" ");
+	}
+	else if (IS_NOT_EOF_UP_TO(3) && IS_EQUAL_UP_TO("tab", 3) && (IS_EOF_AFTER(3) || IS_BOTH(AFTER(3)))) {
+		SEEK(3); return rb_str_new2("\t");
+	}
+	else if (IS_NOT_EOF_UP_TO(9) && IS_EQUAL_UP_TO("backspace", 9) && (IS_EOF_AFTER(9) || IS_BOTH(AFTER(9)))) {
+		SEEK(9); return rb_str_new2("\b");
+	}
+	else if (IS_NOT_EOF_UP_TO(8) && IS_EQUAL_UP_TO("formfeed", 8) && (IS_EOF_AFTER(8) || IS_BOTH(AFTER(8)))) {
+		SEEK(8); return rb_str_new2("\f");
+	}
+	else if (IS_NOT_EOF_UP_TO(6) && IS_EQUAL_UP_TO("return", 6) && (IS_EOF_AFTER(6) || IS_BOTH(AFTER(6)))) {
+		SEEK(6); return rb_str_new2("\r");
+	}
+	else if (CURRENT == 'u' && IS_NOT_EOF_UP_TO(5) && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), 4), rb_intern("=~"), 1, UNICODE_REGEX)) && (IS_EOF_AFTER(5) || IS_BOTH(AFTER(5)))) {
+		SEEK(5); return rb_funcall(rb_ary_new3(1, rb_funcall(rb_str_new(BEFORE_PTR(4), 4), rb_intern("to_i"), 1, INT2FIX(16))),
+			rb_intern("pack"), 1, rb_str_new2("U"));
+	}
+	else if (CURRENT == 'o') {
+		size_t length = 1;
+
+		for (size_t i = 1; i < 5; i++) {
+			if (IS_EOF_AFTER(i) || IS_BOTH(AFTER(i))) {
+				break;
+			}
+
+			length++;
+		}
+
+		if (length > 1 && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), length - 1), rb_intern("=~"), 1, OCTAL_REGEX)) && (IS_EOF_AFTER(length) || IS_BOTH(AFTER(length)))) {
+			SEEK(length); return rb_funcall(rb_funcall(rb_str_new(BEFORE_PTR(length - 1), length - 1), rb_intern("to_i"), 1, INT2FIX(8)),
+				rb_intern("chr"), 0);
+		}
+	}
+
+	// TODO: add unicode and octal chars support
+
+	rb_raise(rb_eSyntaxError, "unknown character type");
+}
+
+static VALUE string_read_keyword (VALUE self, char* string, size_t* position)
+{
+	size_t length = 0;
+
+	SEEK(1);
+
+	while (!IS_EOF_AFTER(length) && !IS_KEYWORD(AFTER(length))) {
+		length++;
+	}
+
+	SEEK(length);
+
+	return rb_funcall(rb_str_new(BEFORE_PTR(length), length), rb_intern("to_sym"), 0);
+}
+
+static VALUE string_read_string (VALUE self, char* string, size_t* position)
+{
+	size_t length = 0;
+
+	SEEK(1);
+
+	while (AFTER(length) != '"') {
+		if (IS_EOF_AFTER(length)) {
+			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		}
+
+		if (AFTER(length) == '\\') {
+			length++;
+		}
+
+		length++;
+	}
+
+	SEEK(length + 1);
+
+	// TODO: make the escapes work properly
+
+	return rb_funcall(cClojure, rb_intern("unescape"), 1, rb_str_new(BEFORE_PTR(length + 1), length));
+}
+
+static VALUE string_read_regexp (VALUE self, char* string, size_t* position)
+{
+	size_t length = 0;
+	VALUE  args[] = { Qnil };
+
+	SEEK(2);
+
+	while (AFTER(length) != '"') {
+		if (IS_EOF_AFTER(length)) {
+			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		}
+
+		if (AFTER(length) == '\\') {
+			length++;
+		}
+
+		length++;
+	}
+
+	SEEK(length + 1);
+
+	args[0] = rb_str_new(BEFORE_PTR(length + 1), length);
+
+	return rb_class_new_instance(1, args, rb_cRegexp);
+}
+
+static VALUE string_read_instant (VALUE self, char* string, size_t* position)
+{
+	SEEK(1);
+
+	if (!IS_NOT_EOF_UP_TO(4)) {
+		rb_raise(rb_eSyntaxError, "unexpected EOF");
+	}
+
+	if (!IS_EQUAL_UP_TO("inst", 4)) {
+		rb_raise(rb_eSyntaxError, "expected inst, got %c%c%c%c", AFTER(0), AFTER(1), AFTER(2), AFTER(3));
+	}
+
+	SEEK(4);
+
+	CALL(string_ignore);
+
+	return rb_funcall(rb_const_get(rb_cObject, rb_intern("DateTime")), rb_intern("rfc3339"), 1, CALL(string_read_string));
+}
+
+static VALUE string_read_list (VALUE self, char* string, size_t* position)
+{
+	VALUE result = rb_class_new_instance(0, NULL, rb_iv_get(self, "@list_class"));
+
+	SEEK(1); CALL(string_ignore);
+
+	while (CURRENT != ')') {
+		rb_funcall(result, rb_intern("<<"), 1, CALL(string_read_next));
+
+		CALL(string_ignore);
+	}
+
+	SEEK(1);
+
+	return result;
+}
+
+static VALUE string_read_vector (VALUE self, char* string, size_t* position)
+{
+	VALUE result = rb_class_new_instance(0, NULL, rb_iv_get(self, "@vector_class"));
+
+	SEEK(1); CALL(string_ignore);
+
+	while (CURRENT != ']') {
+		rb_funcall(result, rb_intern("<<"), 1, CALL(string_read_next));
+
+		CALL(string_ignore);
+	}
+
+	SEEK(1);
+
+	return result;
+}
+
+static VALUE string_read_set (VALUE self, char* string, size_t* position)
+{
+	VALUE result = rb_class_new_instance(0, NULL, rb_iv_get(self, "@set_class"));
+
+	SEEK(2); CALL(string_ignore);
+
+	while (CURRENT != '}') {
+		rb_funcall(result, rb_intern("<<"), 1, CALL(string_read_next));
+
+		CALL(string_ignore);
+	}
+
+	SEEK(1);
+
+	if (!NIL_P(rb_funcall(result, rb_intern("uniq!"), 0))) {
+		rb_raise(rb_eSyntaxError, "the set contains non unique values");
+	}
+
+	return result;
+}
+
+static VALUE string_read_map (VALUE self, char* string, size_t* position)
+{
+	VALUE result = rb_class_new_instance(0, NULL, rb_iv_get(self, "@map_class"));
+	VALUE key;
+	VALUE value;
+
+	SEEK(1); CALL(string_ignore);
+
+	while (CURRENT != '}') {
+		key = CALL(string_read_next);
+		CALL(string_ignore);
+		value = CALL(string_read_next);
+
+		rb_funcall(result, rb_intern("[]="), 2, key, value);
+	}
+
+	SEEK(1);
+
+	return result;
+}
+
+static VALUE string_read_next (VALUE self, char* string, size_t* position)
+{
+	CALL(string_ignore);
+
+	if (IS_EOF) {
+		rb_raise(rb_eSyntaxError, "unexpected EOF");
+	}
+
+	switch (CALL(string_next_type)) {
+		case NODE_METADATA: return CALL(string_read_metadata);
+		case NODE_NUMBER:   return CALL(string_read_number);
+		case NODE_BOOLEAN:  return CALL(string_read_boolean);
+		case NODE_NIL:      return CALL(string_read_nil);
+		case NODE_CHAR:     return CALL(string_read_char);
+		case NODE_KEYWORD:  return CALL(string_read_keyword);
+		case NODE_STRING:   return CALL(string_read_string);
+		case NODE_MAP:      return CALL(string_read_map);
+		case NODE_LIST:     return CALL(string_read_list);
+		case NODE_VECTOR:   return CALL(string_read_vector);
+		case NODE_INSTANT:  return CALL(string_read_instant);
+		case NODE_SET:      return CALL(string_read_set);
+		case NODE_REGEXP:   return CALL(string_read_regexp);
+	}
+}
+
+static VALUE string_parse (VALUE self)
+{
+	size_t position = 0;
+	VALUE  source   = rb_iv_get(self, "@source");
+
+	return string_read_next(self, StringValueCStr(source), &position);
+}
+
+#undef IS_EOF
+#undef IS_EOF_AFTER
+#undef CURRENT
+#undef CURRENT_PTR
+#undef AFTER
+#undef AFTER_PTR
+#undef BEFORE
+#undef BEFORE_PTR
+#undef SEEK
+#undef IS_IGNORED
+#undef IS_BOTH
+#undef IS_KEYWORD
+#undef IS_NOT_EOF_UP_TO
+#undef IS_EQUAL_UP_TO
+#undef IS_EQUAL
+#undef CALL
+#endif

data/lib/clj.rb

@@ -11,10 +11,7 @@
 require 'date'
 require 'bigdecimal'
 
-require 'clj/parser'
-require 'clj/types'
-
-class Clojure
+module Clojure
 	def self.parse (*args)
 		Clojure::Parser.new(*args).parse
 	end
@@ -24,4 +21,59 @@ class Clojure
 
 		what.to_clj(options)
 	end
+
+	UNESCAPE_REGEX = %r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n
+
+	# Unescape characters in strings.
+	UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+	UNESCAPE_MAP.merge!(
+		?"  => '"',
+		?\\ => '\\',
+		?/  => '/',
+		?b  => "\b",
+		?f  => "\f",
+		?n  => "\n",
+		?r  => "\r",
+		?t  => "\t",
+		?u  => nil
+	)
+
+	EMPTY_8BIT_STRING = ''
+
+	if EMPTY_8BIT_STRING.respond_to? :force_encoding
+		EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+	end
+
+	def self.unescape (string)
+		string.gsub(UNESCAPE_REGEX) {|escape|
+			if u = UNESCAPE_MAP[$&[1]]
+				next u
+			end
+
+			bytes = EMPTY_8BIT_STRING.dup
+
+			i = 0
+			while escape[6 * i] == ?\\ && escape[6 * i + 1] == ?u
+				bytes << escape[6 * i + 2, 2].to_i(16) << escape[6 * i + 4, 2].to_i(16)
+
+				i += 1
+			end
+
+			if bytes.respond_to? :force_encoding
+				bytes.force_encoding 'UTF-16be'
+				bytes.encode 'UTF-8'
+			else
+				bytes
+			end
+		}
+
+	end
+end
+
+require 'clj/types'
+
+if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+	require 'clj/parser_ext'
+else
+	require 'clj/parser'
 end

data/lib/clj/parser.rb

@@ -10,43 +10,22 @@
 
 require 'stringio'
 
-class Clojure
+module Clojure
 
 class Parser
 	NUMBERS = '0' .. '9'
 
-	STRING_REGEX  = %r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n
-	UNICODE_REGEX = /u([0-9|a-f|A-F]{4})/
-	OCTAL_REGEX   = /o([0-3][0-7]?[0-7]?)/
-
-	# Unescape characters in strings.
-	UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
-	UNESCAPE_MAP.merge!(
-		?"  => '"',
-		?\\ => '\\',
-		?/  => '/',
-		?b  => "\b",
-		?f  => "\f",
-		?n  => "\n",
-		?r  => "\r",
-		?t  => "\t",
-		?u  => nil
-	)
-
-	EMPTY_8BIT_STRING = ''
-
-	if EMPTY_8BIT_STRING.respond_to? :force_encoding
-		EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
-	end
+	UNICODE_REGEX = /[0-9|a-f|A-F]{4}/
+	OCTAL_REGEX   = /[0-3]?[0-7]?[0-7]/
 
 	def initialize (source, options = {})
 		@source  = source.is_a?(String) ? StringIO.new(source) : source
 		@options = options
 
-		@map_class    = options[:map_class]    || Hash
-		@vector_class = options[:vector_class] || Array
-		@list_class   = options[:list_class]   || Array
-		@set_class    = options[:set_class]    || Array
+		@map_class    = options[:map_class]    || Clojure::Map
+		@vector_class = options[:vector_class] || Clojure::Vector
+		@list_class   = options[:list_class]   || Clojure::List
+		@set_class    = options[:set_class]    || Clojure::Set
 	end
 
 	def parse
@@ -56,6 +35,7 @@ class Parser
 private
 	def next_type (ch)
 		case ch
+		when '^'               then :metadata
 		when NUMBERS, '-', '+' then :number
 		when 't', 'f'          then :boolean
 		when 'n'               then :nil
@@ -82,6 +62,26 @@ private
 		__send__ "read_#{next_type ch}", ch
 	end
 
+	def read_metadata (ch)
+		metadatas = [read_next]
+
+		while lookahead(1) == '^'
+			raise SyntaxError, 'unexpected EOF' unless @source.read(1)
+
+			metadatas.push(read_next)
+		end
+
+		value = read_next
+
+		unless value.respond_to? :metadata=
+			raise SyntaxError, 'the object cannot hold metadata'
+		end
+
+		metadatas.each { |m| value.metadata = m }
+
+		value
+	end
+
 	def read_nil (ch)
 		check = @source.read(2)
 
@@ -135,8 +135,6 @@ private
 			number.to_i(base.to_i)
 		elsif piece.include? '.' or piece.include? 'e' or piece.include? 'E' or piece.end_with? 'M'
 			if piece.end_with? 'M'
-				piece[-1] = ''
-
 				BigDecimal(piece)
 			else
 				Float(piece)
@@ -165,13 +163,15 @@ private
 			@source.read(8) and "\f"
 		elsif (ahead = lookahead(7)) && ahead[0, 6] == 'return' && (!ahead[6] || both?(ahead[6]))
 			@source.read(6) and "\r"
-		elsif (ahead = lookahead(6)) && ahead[0, 5] =~ UNICODE_REGEX && (!ahead[5] || both?(ahead[5]))
+		elsif (ahead = lookahead(6)) && ahead[0] == 'u' && ahead[1, 5] =~ UNICODE_REGEX && (!ahead[5] || both?(ahead[5]))
 			[@source.read(5)[1, 4].to_i(16)].pack('U')
-		elsif (ahead = lookahead(5)) && ahead[0, 4] =~ OCTAL_REGEX && (!ahead[4] || both?(ahead[4]))
-			@source.read(4)[1, 3].to_i(8).chr
-		else
-			raise SyntaxError, 'unknown character type'
-		end
+		elsif (ahead = lookahead(5)) && ahead[0] == 'o' && matches = ahead[1, 3].match(OCTAL_REGEX)
+			length = matches[0].length + 1
+
+			if !ahead[length] || both?(ahead[length])
+				@source.read(length)[1, 3].to_i(8).chr
+			end
+		end or raise SyntaxError, 'unknown character type'
 	end
 
 	def read_keyword (ch)
@@ -199,31 +199,17 @@ private
 			end
 		end
 
-		result.gsub(STRING_REGEX) {|escape|
-			if u = UNESCAPE_MAP[$&[1]]
-				next u
-			end
-
-			bytes = EMPTY_8BIT_STRING.dup
-
-			i = 0
-			while escape[6 * i] == ?\\ && escape[6 * i + 1] == ?u
-				bytes << escape[6 * i + 2, 2].to_i(16) << escape[6 * i + 4, 2].to_i(16)
-
-				i += 1
-			end
-
-			if bytes.respond_to? :force_encoding
-				bytes.force_encoding 'UTF-16be'
-				bytes.encode 'UTF-8'
-			else
-				bytes
-			end
-		}
+		Clojure.unescape(result)
 	end
 
 	def read_instant (ch)
-		@source.read(3)
+		check = @source.read(3)
+
+		if check.length != 3
+			raise SyntaxError, 'unexpected EOF'
+		elsif check != 'nst'
+			raise SyntaxError, "expected inst, found i#{check}"
+		end
 
 		DateTime.rfc3339(read_string(ignore(false)))
 	end
@@ -311,14 +297,12 @@ private
 		result
 	end
 
-	def unescape (string)
-		string
-	end
-
 	def lookahead (length)
 		result = @source.read(length)
 
-		@source.seek(-result.length, IO::SEEK_CUR)
+		if result
+			@source.seek(-result.length, IO::SEEK_CUR)
+		end
 
 		result
 	end
@@ -334,27 +318,15 @@ private
 	end
 
 	def ignore? (ch)
-		if ch == ' ' || ch == ',' || ch == "\n" || ch == "\r" || ch == "\t"
-			true
-		else
-			false
-		end
+		ch == ' ' || ch == ',' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 
 	def both? (ch)
-		if ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "\n" || ch == "\r" || ch == "\t"
-			true
-		else
-			false
-		end
+		ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 
 	def keyword? (ch)
-		if ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "'" || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == "\n" || ch == "\r" || ch == "\t"
-			true
-		else
-			false
-		end
+		ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "'" || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 end
 

data/lib/clj/types.rb

@@ -8,6 +8,73 @@
 #  0. You just DO WHAT THE FUCK YOU WANT TO.
 #++
 
+module Clojure
+	module Metadata
+		def metadata
+			@metadata ||= Clojure::Map.new
+		end
+
+		def metadata= (value)
+			metadata.merge! case value
+				when Hash   then value
+				when Symbol then { value => true }
+				when String then { :tag => value }
+				else raise ArgumentError, 'the passed value is not suitable as metadata'
+			end
+		end
+
+		def metadata_to_clj (options = {})
+			return '' unless options[:metadata] != false && @metadata && !@metadata.empty?
+
+			'^' + if @metadata.length == 1
+				piece = @metadata.first
+
+				if piece.first.is_a?(Symbol) && piece.last == true
+					piece.first.to_clj(options)
+				elsif piece.first == :tag && piece.last.is_a?(String)
+					piece.last.to_clj(options)
+				else
+					@metadata.to_clj(options)
+				end
+			else
+				@metadata.to_clj(options)
+			end + ' '
+		end
+	end
+
+	class Map < Hash
+		include Clojure::Metadata
+
+		def to_clj (options = {})
+			metadata_to_clj(options) + '{' + map { |k, v| k.to_clj(options) + ' ' + v.to_clj(options) }.join(' ') + '}'
+		end
+	end
+
+	class Vector < Array
+		include Clojure::Metadata
+
+		def to_clj (options = {})
+			metadata_to_clj(options) + '[' + map { |o| o.to_clj(options) }.join(' ') + ']'
+		end
+	end
+
+	class List < Array
+		include Clojure::Metadata
+
+		def to_clj (options = {})
+			metadata_to_clj(options) + '(' + map { |o| o.to_clj(options) }.join(' ') + ')'
+		end
+	end
+
+	class Set < Array
+		include Clojure::Metadata
+
+		def to_clj (options = {})
+			metadata_to_clj(options) + '#{' + uniq.map { |o| o.to_clj(options) }.join(' ') + '}'
+		end
+	end
+end
+
 [Numeric, TrueClass, FalseClass, NilClass].each {|klass|
 	klass.instance_eval {
 		define_method :to_clj do |*|
@@ -57,11 +124,7 @@ end
 
 class DateTime
 	def to_clj (options = {})
-		if options[:alpha]
-			'#inst "' + rfc3339 + '"'
-		else
-			to_time.to_i.to_s
-		end
+		options[:alpha] ? '#inst "' + rfc3339 + '"' : to_time.to_i.to_s
 	end
 end
 
@@ -91,12 +154,28 @@ end
 
 class Array
 	def to_clj (options = {})
-		'[' + map { |o| o.to_clj(options) }.join(' ') + ']'
+		to_vector.to_clj(options)
+	end
+
+	def to_set
+		Clojure::Set.new(self)
+	end
+
+	def to_vector
+		Clojure::Vector.new(self)
+	end
+
+	def to_list
+		Clojure::List.new(self)
 	end
 end
 
 class Hash
 	def to_clj (options = {})
-		'{' + map { |k, v| k.to_clj(options) + ' ' + v.to_clj(options) }.join(' ') + '}'
+		to_map.to_clj(options)
+	end
+
+	def to_map
+		Clojure::Map[self]
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clj
 version: !ruby/object:Gem::Version
-  version: 0.0.5.6
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-16 00:00:00.000000000 Z
+date: 2012-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &4605840 !ruby/object:Gem::Requirement
+  requirement: &12555040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *4605840
+  version_requirements: *12555040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &4605160 !ruby/object:Gem::Requirement
+  requirement: &12553860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,13 +32,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *4605160
+  version_requirements: *12553860
 description: 
 email: meh@paranoici.org
 executables: []
-extensions: []
+extensions:
+- ext/clj/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/clj/parser.c
+- ext/clj/io_parser.c
+- ext/clj/string_parser.c
+- ext/clj/extconf.rb
 - lib/clj.rb
 - lib/clj/types.rb
 - lib/clj/parser.rb
@@ -62,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: Like json, but with clojure sexps.