metal 0.0.2 → 0.0.3

data/ext/metal/boot/metal_boot_extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+
+begin
+	CXX_EXT << 'mm' unless CXX_EXT.include?('mm')
+rescue
+end
+
+dir_config('metal')
+
+$CFLAGS << " -I. -I../../../include/ -Wall -g"
+$libs << " -lobjc"
+
+$objs = %w[metal_boot.o  metal_boot_rb.o]
+$srcs = %w[metal_boot.mm metal_boot_rb.mm]
+
+create_makefile('metal_boot')

data/ext/metal/boot/metal_boot_rb.mm

@@ -0,0 +1,20 @@
+#import "ruby.h"
+#import "metal/rbcode.h"
+#import "metal_boot.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void Init_metal_boot() {
+VALUE mMetal = rb_define_module("Metal");
+VALUE cBase = rb_define_class_under(mMetal, "ParserBase", rb_cObject);
+VALUE code;
+{
+VALUE cMetalParser = rb_define_class("MetalParser", cBase);
+rb_define_method(cMetalParser, "parse", (VALUE (*)(ANYARGS))(VALUE (*)(VALUE,VALUE))&Metal::parse_method_template<MetalParser>, 1);
+code = rb_str_new(" include Metal::Generator ",26);
+rb_mod_module_eval(1,&code,cMetalParser);
+}
+}
+#ifdef __cplusplus
+}
+#endif

data/ext/metal/runtime/extconf.rb

@@ -0,0 +1,35 @@
+require 'mkmf'
+
+begin
+	CXX_EXT << 'mm' unless CXX_EXT.include?('mm')
+rescue
+end
+
+dir_config('oniguruma')
+dir_config('metal')
+
+$CFLAGS << " -I. -I../../../include -Wall -g"
+
+if have_library('objc', 'objc_msgSend')
+	$CFLAGS << " -DOBJC_APPLE"
+elsif have_library('objc', 'objc_msg_lookup')
+	$CFLAGS << " -DOBJC_GNU"
+else
+	raise "Objective-C library is needed."
+end
+
+unless have_library('stdc++')
+	raise "Standard C++ library is needed."
+end
+
+if RUBY_VERSION < "1.9.0"
+	unless have_library('onig')
+		raise "Oniguruma library is needed."
+	end
+end
+
+$objs = %w[input.o  runtime.o  rbinit.o]
+$srcs = %w[input.mm runtime.mm rbinit.mm]
+
+create_makefile('metal_runtime')
+

data/ext/metal/runtime/input.mm

@@ -0,0 +1,99 @@
+/*
+ * Metal Buffered Input
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#import "metal/input.h"
+#import "metal/runtime.h"
+#import <stdexcept>
+
+namespace Metal {
+
+
+static const unsigned UTF8_CHARLEN_TABLE[] = {
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1, // 0x00
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,	1, 1, 1, 1, 1, 1, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0, 0, 0, // 0x80
+	0, 0, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,	0, 0, 0, 0, 0, 0, 0, 0,
+	2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2, // 0xc0
+	2, 2, 2, 2, 2, 2, 2, 2,	2, 2, 2, 2, 2, 2, 2, 2,
+	3, 3, 3, 3, 3, 3, 3, 3,	3, 3, 3, 3, 3, 3, 3, 3, // 0xe0
+	4, 4, 4, 4, 4, 4, 4, 4,	5, 5, 5, 5, 6, 6, 0, 0  // 0xf0
+};
+
+
+BufferedInput::BufferedInput(const char* src, size_t len) :
+	m_cur(0), m_pos(src), m_endpos(m_pos+len)
+{ }
+
+BufferedInput::~BufferedInput() {}
+
+BufferedInput::at_t BufferedInput::at(size_t pos)
+{
+	ssize_t dist = pos - m_cur;
+	if(dist == 0) {
+		// do nothing
+		return at_t(m_pos, charlen());
+//	} else if(dist == 1) {
+//		while(true) {
+//			++m_pos;
+//			if(m_pos == m_endpos) { prev(); return at_t(NULL, 0); }
+//			if(charlen() != 0) { break; }
+//		}
+//		++m_cur;
+//		return at_t(m_pos, charlen());
+	} else if(dist > 0) {
+		for(size_t i=0; i < (size_t)dist; ++i) {
+			while(true) {
+				++m_pos;
+				if(m_pos == m_endpos) { prev(); return at_t(NULL, 0); }
+				if(charlen() != 0) { break; }
+			}
+		}
+		m_cur += dist;
+		return at_t(m_pos, charlen());
+	} else {  // dist < 0
+		for(size_t i=-dist; i > 0; --i) {
+			prev();
+		}
+		m_cur += dist;
+		return at_t(m_pos, charlen());
+	}
+}
+
+void BufferedInput::prev()
+{
+	do {
+		--m_pos;
+	} while(charlen() == 0);
+}
+
+unsigned BufferedInput::charlen()
+{
+	return UTF8_CHARLEN_TABLE[(unsigned char)*m_pos];
+}
+
+
+}  // namespace Metal
+

data/ext/metal/runtime/rbinit.mm

@@ -0,0 +1,17 @@
+#import "ruby.h"
+#import "metal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Init_metal_runtime()
+{
+	VALUE mMetal = rb_define_module("Metal");
+	rb_define_class_under(mMetal, "ParserBase", rb_cObject);
+}
+
+#ifdef __cplusplus
+}
+#endif
+

data/ext/metal/runtime/runtime.mm

@@ -0,0 +1,660 @@
+/*
+ * Metal Runtime
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#import "metal.h"
+#import <iostream>
+#import <sstream>
+#import <vector>
+#import <string.h>
+#import <oniguruma.h>
+
+#ifdef OBJC_APPLE
+#else
+#import <objc/objc-api.h>
+#endif
+
+namespace Metal {
+
+
+class ContextIMPL {
+public:
+	ContextIMPL(id instance, VALUE rb_instance, Input& input);
+	~ContextIMPL();
+
+public:
+	inline VALUE apply(SEL method, Context* ctx);
+
+	inline VALUE act_or(Lambda** blocks);
+	inline VALUE act_many(Lambda* block);
+	inline VALUE act_many1(Lambda* block);
+	inline VALUE act_may(Lambda* block);
+	inline VALUE act_not(Lambda* block);
+	inline VALUE act_lookahead(Lambda* block);
+	inline VALUE act_char(const char* c, unsigned clen);
+	inline VALUE act_token(const char* s, unsigned slen);
+	inline VALUE act_any();
+	inline VALUE act_charclass(const char* s, unsigned slen);
+
+	inline VALUE act_run(Env& env, const char* code, unsigned code_len);
+	inline VALUE act_where(Env& env, const char* code, unsigned code_len);
+
+	inline VALUE act_end();
+
+private:
+	void next_char();
+
+private:
+	typedef size_t index_t;
+	index_t m_index;
+	Input& m_input;
+
+	id m_instance;
+	VALUE m_rb_instance;
+	std::string m_env_tmp_name;
+
+	// current character
+	const char* m_ccur;
+	unsigned m_ccur_len;
+
+public:
+	class Backtrack;
+
+private:
+	class ErrorMessage;
+#ifdef __GNUC__
+	void backtrack(const std::string& msg) __attribute__((noreturn));
+#else
+	void backtrack(const std::string& msg);
+#endif
+	friend class ErrorMessage;
+
+	static inline ContextIMPL& impl(Context& ctx)
+		{ return *ctx.m_impl; }
+
+	typedef std::vector<SEL> call_stack_t;
+	call_stack_t m_call_stack;
+
+	typedef std::vector<ErrorMessage*> error_history_t;
+	error_history_t m_error_history;
+
+	void clear_history();
+
+private:
+	ContextIMPL(const ContextIMPL&);
+	ContextIMPL();
+};
+
+
+class ContextIMPL::ErrorMessage {
+public:
+	ErrorMessage(const std::string& msg,
+			size_t index, call_stack_t& call_stack) :
+		m_message(msg),
+		m_index(index),
+		m_call_stack(call_stack)
+	{ }
+	~ErrorMessage() {}
+public:
+	void message(std::ostream& stream, Context& ctx)
+	{
+		ContextIMPL& ctx_impl( ContextIMPL::impl(ctx) );
+		for(error_history_t::iterator it(ctx_impl.m_error_history.begin()),
+				it_end(ctx_impl.m_error_history.end());
+				it != it_end; ++it) {
+			(*it)->format(stream, ctx_impl);
+		}
+	}
+private:
+	void format(std::ostream& stream, ContextIMPL& ctx_impl)
+	{
+		stream << "\n  ";
+		for(call_stack_t::iterator it(m_call_stack.begin()),
+				it_end(m_call_stack.end());
+				it != it_end; ++it) {
+#ifdef OBJC_APPLE
+			const char* name = sel_getName(*it) + strlen("rule_");
+#else
+			const char* name = sel_get_name(*it) + strlen("rule_");
+#endif
+			size_t len = strlen(name);
+			stream.write(name, len-1);   // rule_end:
+			stream << "> ";
+		}
+		stream << "\n      at index " << m_index << "  " << m_message;
+	}
+
+private:
+	const std::string m_message;
+	size_t m_index;
+	call_stack_t m_call_stack;
+private:
+	ErrorMessage();
+	ErrorMessage(const ErrorMessage&);
+};
+
+
+class ContextIMPL::Backtrack {
+public:
+	Backtrack(ErrorMessage* message) :
+		m_message(message) { }
+public:
+	inline std::string message(Context& ctx)
+	{
+		std::ostringstream stream;
+		stream << "parse error:";
+		m_message->message(stream, ctx);
+		return stream.str();
+	}
+private:
+	ErrorMessage* m_message;
+private:
+	Backtrack();
+};
+
+
+
+class EnvIMPL {
+public:
+	EnvIMPL() {}
+	~EnvIMPL() {}
+public:
+	inline VALUE& operator[](param_t key);
+	inline size_t size() const { return m_table.size(); }
+	inline bool empty() const { return m_table.empty(); }
+private:
+	typedef std::vector< std::pair<param_t,VALUE> > table_t;
+	table_t m_table;
+public:
+	typedef table_t::iterator iterator;
+	inline iterator begin() { return m_table.begin(); }
+	inline iterator end()   { return m_table.end();   }
+private:
+	static inline EnvIMPL& impl(Env& env)
+		{ return *env.m_impl; }
+	friend class ContextIMPL;
+private:
+	static void gc_mark(EnvIMPL* impl);
+	friend class Env;
+};
+
+Env::Env() :
+	m_impl( new EnvIMPL() )
+{
+	m_gc_marker = Data_Wrap_Struct(
+			0, (void (*)(void*))&EnvIMPL::gc_mark,
+			NULL, m_impl
+			);
+}
+
+Env::~Env() {
+	RDATA(m_gc_marker)->dmark = 0;
+	delete m_impl;
+}
+
+VALUE& Env::operator[](param_t key)
+	{ return m_impl->operator[](key); }
+VALUE& EnvIMPL::operator[](param_t key)
+{
+	for(table_t::iterator it(m_table.begin()),
+			it_end(m_table.end());
+			it != it_end; ++it) {
+		if(it->first == key) {
+			return it->second;
+		}
+	}
+	m_table.push_back( table_t::value_type(key,Qnil) );
+	return m_table.back().second;
+}
+
+void EnvIMPL::gc_mark(EnvIMPL* impl)
+{
+	for(table_t::iterator it(impl->m_table.begin()),
+			it_end(impl->m_table.end());
+			it != it_end; ++it) {
+		rb_gc_mark(it->second);
+	}
+}
+
+
+
+Context::Context(id instance, VALUE rb_instance, Input& input) :
+		m_impl( new ContextIMPL(instance, rb_instance, input) )
+{ }
+
+Context::~Context()
+{
+	delete m_impl;
+}
+
+static const char*  ENV_TMP_NAME_PREFIX = "@metal_env";
+
+ContextIMPL::ContextIMPL(id instance, VALUE rb_instance, Input& input) :
+	m_index(0),
+	m_input(input),
+	m_instance(instance),
+	m_rb_instance(rb_instance)
+{
+	// FIXME
+	std::ostringstream stream;
+	stream << ENV_TMP_NAME_PREFIX;
+	stream << (unsigned long)FIX2ULONG( rb_obj_id(rb_instance) );
+	m_env_tmp_name = stream.str();
+}
+
+ContextIMPL::~ContextIMPL()
+{
+	clear_history();
+}
+
+
+VALUE Context::apply(SEL method)
+	{ return m_impl->apply(method, this); }
+VALUE ContextIMPL::apply(SEL method, Context* ctx)
+{
+	m_call_stack.push_back(method);
+	VALUE ret;
+	try {
+#ifdef OBJC_APPLE
+		ret = (VALUE)objc_msgSend(m_instance, method, ctx);
+#else
+		IMP imp = objc_msg_lookup(m_instance, method);
+		ret = (VALUE)(*imp)(m_instance, method, ctx);
+#endif
+	} catch (...) {
+		m_call_stack.pop_back();
+		throw;
+	}
+	m_call_stack.pop_back();
+	return ret;
+}
+
+
+VALUE Context::act_or(Lambda** blocks)
+	{ return m_impl->act_or(blocks); }
+VALUE ContextIMPL::act_or(Lambda** blocks)
+{
+	index_t pos = m_index;
+	do {
+		try {
+			VALUE ret = (*blocks)->call();
+			return ret;
+		} catch (Backtrack& e) {
+			m_index = pos;
+		}
+		++blocks;
+	} while(*blocks != NULL);
+	backtrack("or failed");
+}
+
+VALUE Context::act_many(Lambda* block)
+	{ return m_impl->act_many(block); }
+VALUE ContextIMPL::act_many(Lambda* block)
+{
+	VALUE ret = rb_ary_new();
+	while(true) {
+		index_t pos = m_index;
+		try {
+			rb_ary_push(ret, block->call());
+			if(pos == m_index) { return ret; }  // XXX many in many avoidance
+		} catch (Backtrack& e) {
+			m_index = pos;
+			return ret;
+		}
+	}
+}
+
+VALUE Context::act_many1(Lambda* block)
+	{ return m_impl->act_many1(block); }
+VALUE ContextIMPL::act_many1(Lambda* block)
+{
+	VALUE ret = rb_ary_new();
+	while(true) {
+		index_t pos = m_index;
+		try {
+			rb_ary_push(ret, block->call());
+			if(pos == m_index) { return ret; }  // XXX many in many avoidance
+		} catch(Backtrack& e) {
+			m_index = pos;
+			if(RARRAY_LEN(ret) == 0) { throw; }
+			return ret;
+		}
+	}
+}
+
+VALUE Context::act_may(Lambda* block)
+	{ return m_impl->act_may(block); }
+VALUE ContextIMPL::act_may(Lambda* block)
+{
+	index_t pos = m_index;
+	try {
+		return block->call();
+	} catch(Backtrack& e) {
+		m_index = pos;
+		return Qnil;
+	}
+}
+
+VALUE Context::act_not(Lambda* block)
+	{ return m_impl->act_not(block); }
+VALUE ContextIMPL::act_not(Lambda* block)
+{
+	index_t pos = m_index;
+	bool ok;
+	try {
+		block->call();
+		ok = false;
+	} catch(Backtrack& e) {
+		ok = true;
+	}
+	m_index = pos;
+	if(!ok) {
+		backtrack("not prediction failed");
+	}
+	return Qnil;
+}
+
+VALUE Context::act_lookahead(Lambda* block)
+	{ return m_impl->act_lookahead(block); }
+VALUE ContextIMPL::act_lookahead(Lambda* block)
+{
+	index_t pos = m_index;
+	try {
+		VALUE ret = block->call();
+		m_index = pos;
+		return ret;
+	} catch(Backtrack& e) {
+		m_index = pos;
+		throw;
+	}
+}
+
+
+VALUE Context::act_char(const char* c, unsigned clen)
+	{ return m_impl->act_char(c, clen); }
+VALUE ContextIMPL::act_char(const char* c, unsigned clen)
+{
+	index_t pos = m_index;
+	next_char();
+	if(!( m_ccur_len==clen && memcmp(m_ccur,c,clen)==0 )) {
+		m_index = pos;
+		backtrack("act_char failed");
+	}
+	return rb_str_new(c, clen);
+}
+
+VALUE Context::act_token(const char* s, unsigned slen)
+	{ return m_impl->act_token(s, slen); }
+VALUE ContextIMPL::act_token(const char* s, unsigned slen)
+{
+	index_t pos = m_index;
+	const char* c = s;
+	unsigned left = slen;
+	while(true) {
+		try {
+			next_char();
+		} catch(Backtrack& e) {
+			break;
+		}
+		if(!( m_ccur_len <= left && memcmp(m_ccur,c,m_ccur_len)==0 )) {
+			break;
+		}
+		left -= m_ccur_len;
+		if(left == 0) { return rb_str_new(s, slen); }
+		c += m_ccur_len;
+	}
+	m_index = pos;
+	backtrack("act_token failed");
+}
+
+VALUE Context::act_any()
+	{ return m_impl->act_any(); }
+VALUE ContextIMPL::act_any()
+{
+	next_char();
+	return rb_str_new(m_ccur, m_ccur_len);
+}
+
+
+VALUE Context::act_charclass(const char* s, unsigned slen)
+	{ return m_impl->act_charclass(s, slen); }
+VALUE ContextIMPL::act_charclass(const char* s, unsigned slen)
+{
+	// FIXME regexp precompile
+	index_t pos = m_index;
+
+	next_char();
+
+	regex_t* reg;
+	onig_new(&reg,
+			(const OnigUChar*)s, (const OnigUChar*)s+slen,
+			ONIG_OPTION_MULTILINE, ONIG_ENCODING_UTF8,
+			ONIG_SYNTAX_RUBY, NULL);
+	int ret = onig_match(reg,
+			(const OnigUChar*)m_ccur,
+			(const OnigUChar*)m_ccur+m_ccur_len,
+			(const OnigUChar*)m_ccur,
+			NULL, 0);
+	onig_free(reg);
+
+	if(ret < 0) {
+		m_index = pos;
+		backtrack("act_charclass failed");
+	} else {
+		return rb_str_new(m_ccur, m_ccur_len);
+	}
+}
+
+static VALUE act_run_eval(VALUE ary)
+{
+	VALUE rbcode = rb_ary_entry(ary, 0);
+	VALUE klass  = rb_ary_entry(ary, 1);
+	return rb_mod_module_eval(1, &rbcode, klass);
+}
+
+static VALUE act_run_rescue(VALUE rbcode) {
+	// FIXME
+	throw std::runtime_error( STR2CSTR(rb_eval_string("$!")) );
+}
+
+VALUE Context::act_run(Env& env, const char* code, unsigned code_len)
+	{ return m_impl->act_run(env, code, code_len); }
+VALUE ContextIMPL::act_run(Env& env, const char* code, unsigned code_len)
+{
+	// instance variable -> local variable
+	EnvIMPL& env_impl( EnvIMPL::impl(env) );
+	
+	VALUE rbcode;
+	VALUE klass = CLASS_OF(m_rb_instance);
+
+	if(env_impl.empty()) {
+		rbcode = rb_str_new(code, code_len);
+
+	} else {
+		// args = [a_value, b_value]
+		// ParserClass.instance_variable_set(env_name, args)
+		// begin
+		//   ParserClass.instance_eval("a,b,=#{env_name}; #{code}")
+		// ensure
+		//   ParserClass.instance_variable_set(env_name, Qnil)
+		// end
+
+		VALUE args = rb_ary_new2(env_impl.size());
+		rbcode = rb_str_buf_new(
+				env_impl.size()*4 + m_env_tmp_name.length() + code_len
+				);  // FIXME
+
+		for(EnvIMPL::iterator it(env_impl.begin()),
+				it_end(env_impl.end());
+				it != it_end; ++it) {
+			long itlen = strlen(it->first);
+			rb_ary_push(args, it->second);
+			rb_str_buf_cat(rbcode, it->first, itlen);
+			rb_str_buf_cat(rbcode, ",", 1);
+		}
+		rb_str_buf_cat(rbcode, "=", 1);
+		rb_str_buf_cat(rbcode, m_env_tmp_name.c_str(), m_env_tmp_name.length());
+		rb_str_buf_cat(rbcode, ";", 1);
+		rb_str_buf_cat(rbcode, code, code_len);
+	
+		rb_iv_set(klass, m_env_tmp_name.c_str(), args);
+	}
+	
+	VALUE ary = rb_ary_new2(2);
+	rb_ary_push(ary, rbcode);
+	rb_ary_push(ary, klass);
+	
+	VALUE ret;
+	try {
+		ret = rb_rescue((VALUE(*)(ANYARGS))act_run_eval, ary,
+				(VALUE(*)(ANYARGS))act_run_rescue, rbcode);
+	} catch (...) {
+		rb_iv_set(klass, m_env_tmp_name.c_str(), Qnil);
+		throw;
+	}
+	rb_iv_set(klass, m_env_tmp_name.c_str(), Qnil);
+	
+	return ret;
+}
+
+VALUE Context::act_where(Env& env, const char* code, unsigned code_len)
+	{ return m_impl->act_where(env, code, code_len); }
+VALUE ContextIMPL::act_where(Env& env, const char* code, unsigned code_len)
+{
+	VALUE ret = act_run(env, code, code_len);
+	if(ret == Qfalse || ret == Qnil) {
+		backtrack("where prediction failed");
+	}
+	return ret;
+}
+
+
+VALUE Context::act_end()
+	{ return m_impl->act_end(); }
+VALUE ContextIMPL::act_end()
+{
+	size_t pos = m_index;
+	bool ok;
+	try {
+		next_char();
+		ok = false;
+	} catch(Backtrack& e) {
+		ok = true;
+	}
+	m_index = pos;
+	if(!ok) {
+		backtrack("unexpected character 'NOT IMPLEMENTED', EOF expected");
+	}
+	return Qnil;
+}
+
+
+void ContextIMPL::next_char()
+{
+	Input::at_t c( m_input.at(m_index) );
+	if(c.pos == NULL) {
+		backtrack("unexpected end of input");
+	}
+	m_ccur = c.pos;
+	m_ccur_len = c.charlen;
+	++m_index;
+}
+
+
+void ContextIMPL::backtrack(const std::string& msg)
+{
+	ErrorMessage* err = new ErrorMessage(msg, m_index, m_call_stack);
+	m_error_history.push_back(err);
+	throw Backtrack(err);
+}
+
+void ContextIMPL::clear_history()
+{
+	for(error_history_t::iterator it(m_error_history.begin()),
+			it_end(m_error_history.end());
+			it != it_end; ++it) {
+		delete *it;
+	}
+}
+
+
+class ParameterMap {
+public:
+	param_t operator[](const char* at_name);
+private:
+	typedef std::vector< std::pair<const char*,param_t> > table_t;
+	table_t m_table;
+private:
+	void clear_table();
+};
+
+param_t ParameterMap::operator[](const char* name)
+{
+	for(table_t::iterator it(m_table.begin()),
+			it_end(m_table.end());
+			it != it_end; ++it) {
+		if(strcmp(it->first,name) == 0) {
+			return it->second;
+		}
+	}
+	m_table.push_back( table_t::value_type(name,name) );
+	return name;
+}
+
+void ParameterMap::clear_table()
+{
+	for(table_t::iterator it(m_table.begin()),
+			it_end(m_table.end());
+			it != it_end; ++it) {
+		free((void*)it->second);
+	}
+}
+
+param_t param_lookup(const char* name)
+{
+	static ParameterMap map;
+	return map[name];
+}
+
+
+}  // namespace Metal
+
+
+@implementation MetalParserBase
+-(id)init:(VALUE)rb_instance
+{
+	self = [super init];
+	if(self != nil) {
+		instance = rb_instance;
+	}
+	return self;
+}
+-(VALUE)parse:(Metal::Input&)input withRule:(SEL)name
+{
+	Metal::Context ctx((id)self, instance, input);
+	try {
+		return ctx.apply(name);  // FIXME
+	} catch (Metal::ContextIMPL::Backtrack& e) {
+		throw Metal::ParseError(e.message(ctx));
+	}
+}
+-(VALUE)parse:(Metal::Input&)input
+{
+	return [self parse:input withRule:@selector(rule_main:)];
+}
+@end
+