metal 0.0.2 → 0.0.3

data/Manifest.txt

@@ -6,8 +6,21 @@ bin/metal
 bin/metal-run
 config/hoe.rb
 config/requirements.rb
+ext/metal/boot/metal_boot.h
+ext/metal/boot/metal_boot.metal
+ext/metal/boot/metal_boot.mm
+ext/metal/boot/metal_boot_extconf.rb
+ext/metal/boot/metal_boot_rb.mm
+ext/metal/runtime/extconf.rb
+ext/metal/runtime/input.mm
+ext/metal/runtime/rbinit.mm
+ext/metal/runtime/runtime.mm
+include/metal.h
+include/metal/exception.h
+include/metal/input.h
+include/metal/rbcode.h
+include/metal/runtime.h
 lib/metal.rb
-lib/metal/boot.metal
 lib/metal/boot.rb
 lib/metal/generator.rb
 lib/metal/runtime.rb

data/bin/metal

@@ -1,41 +1,88 @@
 #!/usr/bin/env ruby
+require 'metal'
+require 'metal/version'
+
 require 'optparse'
 
 opts = {
-	:output => '-',
+	:name => nil,
+	:syntax_check => false,
+	:no_compile => false,
 }
 
 op = OptionParser.new
 
-require 'metal/version'
 op.version = Metal::VERSION::STRING
 
-op.on('-o OUTPUT', 'output file name') {|v|
-	opts[:output] = v
+op.on('-n NAME', 'output library name') {|v|
+	opts[:name] = v
+}
+
+op.on('-s',      'syntax check only') {
+	opts[:syntax_check] = true
+}
+
+op.on('-E',      'omit compiling library') {
+	opts[:no_compile] = true
 }
+
 op.banner = "#{op.banner} <source.metal>"
 op.parse!(ARGV)
 
 if ARGV.length != 1
+	# Argument error
 	puts op.to_s
 	exit 1
 end
+
 src = ARGV[0]
+name = opts[:name] || File.basename(src, ".metal")
 
-require 'metal'
-unless defined? MetalParser
-	require 'metal/boot'
-end
+require 'metal/generator'
+require 'metal/boot'
 
 parser = MetalParser.new
 result = parser.parse File.read(src)
-code = result.generate(:ruby)
-
-if opts[:output] == '-'
-	$stdout.write code
-else
-	File.open(opts[:output], 'wb') {|f|
-		f.write code
-	}
+
+exit 0 if opts[:syntax_check]
+
+
+File.open("#{name}.mm", "wb") {|source|
+File.open("#{name}.h", "wb") {|header|
+File.open("#{name}_rb.mm", "wb") {|rbcode|
+result.generate(name, source, header, rbcode)
+}
+}
+}
+
+inc_dir = File.expand_path File.join(File.dirname(__FILE__), '../include')
+
+File.open("#{name}_extconf.rb", "wb") {|file|
+	file.write <<EOF
+require 'mkmf'
+
+begin
+	CXX_EXT << 'mm' unless CXX_EXT.include?('mm')
+rescue
 end
 
+dir_config('metal')
+
+$CFLAGS << " -I. -I#{inc_dir} #{ENV['CFLAGS']} -Wall -g"
+$libs << " -lobjc"
+
+$objs = %w[#{name}.o  #{name}_rb.o]
+$srcs = %w[#{name}.mm #{name}_rb.mm]
+
+create_makefile('#{name}')
+EOF
+}
+
+exit 0 if opts[:no_compile]
+
+
+load "#{name}_extconf.rb"
+
+#system(ENV['make'] || 'make')
+system( (ENV['make'] || 'make') + " -j2")
+

data/bin/metal-run

@@ -1,29 +1,32 @@
 #!/usr/bin/env ruby
 
-if ARGV.length != 2
-	puts "Usage: #{File.basename($0)} <source.rb> <target>"
+if ARGV.length < 2
+	puts "Usage: #{File.basename($0)} <parser.so/bundle>+ <target>"
 	exit 1
 end
-src = ARGV[0]
-target = ARGV[1]
+target = ARGV.pop
+libs = ARGV
 
-require 'rubygems'
 require 'metal'
+require 'metal/generator'
 
 before = Object.constants
-load src
+
+libs.each {|lib|
+	require lib
+}
+
 after = Object.constants
 
 
 parsers = (after - before) \
 	.map     {|c| Object.const_get(c) } \
-	.select  {|c| c.is_a?(Class) }      \
-	.select  {|c| c.public_instance_methods.map{|m|m.to_sym}.include?(:rule_main) } \
-	.sort_by {|c| c.ancestors.length }  \
-	.reverse
+	.select  {|c| c < Metal::ParserBase } \
+	.select  {|c| c.public_instance_methods.map{|m|m.to_sym}.include?(:parse) } \
+	.sort_by {|c| -c.ancestors.length }
 
 if parsers.empty?
-	puts "Can't find parser in #{src}."
+	puts "Can't find parser in #{libs.join(', ')}."
 	exit 1
 end
 
@@ -32,10 +35,10 @@ $stderr.puts "Using #{first}"
 
 if target == '-'
 	$stderr.puts "Using standard input as input."
-	input = $stdin
+	input = $stdin.read
 elsif File.file?(target)
 	$stderr.puts "Using #{target} file as input."
-	input = File.open(target)
+	input = File.read(target)
 else
 	$stderr.puts "Using '#{target}' as input."
 	input = target

data/config/hoe.rb

@@ -63,8 +63,10 @@ $hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   #p.extra_deps = EXTRA_DEPENDENCIES
 
-    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
-  end
+  p.spec_extras = {    # A hash of extra values to set in the gemspec.
+		:extensions => %w[ext/metal/runtime/extconf.rb ext/metal/boot/metal_boot_extconf.rb]
+	}
+end
 
 CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
 PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"

data/ext/metal/boot/metal_boot.h

@@ -0,0 +1,32 @@
+#import "metal/runtime.h"
+@interface MetalParser : MetalParserBase
+-(VALUE)rule_main:(Metal::Context*)ctx;
+-(VALUE)rule_meta:(Metal::Context*)ctx;
+-(VALUE)rule_grammar:(Metal::Context*)ctx;
+-(VALUE)rule_precode:(Metal::Context*)ctx;
+-(VALUE)rule_extend_attr:(Metal::Context*)ctx;
+-(VALUE)rule_category_attr:(Metal::Context*)ctx;
+-(VALUE)rule_rule:(Metal::Context*)ctx;
+-(VALUE)rule_token:(Metal::Context*)ctx;
+-(VALUE)rule_or_set:(Metal::Context*)ctx;
+-(VALUE)rule_and_set:(Metal::Context*)ctx;
+-(VALUE)rule_expr:(Metal::Context*)ctx;
+-(VALUE)rule_var:(Metal::Context*)ctx;
+-(VALUE)rule_iter:(Metal::Context*)ctx;
+-(VALUE)rule_pred:(Metal::Context*)ctx;
+-(VALUE)rule_literal:(Metal::Context*)ctx;
+-(VALUE)rule_call_rule:(Metal::Context*)ctx;
+-(VALUE)rule_other_call:(Metal::Context*)ctx;
+-(VALUE)rule_apply_args:(Metal::Context*)ctx;
+-(VALUE)rule_action:(Metal::Context*)ctx;
+-(VALUE)rule_where:(Metal::Context*)ctx;
+-(VALUE)rule_rule_name:(Metal::Context*)ctx;
+-(VALUE)rule_var_name:(Metal::Context*)ctx;
+-(VALUE)rule_grammar_name:(Metal::Context*)ctx;
+-(VALUE)rule_dq_string:(Metal::Context*)ctx;
+-(VALUE)rule_q_string:(Metal::Context*)ctx;
+-(VALUE)rule_charclass:(Metal::Context*)ctx;
+-(VALUE)rule_s:(Metal::Context*)ctx;
+-(VALUE)rule_fs:(Metal::Context*)ctx;
+-(VALUE)rule_comment:(Metal::Context*)ctx;
+@end

data/{lib/metal/boot.metal → ext/metal/boot/metal_boot.metal}

@@ -1,4 +1,4 @@
-@{#
+#
 # Metal Bootstrap Parser
 #
 # Copyright (C) 2008 FURUHASHI Sadayuki
@@ -15,59 +15,43 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-require 'metal/generator'
-@}
 
 
 MetalParser {
-	@include Metal::Generator
+	{| include Metal::Generator |}
 
 	-main
-		meta:m end  {* m *}
+			meta:m s end  {* m *}
 
 	-meta
-		(grammar / meta_command)*:xs s  {* Meta.new(xs) *}
+			(s grammar / s precode)*:xs {* Meta.new(xs) *}
 
-	-meta_command
-			s precode
-	
 	-grammar
-			s interface_attr:i grammar_name:n s extend_attr?:e s '{' grammar_body:b '}'
-				{* Grammar.new(n, b, e, i) *}
-
-	-interface_attr
-			'module' fs  {* true  *}
-		/ 'class' fs   {* false *}
-		/ {* false *}
-	
-	-extend_attr
-			'<' s grammar_name
-
-	-grammar_body
-		s (rule / grammar_command)*
-
-	-grammar_command
-			precode
-		/ mixin
+			grammar_name:n s (extend_attr / category_attr)?:ec s
+				'{' (s rule / s token / s precode)*:b s '}'
+					{* Grammar.new(n, b, *ec) *}
 
 	-precode
 			'@{' (!'@' . / '@' !'}' {*'@'*})+:s '@}' s  {* Precode.new(s.join) *}
+		/ '{|' (!'|' . / '|' !'}' {*'@'*})+:s '|}' s  {* Precode.new(s.join) *}
+
+	-extend_attr
+			'<' s grammar_name:e  {* [e, nil] *}
 
-	-mixin
-			'@include' fs scoped_grammar_name:n s  {* Mixin.new(n) *}
+	-category_attr
+			'(' s grammar_name:c s ')'  {* [nil, c] *}
 
-	-scoped_grammar_name
-		('::'?:s grammar_name:n  {*"#{s}#{n}"*})+:xs  {* xs.join *}
 
 	-rule
-			'-' s rule_name:n rule_args:a fs or_set:r s
-				{* Rule.new(n, r, a) *}
-	
-	-rule_args
-			(s ':' var_name)*
+			'-' s rule_name:n fs or_set:r s
+				{* Rule.new(n, r) *}
+
+	-token
+			'NO MATCH'  # FIXME
 	
+
 	-or_set
-			and_set:x s (s '/' and_set)*:xs
+			('/' s)? and_set:x s (s '/' and_set)*:xs
 				{* OrSet.new([x] + xs) *}
 	
 	-and_set
@@ -75,41 +59,40 @@ MetalParser {
 				{* AndSet.new(xs || []) *}
 	
 	-expr
-			pred:p iter(p)?:p var?:v {* Expression.new(p, v) *}
+			pred:p iter?:i var?:v {* Expression.new(p, i, v) *}
+	
+	-var
+			':' var_name:n  {* n *}
+	
+	-iter
+			'*'  {* :many  *}
+		/ '+'  {* :many1 *}
+		/ '?'  {* :may   *}
 	
 	-pred
 			'!' pred:p     {* PredNot.new(p) *}
 		/ '&' literal:f  {* PredLookahead.new(f) *}
 		/ literal
 	
-	-iter :x
-			'*'  {* IterMany.new(x)  *}
-		/ '+'  {* IterMany1.new(x) *}
-		/ '?'  {* IterMay.new(x) *}
-		/      {* x *}
-	
 	-literal
-			apply_rule
+			call_rule
 		/ action
 		/ where
 		/ q_string:s   {* LiteralQuotedToken.new(s) *}
 		/ dq_string:s  {* LiteralToken.new(s) *}
-		/ charclass:s  {* LiteralCharset.new(s) *}
+		/ charclass:s  {* LiteralCharclass.new(s) *}
 		/ '.'          {* LiteralAny.new *}
 		/ other_call
 		/ '(' s or_set:r s ')'  {* r *}
-	
-	-var
-			':' var_name:n  {* n *}
 
-	-apply_rule
+	-call_rule
 			rule_name:r apply_args?:a  {*
 				if r == "super"
-					Super.new(a)
-				elsif r == "self"
-					Self.new(a || [])
+					LiteralSuper.new(a)
+				elsif r == "end"
+					LiteralEnd.new  # FIXME args
 				else
-					Apply.new(r, a || [])
+					LiteralApply.new(r, a || [])
 				end *}
 	
 	-other_call
@@ -120,9 +103,11 @@ MetalParser {
 	
 	-action
 			'{*' (!'*' . / '*' !'}' {*'*'*})+:s '*}'  {* Action.new(s.join) *}
+		/ '{|' (!'|' . / '|' !'}' {*'*'*})+:s '|}'  {* Action.new(s.join) *}
 
 	-where
 			'?{*' (!'*' . / '*' !'}' {*'*'*})+:s '*}' {* Where.new(s.join) *}
+		/ '?{|' (!'|' . / '|' !'}' {*'*'*})+:s '|}' {* Where.new(s.join) *}
 	
 	-rule_name
 			[a-z_]:x [a-zA-Z_0-9]*:xs  {* ([x] + xs).join *}
@@ -153,3 +138,5 @@ MetalParser {
 }
 
 
+# vim: ft=ruby syntax=conf
+

data/ext/metal/boot/metal_boot.mm

@@ -0,0 +1,1294 @@
+#import "metal_boot.h"
+using namespace Metal;
+static param_t const PARAM_a = param_lookup("a");
+static param_t const PARAM_b = param_lookup("b");
+static param_t const PARAM_c = param_lookup("c");
+static param_t const PARAM_e = param_lookup("e");
+static param_t const PARAM_ec = param_lookup("ec");
+static param_t const PARAM_f = param_lookup("f");
+static param_t const PARAM_g = param_lookup("g");
+static param_t const PARAM_i = param_lookup("i");
+static param_t const PARAM_m = param_lookup("m");
+static param_t const PARAM_n = param_lookup("n");
+static param_t const PARAM_p = param_lookup("p");
+static param_t const PARAM_r = param_lookup("r");
+static param_t const PARAM_s = param_lookup("s");
+static param_t const PARAM_v = param_lookup("v");
+static param_t const PARAM_x = param_lookup("x");
+static param_t const PARAM_xs = param_lookup("xs");
+@implementation MetalParser
+-(VALUE)rule_main:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_m] = ({
+ctx->apply(@selector(rule_meta:));
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_end();
+ctx->act_run(env," m ",3);
+});
+}
+-(VALUE)rule_meta:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_xs] = ({
+struct rule_meta_1_t : Lambda {
+rule_meta_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_meta_2_t : Lambda {
+rule_meta_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_grammar:));
+});
+}
+} rule_meta_2(ctx, env);
+struct rule_meta_3_t : Lambda {
+rule_meta_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_precode:));
+});
+}
+} rule_meta_3(ctx, env);
+Lambda* rule_meta_2_or[] = {
+&rule_meta_2,
+&rule_meta_3,
+NULL
+};
+ctx->act_or(rule_meta_2_or);
+});
+}
+} rule_meta_1(ctx, env);
+ctx->act_many(&rule_meta_1);
+});
+ctx->act_run(env," Meta.new(xs) ",14);
+});
+}
+-(VALUE)rule_grammar:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_n] = ({
+ctx->apply(@selector(rule_grammar_name:));
+});
+ctx->apply(@selector(rule_s:));
+env[PARAM_ec] = ({
+struct rule_grammar_1_t : Lambda {
+rule_grammar_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_grammar_2_t : Lambda {
+rule_grammar_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_extend_attr:));
+});
+}
+} rule_grammar_2(ctx, env);
+struct rule_grammar_3_t : Lambda {
+rule_grammar_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_category_attr:));
+});
+}
+} rule_grammar_3(ctx, env);
+Lambda* rule_grammar_2_or[] = {
+&rule_grammar_2,
+&rule_grammar_3,
+NULL
+};
+ctx->act_or(rule_grammar_2_or);
+});
+}
+} rule_grammar_1(ctx, env);
+ctx->act_may(&rule_grammar_1);
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_char("{",1);
+env[PARAM_b] = ({
+struct rule_grammar_4_t : Lambda {
+rule_grammar_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_grammar_5_t : Lambda {
+rule_grammar_5_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_rule:));
+});
+}
+} rule_grammar_5(ctx, env);
+struct rule_grammar_6_t : Lambda {
+rule_grammar_6_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_token:));
+});
+}
+} rule_grammar_6(ctx, env);
+struct rule_grammar_7_t : Lambda {
+rule_grammar_7_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_precode:));
+});
+}
+} rule_grammar_7(ctx, env);
+Lambda* rule_grammar_5_or[] = {
+&rule_grammar_5,
+&rule_grammar_6,
+&rule_grammar_7,
+NULL
+};
+ctx->act_or(rule_grammar_5_or);
+});
+}
+} rule_grammar_4(ctx, env);
+ctx->act_many(&rule_grammar_4);
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_char("}",1);
+ctx->act_run(env," Grammar.new(n, b, *ec) ",24);
+});
+}
+-(VALUE)rule_precode:(Context*)ctx {
+return ({
+Env env;
+struct rule_precode_1_t : Lambda {
+rule_precode_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("@{",2);
+env[PARAM_s] = ({
+struct rule_precode_2_t : Lambda {
+rule_precode_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_precode_3_t : Lambda {
+rule_precode_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_precode_4_t : Lambda {
+rule_precode_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("@",1);
+});
+}
+} rule_precode_4(ctx, env);
+ctx->act_not(&rule_precode_4);
+ctx->act_any();
+});
+}
+} rule_precode_3(ctx, env);
+struct rule_precode_5_t : Lambda {
+rule_precode_5_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("@",1);
+struct rule_precode_6_t : Lambda {
+rule_precode_6_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_precode_6(ctx, env);
+ctx->act_not(&rule_precode_6);
+ctx->act_run(env,"'@'",3);
+});
+}
+} rule_precode_5(ctx, env);
+Lambda* rule_precode_3_or[] = {
+&rule_precode_3,
+&rule_precode_5,
+NULL
+};
+ctx->act_or(rule_precode_3_or);
+});
+}
+} rule_precode_2(ctx, env);
+ctx->act_many1(&rule_precode_2);
+});
+ctx->act_token("@}",2);
+ctx->apply(@selector(rule_s:));
+ctx->act_run(env," Precode.new(s.join) ",21);
+});
+}
+} rule_precode_1(ctx, env);
+struct rule_precode_7_t : Lambda {
+rule_precode_7_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("{|",2);
+env[PARAM_s] = ({
+struct rule_precode_8_t : Lambda {
+rule_precode_8_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_precode_9_t : Lambda {
+rule_precode_9_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_precode_10_t : Lambda {
+rule_precode_10_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+});
+}
+} rule_precode_10(ctx, env);
+ctx->act_not(&rule_precode_10);
+ctx->act_any();
+});
+}
+} rule_precode_9(ctx, env);
+struct rule_precode_11_t : Lambda {
+rule_precode_11_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+struct rule_precode_12_t : Lambda {
+rule_precode_12_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_precode_12(ctx, env);
+ctx->act_not(&rule_precode_12);
+ctx->act_run(env,"'@'",3);
+});
+}
+} rule_precode_11(ctx, env);
+Lambda* rule_precode_9_or[] = {
+&rule_precode_9,
+&rule_precode_11,
+NULL
+};
+ctx->act_or(rule_precode_9_or);
+});
+}
+} rule_precode_8(ctx, env);
+ctx->act_many1(&rule_precode_8);
+});
+ctx->act_token("|}",2);
+ctx->apply(@selector(rule_s:));
+ctx->act_run(env," Precode.new(s.join) ",21);
+});
+}
+} rule_precode_7(ctx, env);
+Lambda* rule_precode_1_or[] = {
+&rule_precode_1,
+&rule_precode_7,
+NULL
+};
+ctx->act_or(rule_precode_1_or);
+});
+}
+-(VALUE)rule_extend_attr:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("<",1);
+ctx->apply(@selector(rule_s:));
+env[PARAM_e] = ({
+ctx->apply(@selector(rule_grammar_name:));
+});
+ctx->act_run(env," [e, nil] ",10);
+});
+}
+-(VALUE)rule_category_attr:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("(",1);
+ctx->apply(@selector(rule_s:));
+env[PARAM_c] = ({
+ctx->apply(@selector(rule_grammar_name:));
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_char(")",1);
+ctx->act_run(env," [nil, c] ",10);
+});
+}
+-(VALUE)rule_rule:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("-",1);
+ctx->apply(@selector(rule_s:));
+env[PARAM_n] = ({
+ctx->apply(@selector(rule_rule_name:));
+});
+ctx->apply(@selector(rule_fs:));
+env[PARAM_r] = ({
+ctx->apply(@selector(rule_or_set:));
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_run(env," Rule.new(n, r) ",16);
+});
+}
+-(VALUE)rule_token:(Context*)ctx {
+return ({
+Env env;
+ctx->act_token("NO MATCH",8);
+});
+}
+-(VALUE)rule_or_set:(Context*)ctx {
+return ({
+Env env;
+struct rule_or_set_1_t : Lambda {
+rule_or_set_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("/",1);
+ctx->apply(@selector(rule_s:));
+});
+}
+} rule_or_set_1(ctx, env);
+ctx->act_may(&rule_or_set_1);
+env[PARAM_x] = ({
+ctx->apply(@selector(rule_and_set:));
+});
+ctx->apply(@selector(rule_s:));
+env[PARAM_xs] = ({
+struct rule_or_set_2_t : Lambda {
+rule_or_set_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+ctx->act_char("/",1);
+ctx->apply(@selector(rule_and_set:));
+});
+}
+} rule_or_set_2(ctx, env);
+ctx->act_many(&rule_or_set_2);
+});
+ctx->act_run(env," OrSet.new([x] + xs) ",21);
+});
+}
+-(VALUE)rule_and_set:(Context*)ctx {
+return ({
+Env env;
+ctx->apply(@selector(rule_s:));
+env[PARAM_xs] = ({
+struct rule_and_set_1_t : Lambda {
+rule_and_set_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+env[PARAM_x] = ({
+ctx->apply(@selector(rule_expr:));
+});
+env[PARAM_xs] = ({
+struct rule_and_set_2_t : Lambda {
+rule_and_set_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_fs:));
+ctx->apply(@selector(rule_expr:));
+});
+}
+} rule_and_set_2(ctx, env);
+ctx->act_many(&rule_and_set_2);
+});
+ctx->act_run(env,"[x]+xs",6);
+});
+}
+} rule_and_set_1(ctx, env);
+ctx->act_may(&rule_and_set_1);
+});
+ctx->act_run(env," AndSet.new(xs || []) ",22);
+});
+}
+-(VALUE)rule_expr:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_p] = ({
+ctx->apply(@selector(rule_pred:));
+});
+env[PARAM_i] = ({
+struct rule_expr_1_t : Lambda {
+rule_expr_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_iter:));
+});
+}
+} rule_expr_1(ctx, env);
+ctx->act_may(&rule_expr_1);
+});
+env[PARAM_v] = ({
+struct rule_expr_2_t : Lambda {
+rule_expr_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_var:));
+});
+}
+} rule_expr_2(ctx, env);
+ctx->act_may(&rule_expr_2);
+});
+ctx->act_run(env," Expression.new(p, i, v) ",25);
+});
+}
+-(VALUE)rule_var:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char(":",1);
+env[PARAM_n] = ({
+ctx->apply(@selector(rule_var_name:));
+});
+ctx->act_run(env," n ",3);
+});
+}
+-(VALUE)rule_iter:(Context*)ctx {
+return ({
+Env env;
+struct rule_iter_1_t : Lambda {
+rule_iter_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("*",1);
+ctx->act_run(env," :many  ",8);
+});
+}
+} rule_iter_1(ctx, env);
+struct rule_iter_2_t : Lambda {
+rule_iter_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("+",1);
+ctx->act_run(env," :many1 ",8);
+});
+}
+} rule_iter_2(ctx, env);
+struct rule_iter_3_t : Lambda {
+rule_iter_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("?",1);
+ctx->act_run(env," :may   ",8);
+});
+}
+} rule_iter_3(ctx, env);
+Lambda* rule_iter_1_or[] = {
+&rule_iter_1,
+&rule_iter_2,
+&rule_iter_3,
+NULL
+};
+ctx->act_or(rule_iter_1_or);
+});
+}
+-(VALUE)rule_pred:(Context*)ctx {
+return ({
+Env env;
+struct rule_pred_1_t : Lambda {
+rule_pred_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("!",1);
+env[PARAM_p] = ({
+ctx->apply(@selector(rule_pred:));
+});
+ctx->act_run(env," PredNot.new(p) ",16);
+});
+}
+} rule_pred_1(ctx, env);
+struct rule_pred_2_t : Lambda {
+rule_pred_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("&",1);
+env[PARAM_f] = ({
+ctx->apply(@selector(rule_literal:));
+});
+ctx->act_run(env," PredLookahead.new(f) ",22);
+});
+}
+} rule_pred_2(ctx, env);
+struct rule_pred_3_t : Lambda {
+rule_pred_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_literal:));
+});
+}
+} rule_pred_3(ctx, env);
+Lambda* rule_pred_1_or[] = {
+&rule_pred_1,
+&rule_pred_2,
+&rule_pred_3,
+NULL
+};
+ctx->act_or(rule_pred_1_or);
+});
+}
+-(VALUE)rule_literal:(Context*)ctx {
+return ({
+Env env;
+struct rule_literal_1_t : Lambda {
+rule_literal_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_call_rule:));
+});
+}
+} rule_literal_1(ctx, env);
+struct rule_literal_2_t : Lambda {
+rule_literal_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_action:));
+});
+}
+} rule_literal_2(ctx, env);
+struct rule_literal_3_t : Lambda {
+rule_literal_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_where:));
+});
+}
+} rule_literal_3(ctx, env);
+struct rule_literal_4_t : Lambda {
+rule_literal_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+env[PARAM_s] = ({
+ctx->apply(@selector(rule_q_string:));
+});
+ctx->act_run(env," LiteralQuotedToken.new(s) ",27);
+});
+}
+} rule_literal_4(ctx, env);
+struct rule_literal_5_t : Lambda {
+rule_literal_5_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+env[PARAM_s] = ({
+ctx->apply(@selector(rule_dq_string:));
+});
+ctx->act_run(env," LiteralToken.new(s) ",21);
+});
+}
+} rule_literal_5(ctx, env);
+struct rule_literal_6_t : Lambda {
+rule_literal_6_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+env[PARAM_s] = ({
+ctx->apply(@selector(rule_charclass:));
+});
+ctx->act_run(env," LiteralCharclass.new(s) ",25);
+});
+}
+} rule_literal_6(ctx, env);
+struct rule_literal_7_t : Lambda {
+rule_literal_7_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char(".",1);
+ctx->act_run(env," LiteralAny.new ",16);
+});
+}
+} rule_literal_7(ctx, env);
+struct rule_literal_8_t : Lambda {
+rule_literal_8_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_other_call:));
+});
+}
+} rule_literal_8(ctx, env);
+struct rule_literal_9_t : Lambda {
+rule_literal_9_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("(",1);
+ctx->apply(@selector(rule_s:));
+env[PARAM_r] = ({
+ctx->apply(@selector(rule_or_set:));
+});
+ctx->apply(@selector(rule_s:));
+ctx->act_char(")",1);
+ctx->act_run(env," r ",3);
+});
+}
+} rule_literal_9(ctx, env);
+Lambda* rule_literal_1_or[] = {
+&rule_literal_1,
+&rule_literal_2,
+&rule_literal_3,
+&rule_literal_4,
+&rule_literal_5,
+&rule_literal_6,
+&rule_literal_7,
+&rule_literal_8,
+&rule_literal_9,
+NULL
+};
+ctx->act_or(rule_literal_1_or);
+});
+}
+-(VALUE)rule_call_rule:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_r] = ({
+ctx->apply(@selector(rule_rule_name:));
+});
+env[PARAM_a] = ({
+struct rule_call_rule_1_t : Lambda {
+rule_call_rule_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_apply_args:));
+});
+}
+} rule_call_rule_1(ctx, env);
+ctx->act_may(&rule_call_rule_1);
+});
+ctx->act_run(env,"\n"
+"				if r == \"super\"\n"
+"					LiteralSuper.new(a)\n"
+"				elsif r == \"end\"\n"
+"					LiteralEnd.new  # FIXME args\n"
+"				else\n"
+"					LiteralApply.new(r, a || [])\n"
+"				end ",152);
+});
+}
+-(VALUE)rule_other_call:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_g] = ({
+ctx->apply(@selector(rule_grammar_name:));
+});
+ctx->act_char(".",1);
+env[PARAM_r] = ({
+ctx->apply(@selector(rule_rule_name:));
+});
+env[PARAM_a] = ({
+struct rule_other_call_1_t : Lambda {
+rule_other_call_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_apply_args:));
+});
+}
+} rule_other_call_1(ctx, env);
+ctx->act_may(&rule_other_call_1);
+});
+ctx->act_run(env," Other.new(g, r, a || []) ",26);
+});
+}
+-(VALUE)rule_apply_args:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("(",1);
+env[PARAM_a] = ({
+struct rule_apply_args_1_t : Lambda {
+rule_apply_args_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_s:));
+env[PARAM_x] = ({
+ctx->apply(@selector(rule_var_name:));
+});
+env[PARAM_xs] = ({
+struct rule_apply_args_2_t : Lambda {
+rule_apply_args_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char(",",1);
+ctx->apply(@selector(rule_s:));
+ctx->apply(@selector(rule_var_name:));
+});
+}
+} rule_apply_args_2(ctx, env);
+ctx->act_many(&rule_apply_args_2);
+});
+ctx->act_run(env,"[x] + xs",8);
+});
+}
+} rule_apply_args_1(ctx, env);
+ctx->act_may(&rule_apply_args_1);
+});
+ctx->act_char(")",1);
+ctx->act_run(env," a || [] ",9);
+});
+}
+-(VALUE)rule_action:(Context*)ctx {
+return ({
+Env env;
+struct rule_action_1_t : Lambda {
+rule_action_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("{*",2);
+env[PARAM_s] = ({
+struct rule_action_2_t : Lambda {
+rule_action_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_action_3_t : Lambda {
+rule_action_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_action_4_t : Lambda {
+rule_action_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("*",1);
+});
+}
+} rule_action_4(ctx, env);
+ctx->act_not(&rule_action_4);
+ctx->act_any();
+});
+}
+} rule_action_3(ctx, env);
+struct rule_action_5_t : Lambda {
+rule_action_5_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("*",1);
+struct rule_action_6_t : Lambda {
+rule_action_6_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_action_6(ctx, env);
+ctx->act_not(&rule_action_6);
+ctx->act_run(env,"'*'",3);
+});
+}
+} rule_action_5(ctx, env);
+Lambda* rule_action_3_or[] = {
+&rule_action_3,
+&rule_action_5,
+NULL
+};
+ctx->act_or(rule_action_3_or);
+});
+}
+} rule_action_2(ctx, env);
+ctx->act_many1(&rule_action_2);
+});
+ctx->act_token("*}",2);
+ctx->act_run(env," Action.new(s.join) ",20);
+});
+}
+} rule_action_1(ctx, env);
+struct rule_action_7_t : Lambda {
+rule_action_7_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("{|",2);
+env[PARAM_s] = ({
+struct rule_action_8_t : Lambda {
+rule_action_8_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_action_9_t : Lambda {
+rule_action_9_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_action_10_t : Lambda {
+rule_action_10_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+});
+}
+} rule_action_10(ctx, env);
+ctx->act_not(&rule_action_10);
+ctx->act_any();
+});
+}
+} rule_action_9(ctx, env);
+struct rule_action_11_t : Lambda {
+rule_action_11_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+struct rule_action_12_t : Lambda {
+rule_action_12_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_action_12(ctx, env);
+ctx->act_not(&rule_action_12);
+ctx->act_run(env,"'*'",3);
+});
+}
+} rule_action_11(ctx, env);
+Lambda* rule_action_9_or[] = {
+&rule_action_9,
+&rule_action_11,
+NULL
+};
+ctx->act_or(rule_action_9_or);
+});
+}
+} rule_action_8(ctx, env);
+ctx->act_many1(&rule_action_8);
+});
+ctx->act_token("|}",2);
+ctx->act_run(env," Action.new(s.join) ",20);
+});
+}
+} rule_action_7(ctx, env);
+Lambda* rule_action_1_or[] = {
+&rule_action_1,
+&rule_action_7,
+NULL
+};
+ctx->act_or(rule_action_1_or);
+});
+}
+-(VALUE)rule_where:(Context*)ctx {
+return ({
+Env env;
+struct rule_where_1_t : Lambda {
+rule_where_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("?{*",3);
+env[PARAM_s] = ({
+struct rule_where_2_t : Lambda {
+rule_where_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_where_3_t : Lambda {
+rule_where_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_where_4_t : Lambda {
+rule_where_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("*",1);
+});
+}
+} rule_where_4(ctx, env);
+ctx->act_not(&rule_where_4);
+ctx->act_any();
+});
+}
+} rule_where_3(ctx, env);
+struct rule_where_5_t : Lambda {
+rule_where_5_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("*",1);
+struct rule_where_6_t : Lambda {
+rule_where_6_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_where_6(ctx, env);
+ctx->act_not(&rule_where_6);
+ctx->act_run(env,"'*'",3);
+});
+}
+} rule_where_5(ctx, env);
+Lambda* rule_where_3_or[] = {
+&rule_where_3,
+&rule_where_5,
+NULL
+};
+ctx->act_or(rule_where_3_or);
+});
+}
+} rule_where_2(ctx, env);
+ctx->act_many1(&rule_where_2);
+});
+ctx->act_token("*}",2);
+ctx->act_run(env," Where.new(s.join) ",19);
+});
+}
+} rule_where_1(ctx, env);
+struct rule_where_7_t : Lambda {
+rule_where_7_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("?{|",3);
+env[PARAM_s] = ({
+struct rule_where_8_t : Lambda {
+rule_where_8_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_where_9_t : Lambda {
+rule_where_9_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_where_10_t : Lambda {
+rule_where_10_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+});
+}
+} rule_where_10(ctx, env);
+ctx->act_not(&rule_where_10);
+ctx->act_any();
+});
+}
+} rule_where_9(ctx, env);
+struct rule_where_11_t : Lambda {
+rule_where_11_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("|",1);
+struct rule_where_12_t : Lambda {
+rule_where_12_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("}",1);
+});
+}
+} rule_where_12(ctx, env);
+ctx->act_not(&rule_where_12);
+ctx->act_run(env,"'*'",3);
+});
+}
+} rule_where_11(ctx, env);
+Lambda* rule_where_9_or[] = {
+&rule_where_9,
+&rule_where_11,
+NULL
+};
+ctx->act_or(rule_where_9_or);
+});
+}
+} rule_where_8(ctx, env);
+ctx->act_many1(&rule_where_8);
+});
+ctx->act_token("|}",2);
+ctx->act_run(env," Where.new(s.join) ",19);
+});
+}
+} rule_where_7(ctx, env);
+Lambda* rule_where_1_or[] = {
+&rule_where_1,
+&rule_where_7,
+NULL
+};
+ctx->act_or(rule_where_1_or);
+});
+}
+-(VALUE)rule_rule_name:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_x] = ({
+ctx->act_charclass("[a-z_]",6);
+});
+env[PARAM_xs] = ({
+struct rule_rule_name_1_t : Lambda {
+rule_rule_name_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_charclass("[a-zA-Z_0-9]",12);
+});
+}
+} rule_rule_name_1(ctx, env);
+ctx->act_many(&rule_rule_name_1);
+});
+ctx->act_run(env," ([x] + xs).join ",17);
+});
+}
+-(VALUE)rule_var_name:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_x] = ({
+ctx->act_charclass("[a-z_]",6);
+});
+env[PARAM_xs] = ({
+struct rule_var_name_1_t : Lambda {
+rule_var_name_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_charclass("[a-zA-Z_0-9]",12);
+});
+}
+} rule_var_name_1(ctx, env);
+ctx->act_many(&rule_var_name_1);
+});
+ctx->act_run(env," ([x] + xs).join ",17);
+});
+}
+-(VALUE)rule_grammar_name:(Context*)ctx {
+return ({
+Env env;
+env[PARAM_x] = ({
+ctx->act_charclass("[A-Z]",5);
+});
+env[PARAM_xs] = ({
+struct rule_grammar_name_1_t : Lambda {
+rule_grammar_name_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_charclass("[a-zA-Z_0-9]",12);
+});
+}
+} rule_grammar_name_1(ctx, env);
+ctx->act_many(&rule_grammar_name_1);
+});
+ctx->act_run(env," ([x] + xs).join ",17);
+});
+}
+-(VALUE)rule_dq_string:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("\"",1);
+env[PARAM_s] = ({
+struct rule_dq_string_1_t : Lambda {
+rule_dq_string_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_dq_string_2_t : Lambda {
+rule_dq_string_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_dq_string_3_t : Lambda {
+rule_dq_string_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("\"",1);
+});
+}
+} rule_dq_string_3(ctx, env);
+ctx->act_not(&rule_dq_string_3);
+ctx->act_any();
+});
+}
+} rule_dq_string_2(ctx, env);
+struct rule_dq_string_4_t : Lambda {
+rule_dq_string_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("\\\"",2);
+});
+}
+} rule_dq_string_4(ctx, env);
+Lambda* rule_dq_string_2_or[] = {
+&rule_dq_string_2,
+&rule_dq_string_4,
+NULL
+};
+ctx->act_or(rule_dq_string_2_or);
+});
+}
+} rule_dq_string_1(ctx, env);
+ctx->act_many1(&rule_dq_string_1);
+});
+ctx->act_char("\"",1);
+ctx->act_run(env," s.join ",8);
+});
+}
+-(VALUE)rule_q_string:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("'",1);
+env[PARAM_s] = ({
+struct rule_q_string_1_t : Lambda {
+rule_q_string_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_q_string_2_t : Lambda {
+rule_q_string_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_q_string_3_t : Lambda {
+rule_q_string_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("'",1);
+});
+}
+} rule_q_string_3(ctx, env);
+ctx->act_not(&rule_q_string_3);
+ctx->act_any();
+});
+}
+} rule_q_string_2(ctx, env);
+struct rule_q_string_4_t : Lambda {
+rule_q_string_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("\\'",2);
+});
+}
+} rule_q_string_4(ctx, env);
+Lambda* rule_q_string_2_or[] = {
+&rule_q_string_2,
+&rule_q_string_4,
+NULL
+};
+ctx->act_or(rule_q_string_2_or);
+});
+}
+} rule_q_string_1(ctx, env);
+ctx->act_many1(&rule_q_string_1);
+});
+ctx->act_char("'",1);
+ctx->act_run(env," s.join ",8);
+});
+}
+-(VALUE)rule_charclass:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("[",1);
+env[PARAM_s] = ({
+struct rule_charclass_1_t : Lambda {
+rule_charclass_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_charclass_2_t : Lambda {
+rule_charclass_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_charclass_3_t : Lambda {
+rule_charclass_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("]",1);
+});
+}
+} rule_charclass_3(ctx, env);
+ctx->act_not(&rule_charclass_3);
+ctx->act_any();
+});
+}
+} rule_charclass_2(ctx, env);
+struct rule_charclass_4_t : Lambda {
+rule_charclass_4_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_token("\\]",2);
+});
+}
+} rule_charclass_4(ctx, env);
+Lambda* rule_charclass_2_or[] = {
+&rule_charclass_2,
+&rule_charclass_4,
+NULL
+};
+ctx->act_or(rule_charclass_2_or);
+});
+}
+} rule_charclass_1(ctx, env);
+ctx->act_many1(&rule_charclass_1);
+});
+ctx->act_char("]",1);
+ctx->act_run(env," s.join ",8);
+});
+}
+-(VALUE)rule_s:(Context*)ctx {
+return ({
+Env env;
+struct rule_s_1_t : Lambda {
+rule_s_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_s_2_t : Lambda {
+rule_s_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_comment:));
+});
+}
+} rule_s_2(ctx, env);
+struct rule_s_3_t : Lambda {
+rule_s_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_charclass("[ \\t\\r\\n]",9);
+});
+}
+} rule_s_3(ctx, env);
+Lambda* rule_s_2_or[] = {
+&rule_s_2,
+&rule_s_3,
+NULL
+};
+ctx->act_or(rule_s_2_or);
+});
+}
+} rule_s_1(ctx, env);
+ctx->act_many(&rule_s_1);
+});
+}
+-(VALUE)rule_fs:(Context*)ctx {
+return ({
+Env env;
+struct rule_fs_1_t : Lambda {
+rule_fs_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_fs_2_t : Lambda {
+rule_fs_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->apply(@selector(rule_comment:));
+});
+}
+} rule_fs_2(ctx, env);
+struct rule_fs_3_t : Lambda {
+rule_fs_3_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_charclass("[ \\t\\r\\n]",9);
+});
+}
+} rule_fs_3(ctx, env);
+Lambda* rule_fs_2_or[] = {
+&rule_fs_2,
+&rule_fs_3,
+NULL
+};
+ctx->act_or(rule_fs_2_or);
+});
+}
+} rule_fs_1(ctx, env);
+ctx->act_many1(&rule_fs_1);
+});
+}
+-(VALUE)rule_comment:(Context*)ctx {
+return ({
+Env env;
+ctx->act_char("#",1);
+struct rule_comment_1_t : Lambda {
+rule_comment_1_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+struct rule_comment_2_t : Lambda {
+rule_comment_2_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}
+VALUE call() {
+return ({
+ctx->act_char("\n",1);
+});
+}
+} rule_comment_2(ctx, env);
+ctx->act_not(&rule_comment_2);
+ctx->act_any();
+});
+}
+} rule_comment_1(ctx, env);
+ctx->act_many(&rule_comment_1);
+ctx->act_char("\n",1);
+});
+}
+@end