metal 0.0.2 → 0.0.3

data/include/metal.h

@@ -0,0 +1,4 @@
+#import "metal/runtime.h"
+#import "metal/input.h"
+#import "metal/exception.h"
+// vim: ft=objcpp

data/include/metal/exception.h

@@ -0,0 +1,15 @@
+#import <string>
+#import <stdexcept>
+
+namespace Metal {
+
+
+struct ParseError : public std::runtime_error {
+	ParseError(const std::string& msg) :
+			std::runtime_error(msg) {}
+};
+
+
+}  // namespace Metal
+
+// vim: ft=objcpp

data/include/metal/input.h

@@ -0,0 +1,42 @@
+#import <vector>
+#import <stack>
+
+namespace Metal {
+
+
+class Input {
+public:
+	Input() {}
+	virtual ~Input() {}
+
+	struct at_t {
+		at_t() {}
+		at_t(const char* pos_, unsigned charlen_) :
+			pos(pos_), charlen(charlen_) {}
+		const char* pos;
+		unsigned charlen;
+	};
+
+	virtual at_t at(size_t pos) = 0;
+};
+
+
+class BufferedInput : public Input {
+public:
+	BufferedInput(const char* src, size_t len);
+	~BufferedInput();
+public:
+	at_t at(size_t pos);
+private:
+	size_t m_cur;
+	const char* m_pos;
+	const char* const m_endpos;
+private:
+	inline void prev();
+	inline unsigned charlen();
+};
+
+
+}  // namespace Metal
+
+// vim: ft=objcpp

data/include/metal/rbcode.h

@@ -0,0 +1,24 @@
+#import "metal/runtime.h"
+#import "metal/exception.h"
+#import "metal/input.h"
+
+namespace Metal {
+
+template <typename Parser>
+static VALUE parse_method_template(VALUE self, VALUE src)
+{
+	StringValue(src);
+	Metal::BufferedInput input(RSTRING_PTR(src), RSTRING_LEN(src));
+	id parser = [[Parser alloc] init:self];
+	try {
+		VALUE ret = [parser parse:input];
+		[parser free];
+		return ret;
+	} catch (Metal::ParseError& e) {
+		[parser free];
+		rb_raise(rb_eException, e.what());
+		return Qnil;
+	}
+}
+
+}  // namespace Metal

data/include/metal/runtime.h

@@ -0,0 +1,97 @@
+#import "ruby.h"
+#import <objc/Object.h>
+
+#define RB_P(val) { \
+	rb_define_variable("$RB_P", &val); \
+	rb_eval_string("p $RB_P"); \
+}
+
+namespace Metal {
+
+
+typedef const char* param_t;
+param_t param_lookup(const char* name);
+
+
+class EnvIMPL;
+class Env {
+public:
+	Env();
+	~Env();
+public:
+	VALUE& operator[](param_t key);
+private:
+	EnvIMPL* m_impl;
+	VALUE m_gc_marker;
+	friend class EnvIMPL;
+private:
+	Env(const Env&);
+};
+
+
+class Context;
+
+class Lambda {
+public:
+	Lambda(Context* _ctx, Env& _env) : ctx(_ctx), env(_env) {}
+	virtual ~Lambda() { }
+	virtual VALUE call() = 0;
+protected:
+	Context* const ctx;
+	Env& env;
+private:
+	Lambda();
+	Lambda(const Lambda&);
+};
+
+
+class Input;
+
+class ContextIMPL;
+class Context {
+public:
+	Context(id instance, VALUE rb_instance, Input& input);
+	~Context();
+
+public:
+	VALUE apply(SEL method);
+
+	VALUE act_or(Lambda** blocks);
+	VALUE act_many(Lambda* block);
+	VALUE act_many1(Lambda* block);
+	VALUE act_may(Lambda* block);
+	VALUE act_not(Lambda* block);
+	VALUE act_lookahead(Lambda* block);
+	VALUE act_char(const char* c, unsigned clen);
+	VALUE act_token(const char* s, unsigned slen);
+	VALUE act_any();
+	VALUE act_charclass(const char* s, unsigned slen);
+
+	VALUE act_run(Env& env, const char* code, unsigned code_len);
+	VALUE act_where(Env& env, const char* code, unsigned code_len);
+
+	VALUE act_end();
+
+private:
+	ContextIMPL* m_impl;
+	friend class ContextIMPL;
+private:
+	Context();
+	Context(const Context&);
+};
+
+
+}  // namespace Metal
+
+
+@interface MetalParserBase : Object
+{
+	VALUE instance;
+}
+-(id)init:(VALUE)instance;
+-(VALUE)parse:(Metal::Input&)input withRule:(SEL)name;
+-(VALUE)parse:(Metal::Input&)input;
+@end
+
+
+// vim: ft=objcpp

data/lib/metal/boot.rb

@@ -1,353 +1 @@
-#
-# Metal Bootstrap Parser
-#
-# 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.
-#
-require 'metal/generator'
-
-class MetalParser < Metal::ParserBase
-include Metal::Generator
-def rule_main()
-m = apply(:meta)
-apply(:end)
- m 
-end
-def rule_meta()
-xs = act_many(lambda{act_or([lambda{apply(:grammar)
-},
-lambda{apply(:meta_command)
-},
-])
-})
-apply(:s)
- Meta.new(xs) 
-end
-def rule_meta_command()
-apply(:s)
-apply(:precode)
-end
-def rule_grammar()
-apply(:s)
-i = apply(:interface_attr)
-n = apply(:grammar_name)
-apply(:s)
-e = act_may(lambda{apply(:extend_attr)})
-apply(:s)
-act_token('{')
-b = apply(:grammar_body)
-act_token('}')
- Grammar.new(n, b, e, i) 
-end
-def rule_interface_attr()
-act_or([lambda{act_token('module')
-apply(:fs)
- true  
-},
-lambda{act_token('class')
-apply(:fs)
- false 
-},
-lambda{ false 
-},
-])
-end
-def rule_extend_attr()
-act_token('<')
-apply(:s)
-apply(:grammar_name)
-end
-def rule_grammar_body()
-apply(:s)
-act_many(lambda{act_or([lambda{apply(:rule)
-},
-lambda{apply(:grammar_command)
-},
-])
-})
-end
-def rule_grammar_command()
-act_or([lambda{apply(:precode)
-},
-lambda{apply(:mixin)
-},
-])
-end
-def rule_precode()
-act_token('@{')
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('@')})
-act_any
-},
-lambda{act_token('@')
-act_not(lambda{act_token('}')})
-'@'
-},
-])
-})
-act_token('@}')
-apply(:s)
- Precode.new(s.join) 
-end
-def rule_mixin()
-act_token('@include')
-apply(:fs)
-n = apply(:scoped_grammar_name)
-apply(:s)
- Mixin.new(n) 
-end
-def rule_scoped_grammar_name()
-xs = act_many1(lambda{s = act_may(lambda{act_token('::')})
-n = apply(:grammar_name)
-"#{s}#{n}"
-})
- xs.join 
-end
-def rule_rule()
-act_token('-')
-apply(:s)
-n = apply(:rule_name)
-a = apply(:rule_args)
-apply(:fs)
-r = apply(:or_set)
-apply(:s)
- Rule.new(n, r, a) 
-end
-def rule_rule_args()
-act_many(lambda{apply(:s)
-act_token(':')
-apply(:var_name)
-})
-end
-def rule_or_set()
-x = apply(:and_set)
-apply(:s)
-xs = act_many(lambda{apply(:s)
-act_token('/')
-apply(:and_set)
-})
- OrSet.new([x] + xs) 
-end
-def rule_and_set()
-apply(:s)
-xs = act_may(lambda{x = apply(:expr)
-xs = act_many(lambda{apply(:fs)
-apply(:expr)
-})
-[x]+xs
-})
- AndSet.new(xs || []) 
-end
-def rule_expr()
-p = apply(:pred)
-p = act_may(lambda{apply(:iter,p)})
-v = act_may(lambda{apply(:var)})
- Expression.new(p, v) 
-end
-def rule_pred()
-act_or([lambda{act_token('!')
-p = apply(:pred)
- PredNot.new(p) 
-},
-lambda{act_token('&')
-f = apply(:literal)
- PredLookahead.new(f) 
-},
-lambda{apply(:literal)
-},
-])
-end
-def rule_iter(x)
-act_or([lambda{act_token('*')
- IterMany.new(x)  
-},
-lambda{act_token('+')
- IterMany1.new(x) 
-},
-lambda{act_token('?')
- IterMay.new(x) 
-},
-lambda{ x 
-},
-])
-end
-def rule_literal()
-act_or([lambda{apply(:apply_rule)
-},
-lambda{apply(:action)
-},
-lambda{apply(:where)
-},
-lambda{s = apply(:q_string)
- LiteralQuotedToken.new(s) 
-},
-lambda{s = apply(:dq_string)
- LiteralToken.new(s) 
-},
-lambda{s = apply(:charclass)
- LiteralCharset.new(s) 
-},
-lambda{act_token('.')
- LiteralAny.new 
-},
-lambda{apply(:other_call)
-},
-lambda{act_token('(')
-apply(:s)
-r = apply(:or_set)
-apply(:s)
-act_token(')')
- r 
-},
-])
-end
-def rule_var()
-act_token(':')
-n = apply(:var_name)
- n 
-end
-def rule_apply_rule()
-r = apply(:rule_name)
-a = act_may(lambda{apply(:apply_args)})
-
-				if r == "super"
-					Super.new(a)
-				elsif r == "self"
-					Self.new(a || [])
-				else
-					Apply.new(r, a || [])
-				end 
-end
-def rule_other_call()
-g = apply(:grammar_name)
-act_token('.')
-r = apply(:rule_name)
-a = act_may(lambda{apply(:apply_args)})
- Other.new(g, r, a || []) 
-end
-def rule_apply_args()
-act_token('(')
-a = act_may(lambda{apply(:s)
-x = apply(:var_name)
-xs = act_many(lambda{act_token(',')
-apply(:s)
-apply(:var_name)
-})
-[x] + xs
-})
-act_token(')')
- a || [] 
-end
-def rule_action()
-act_token('{*')
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
-act_any
-},
-lambda{act_token('*')
-act_not(lambda{act_token('}')})
-'*'
-},
-])
-})
-act_token('*}')
- Action.new(s.join) 
-end
-def rule_where()
-act_token('?{*')
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
-act_any
-},
-lambda{act_token('*')
-act_not(lambda{act_token('}')})
-'*'
-},
-])
-})
-act_token('*}')
- Where.new(s.join) 
-end
-def rule_rule_name()
-x = act_charset(%[a-z_])
-xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
- ([x] + xs).join 
-end
-def rule_var_name()
-x = act_charset(%[a-z_])
-xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
- ([x] + xs).join 
-end
-def rule_grammar_name()
-x = act_charset(%[A-Z])
-xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
- ([x] + xs).join 
-end
-def rule_dq_string()
-act_token('"')
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('"')})
-act_any
-},
-lambda{act_token('\"')
-},
-])
-})
-act_token('"')
- s.join 
-end
-def rule_q_string()
-act_token("'")
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token("'")})
-act_any
-},
-lambda{act_token("\\'")
-},
-])
-})
-act_token("'")
- s.join 
-end
-def rule_charclass()
-act_token('[')
-s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token(']')})
-act_any
-},
-lambda{act_token('\]')
-},
-])
-})
-act_token(']')
- s.join 
-end
-def rule_s()
-act_many(lambda{act_or([lambda{apply(:comment)
-},
-lambda{act_charset(%[ \t\r\n])
-},
-])
-})
-end
-def rule_fs()
-act_many1(lambda{act_or([lambda{apply(:comment)
-},
-lambda{act_charset(%[ \t\r\n])
-},
-])
-})
-end
-def rule_comment()
-act_token('#')
-act_many(lambda{act_not(lambda{act_token("\n")})
-act_any
-})
-act_token("\n")
-end
-end
+require 'metal_boot'