MessagePack IDL言語仕様案とパーサの実装

memo.msgspec

// example1.msgspec

namespace com.example
namespace cpp example
namespace ruby Example

message BasicTypeExample {
	1:  int8   f1
	2:  int16  f2
	3:  int32  f3
	4:  int64  f4
	5:  uint8  f5
	6:  uint16 f6
	7:  uint32 f7
	8:  uint64 f8
	9:  float  f9
	10: double f10
	11: bool   f11
	12: raw    f12
	13: string f13
	14: date   f14
}

message ContainerTypeExample {
	1: list<string> f1
	2: map<string,string> f2
	3: set<string> f3
}

message OptionalExample {
	1: string f1           // required non-nullable
	2: required string f2  // required non-nullable
	3: optional string f3  // optional non-nullable
	4: int32 f4            // required non-nullable
	5: required int32 f5   // required non-nullable
	6: optional int32 f6   // optional non-nullable
}

message NullableExample {
	1: string? f1           // required nullable
	2: required string? f2  // required nullable
	3: optional string? f3  // optional nullable
	4: int32? f4            // required nullable
	5: required int32? f5   // required nullable
	6: optional int32? f6   // optional nullable
}

message EmptyExample {
}


message DefaultExample {
	1: int32 f1 = 1212
	2: string f2 = "test"
	//3: list<int16> f3 = [1,2,3]
	//4: map<string,int16> f4 = {"a":1, "b":10}
}

const int32 CONST1 = 11211
const string CONST2 = "test"
//const list<int16> CONST3 = [1,2,3]
//const map<string,int16> CONST4 = {"a":1, "b":10}

message ConstExample {
	1: int32 f1 = CONST1
	2: string f2 = CONST2
	//3: list<int16> f2 = CONST3
	//4: map<string,int16> f4 = CONST4
}

message BuiltInConstExample {
	1: int8 f1 = INT8_MAX
	2: int16 f2 = INT16_MAX
	3: int32 f3 = INT32_MAX
	4: int64 f4 = INT64_MAX
	5: bool f5 = true
	6: bool f6 = false
}


enum EnumExample {
	1: RED
	2: GREEN
	3: BLUE
}


typedef map<string,string> PropertyMap;

message TypedefExampel {
	1: PropertyMap f1
}


typedef<V> map<string,V> GenericStringMap;

message<V> GenericExample {
	1: V f1
	2: list<V> f2
	3: GenericStringMap<V> f3
}

typedef GenericExample<string> GenericExampleSpecific1
typedef GenericExample<bool> GenericExampleSpecific2


message TypeSpecExample {
	1: list<string> f1
}

typespec cpp TypeSpecExample.f1 std::vector<std::string>

typespec cpp PropertyMap std::tr1::unordered_map<std::string,std::string>
typespec<V> cpp GenericStringMap<V> std::unordered_map<string,V>


exception BasicExceptionExample {
	1: string message
	2: int32 code
}

exception SuperExceptionExample {
	1: string message
	2: int32 code

	/*
	exception SubExceptionExample1 {
		3: string key
		4: raw value
	}

	exception SubExceptionExample2 {
		3: int32 flags

		exception SubSubExceptionExample {
			4: string value
		}
	}
	*/
}

exception SubExceptionExample3 < SuperExceptionExample {
	3: raw key
}


service BasicServiceExample {
	string func1(1: string key, 2: string value)
	string func2()
	string? func3(1: string key, 2: string value)
	string? func4()
	void func5(1: string key, 2: string value)
}

service OptionalServiceExample {
	string func1(1: string key, 2: string value)
	string func2(1: string key, 2: optional string value)
	string func3(1: string? key, 2: optional string? value)
	string? func4(1: string key, 2: string value)
}

service ExceptionServiceExample {
	void func1() throws SubExceptionExample2, SubExceptionExample3
	void func2() throws BasicExceptionExample
}

service SubServiceExample < BasicExceptionExample {
	! string func1(1: string key, 2: string value)  // override
	- string func1(1: string key, 2: string value)  // delete
	+ string func6()  // add
	string func7()  // add
}


// バージョニング案1（関数ごとのバージョン）
/*
service VersionServiceExample {
	void func1(1: string key)   // version 0
	void func1:1(1: string key, 2: optional string? value)
	uint32? func1:2(1: string key, 2: optional string? value)
	void func2:0(1: string key)
	string func3()
	string func3:1(1: optional int32 flags)

	// func1    // func1:2
	// func1:0  // func1:0
	// func1:1  // func1:1
	// func1:2  // func1:2
	// func1:3  // エラー (VersionMismatch)
	// func2    // func2:0
	// func2:0  // func2:0
	// func2:1  // エラー (VersionMismatch)
	// func2:2  // エラー (VersionMismatch)
	// func2:3  // エラー (VersionMismatch)
	// func3    // func3:1
	// func3:0  // func3:0
	// func3:1  // func3:1
	// func3:2  // エラー (VersionMismatch)
	// func3:3  // エラー (VersionMismatch)
}
*/

// バージョニング案2（関数セットごとのバージョン）
service VersionServiceExample {
	void func1(1: string key)
	void func2(1: string key)

1:
	! void func1(1: string key, 2: optional string? value)
	+ string func3()

2:
	! uint32? func1(1: string key, 2: optional string? value)
	- void func2(1: string key)
	! string func3(1: optional int32 flags)

	// func1    // func1:2
	// func1:0  // func1:0
	// func1:1  // func1:1
	// func1:2  // func1:2
	// func1:3  // エラー (VersionMismatch)
	// func2    // func2:0
	// func2:0  // func2:0
	// func2:1  // func2:0
	// func2:2  // エラー (VersionMismatch)
	// func2:3  // エラー (VersionMismatch)
	// func3    // func3:2
	// func3:0  // エラー (NoMethodFound)
	// func3:1  // func3:2
	// func3:2  // func3:2
	// func3:3  // エラー (VersionMismatch)
}


include memo2.msgspec


server MyApplication {
	OptionalServiceExample scope1 default
		// func1
		// func2
		// func1:scope1
		// func2:scope1

	ExceptionServiceExample scope2
		// func1:scope2
		// func2:scope2

	VersionServiceExample scope3
		// func1:scope3
		// func2:scope3
		// func3:scope3
		// func1:scope3:1
		// func2:scope3:1
		// func3:scope3:1
		// ...
}


// example1-impl.msgspec

memo2.msgspec

message IncludeTest {
}

msgspec.rb

require 'parslet'
require 'parslet/convenience'

require 'msgspec_visitor'
require 'msgspec_parser'
require 'msgspec_processor'
require 'pp'

processor = MessageSpec::Processor.new

begin
	processor.parse_file('memo.msgspec')
rescue MessageSpec::MessageSpecError => e
	puts e
end

pp processor.ast

msgspec_parser.rb

module MessageSpec


class ParsletParser < Parslet::Parser
	class << self
		def sequence(name, separator, element, min=0)
			if min == 0
				eval %[rule(:#{name.to_s.dump}) {
					(#{element}.as(:sequence_x) >> (#{separator} >> #{element}.as(:sequence_xs)).repeat).maybe.as(:sequence)
				}]
			else
				eval %[rule(:#{name.to_s.dump}) {
					(#{element}.as(:sequence_x) >> (#{separator} >> #{element}.as(:sequence_xs)).repeat(#{min-1})).as(:sequence)
				}]
			end
		end

		def keyword(string, name="k_"+string)
			rule(name.to_sym) {
				space? >> str(string) >> boundary
			}
		end

		def separator(char, name)
			rule(name.to_sym) {
				space? >> str(char)
			}
		end
	end


	root :expression

	rule(:expression) {
		space? >> document >> space?
	}

	rule(:document) {
		(include_ | definition).repeat.as(:document)
	}

	rule(:include_) {
		k_include >>
		path.as(:include) >>
		eol
	}

	rule(:definition) {
		namespace |
		message |
		enum |
		exception |
		const |
		typedef |
		typespec |
		service |
		server
	}


	rule(:namespace) {
		k_namespace >> (
			lang_name.as(:namespace_lang) >> namespace_name.as(:namespace_name) |
			namespace_name.as(:namespace_name)
		) >> eol
	}


	rule(:message) {
		k_message >>
			type_param_decl.maybe.as(:type_param_decl) >>
			class_name.as(:message_name) >>
			lt_extend_class.maybe.as(:super_class) >>
		k_lwing >>
			field.repeat.as(:message_body) >>
		k_rwing
	}

	rule(:exception) {
		k_exception >>
			type_param_decl.maybe.as(:type_param_decl) >>
			class_name.as(:exception_name) >>
			lt_extend_class.maybe.as(:super_class) >>
		k_lwing >>
			field.repeat.as(:exception_body) >>  # TODO nested exception?
		k_rwing
	}


	rule(:field) {
		field_element >> eol
	}

	rule(:field_element) {
		field_id.as(:field_id) >>
		field_modifier.maybe.as(:field_modifier) >>
		field_type.as(:field_type) >>
		field_name.as(:field_name) >>
		eq_default_value.maybe.as(:field_default)
	}

	rule(:field_id) {
		# terminal
		space? >>
			(str('0') | (match('[1-9]') >> match('[0-9]').repeat)).as(:val_int) >>
		str(':') >> str(':').absent?
	}

	rule(:field_modifier) {
		k_optional | k_required
	}

	rule(:eq_default_value) {
		k_equal >> literal
	}


	rule(:enum) {
		k_enum >>
			class_name.as(:enum_name) >>
		k_lwing >>
			enum_field.repeat.as(:enum_body) >>
		k_rwing
	}

	rule(:enum_field) {
		enum_field_element >> eol
	}

	rule(:enum_field_element) {
		field_id.as(:enum_field_id) >> field_name.as(:enum_field_name)
	}


	rule(:typedef) {
		k_typedef >>
			type_param_decl.maybe.as(:type_param_decl) >>
			generic_type.as(:typedef_type) >>
			generic_type.as(:typedef_name) >>
		eol
	}


	rule(:const) {
		k_const >>
			field_type.as(:const_type) >>
			const_name.as(:const_name) >>
			k_equal >> literal.as(:const_value) >>
		eol
	}


	rule(:typespec) {
		k_typespec >>
			type_param_decl.maybe.as(:type_param_decl) >>
			lang_name.as(:typespec_lang) >> (
				generic_type.as(:typespec_class) >> str('.') >> field_name.as(:typespec_field) |
				generic_type.as(:typespec_type)
			) >> lang_type.as(:typespec_spec) >> eol
	}

	rule(:lang_type) {
		space? >> lang_type_lexer.as(:lang_type_tokens)
	}

	rule(:lang_type_lexer) {
		(lang_type_word.as(:lang_type_token) | lang_type_separator.as(:lang_type_token)).repeat(1)
	}

	rule(:lang_type_word) {
		match('[a-zA-Z0-9_\-]').repeat(1)
	}

	rule(:lang_type_separator) {
		match('[\<\>\[\]\:\.\,]').repeat(1)
	}


	rule(:service) {
		k_service >>
			service_name.as(:service_name) >>
			#type_param_decl.maybe.as(:type_param_decl) >>
			lt_extend_class.maybe.as(:super_class) >>
		k_lwing >>
			service_description.as(:service_versions) >>
		k_rwing
	}

	rule(:service_description) {
		(func | version_label).repeat.as(:service_description)
	}

	rule(:version_label) {
		# terminal
		field_id
	}

	rule(:func) {
		func_modifier.maybe.as(:func_modifier) >>
		return_type.as(:return_type) >>
		func_name.as(:func_name) >>
		k_lparen >>
			func_args.as(:func_args) >>
		k_rparen >>
		throws_classes.maybe.as(:func_throws) >>
		eol
	}

	rule(:func_modifier) {
		k_bang.as(:val_override) |
		k_minus.as(:val_remove) |
		k_plus.as(:val_add)
	}

	sequence :func_args_seq, :k_comma, :field_element

	rule(:func_args) {
		func_args_seq
	}

	sequence :throws_classes_seq, :k_comma, :generic_type, 1

	rule(:throws_classes) {
		k_throws >> throws_classes_seq
	}



	rule(:server) {
		k_server >>
			service_name.as(:server_name) >>
		k_lwing >>
			scope.repeat.as(:server_body) >>
		k_rwing
	}

	rule(:scope) {
		generic_type.as(:scope_type) >>
		field_name.as(:scope_name) >>
		k_default.maybe.as(:scope_default) >>
		eol
	}


	rule(:lt_extend_class) {
		k_lpoint >> generic_type
	}


	rule(:field_type) {
		generic_type.as(:field_type) >> k_question.maybe.as(:field_type_maybe)
	}

	rule(:return_type) {
		field_type
	}

	rule(:generic_type) {
		class_name.as(:generic_type) >> type_param.maybe.as(:type_params)
	}

	sequence :type_param_seq, :k_comma, :generic_type, 1

	rule(:type_param) {
		k_lpoint >> type_param_seq >> k_rpoint
	}

	sequence :type_param_decl_seq, :k_comma, :class_name, 1

	rule(:type_param_decl) {
		k_lpoint >> type_param_decl_seq >> k_rpoint
	}


	rule(:literal) {
		literal_nil | literal_bool | literal_int | literal_float | literal_str | literal_list | literal_map | literal_const
	}

	rule(:literal_nil) {
		k_nil.as(:literal_nil)
	}

	rule(:literal_bool) {
		k_true.as(:literal_true) | k_false.as(:literal_false)
	}

	rule(:literal_const) {
		const_name.as(:literal_const)
	}

	rule(:literal_int) {
		space? >> (
			(str('-') | str('+')).maybe >>
			(str('0') | (match('[1-9]') >> match('[0-9]').repeat))
		).as(:literal_int) >>
		boundary
	}

	rule(:literal_float) {
		space? >> (
			(str('0') | (match('[1-9]') >> match('[0-9]').repeat)) >> str('.') >> match('[0-9]').repeat(1)
		).as(:literal_float) >>
		boundary
	}

	rule(:literal_str_dq) {
		space? >> str('"') >> (
			(str('\\') >> any | str('"').absent? >> any ).repeat
		).as(:literal_str_dq) >>
		str('"')
	}

	rule(:literal_str_sq) {
		space? >> str("'") >> (
			(str('\\') >> any | str("'").absent? >> any ).repeat
		).as(:literal_str_sq) >>
		str("'")
	}

	rule(:literal_str) {
		(literal_str_dq | literal_str_sq).repeat(1).as(:literal_str_seq)
	}

	sequence :literal_list_seq, :k_comma, :literal

	rule(:literal_list) {
		space? >> k_lbracket >>
			literal_list_seq.as(:literal_list) >>
		k_rbracket
	}

	sequence :literal_map_seq, :k_comma, :literal_map_pair

	rule(:literal_map) {
		space? >> k_lwing >>
			literal_map_seq.as(:literal_map) >>
		k_rwing
	}

	rule(:literal_map_pair) {
		literal.as(:literal_map_key) >> k_colon >> literal.as(:literal_map_value)
	}


	rule(:path) {
		# TODO path
		space? >> match('[a-zA-Z0-9_\-\.\ ]').repeat(1).as(:path) >> boundary
	}

	rule(:lang_name) {
		name
	}

	rule(:namespace_name) {
		(name >> ((str('.') | str('::')) >> name).repeat).as(:sequence)
	}

	rule(:const_name) {
		name
	}

	rule(:class_name) {
		name
	}

	rule(:service_name) {
		class_name
	}

	rule(:field_name) {
		name
	}

	rule(:func_name) {
		name
	}

	rule(:name) {
		# terminal
		space? >> (match('[a-zA-Z]') >> match('[a-zA-Z0-9_]').repeat).as(:name) >> boundary
	}


	rule(:inline_comment) {
		str('/*') >> (
			inline_comment |   # accepts nested comments
			(str('*') >> str('/').absent?) |
			(str('*').absent? >> any)
		).repeat >> str('*/')
	}

	rule(:line_comment) {
		(str('//') | str('#')) >>
			(match('[\r\n]').absent? >> any).repeat >>
			match('[\r\n]').repeat(1)
	}

	rule(:comment) {
		inline_comment | line_comment
	}


	rule(:space) {
		(match('[ \r\n\t]') | comment).repeat(1)
	}

	rule(:space?) {
		space.maybe
	}

	rule(:eol) {
		match('[ \t]').repeat >>
			(match('[ \t;\r\n]') | line_comment).repeat(1)
	}

	rule(:boundary) {
		match('[a-zA-Z0-9_]').absent?
	}


	keyword('include')
	keyword('namespace')
	keyword('message')
	keyword('enum')
	keyword('exception')
	keyword('const')
	keyword('typedef')
	keyword('typespec')
	keyword('service')
	keyword('server')
	keyword('optional')
	keyword('required')
	keyword('throws')
	keyword('default')
	keyword('nil')
	keyword('true')
	keyword('false')
	keyword('void')

	separator('*', :k_star)
	separator('=', :k_equal)
	separator('{', :k_lwing)
	separator('}', :k_rwing)
	separator('(', :k_lparen)
	separator(')', :k_rparen)
	separator(':', :k_colon)
	separator(',', :k_comma)
	separator(';', :k_semi)
	separator('<', :k_lpoint)
	separator('>', :k_rpoint)
	separator('[', :k_lbracket)
	separator(']', :k_rbracket)
	separator('!', :k_bang)
	separator('-', :k_minus)
	separator('+', :k_plus)
	separator('?', :k_question)
	separator('.', :k_dot)

	LINE_HEAD_FORMAT = " % 4d: "
	LINE_HEAD_SIZE = (LINE_HEAD_FORMAT % 0).size
	AFTER_BUFFER = 200
	AFTER_LINES = 3
	BEFORE_BUFFER = 200
	BEFORE_LINES = 4

	def print_error(error, fname, out=STDERR)
		error_tree = self.root.error_tree

		last = error_tree
		until last.children.empty?
			last = last.children.last
		end
		last_cause = last.parslet.instance_eval('@last_cause')
		source = last_cause.source

		row, col = source.line_and_column(last_cause.pos)

		old_pos = source.pos
		begin
			source.pos = last_cause.pos - col + 1
			line, *after = source.read(AFTER_BUFFER).to_s.split("\n")
			after = after[0,AFTER_LINES]

			source.pos = last_cause.pos - col - BEFORE_BUFFER
			before = source.read(BEFORE_BUFFER).to_s.split("\n")
			before = before[-BEFORE_LINES,BEFORE_LINES] || []
		ensure
			source.pos = old_pos
		end

		if m = /[ \t\r\n]*/.match(line)
			heading = m[0]
		else
			heading = ""
		end

		out.puts "syntax error:"
		(
			error.to_s.split("\n") +
			error_tree.to_s.split("\n")
		).each {|ln|
			out.puts "  "+ln
		}

		out.puts ""
		out.puts "around line #{row} column #{heading.size}-#{col}:"
		out.puts ""

		before.each_with_index {|ln,i|
			l = row - after.size - 1 + i
			out.print LINE_HEAD_FORMAT % l
			out.puts ln
		}

		out.print LINE_HEAD_FORMAT % row
		out.puts line
		out.print " "*LINE_HEAD_SIZE
		out.puts heading + '^'*(col - heading.size)

		after.each_with_index {|ln,i|
			l = row + 1 + i
			out.print LINE_HEAD_FORMAT % l
			out.puts ln
		}

		out.puts ""

		out
	end
end


end

msgspec_processor.rb

module MessageSpec


class MessageSpecError < StandardError
end

class SyntaxError < MessageSpecError
end

class IncludeError < MessageSpecError
end


class Processor
	require 'stringio'

	def initialize(search_paths = [])
		@parslet = ParsletParser.new
		@visitor = Visitor.new
		@evaluator = nil
		@search_paths = search_paths
		@ast = []
	end

	attr_reader :parslet
	attr_reader :visitor
	attr_reader :evaluator
	attr_reader :ast

	def parse(src, fname, dir)
		begin
			tree = @parslet.parse(src)
			ast = @visitor.apply(tree)
		rescue Parslet::ParseFailed => error
			msg = @parslet.print_error(error, fname, StringIO.new).string
			raise SyntaxError, msg
		end
		ast.each {|e|
			if e.class == AST::Include
				parse_include(e.path, dir, fname)
			else
				@ast << e
			end
		}
		self
	end

	def parse_file(path)
		parse(File.read(path), File.basename(path), File.dirname(path))
	end

	def evaluate
		@evaluator ||= Evaluator.new
		@evaluator.evaluate(@ast)
		self
	end

	def generate(specs, dir)
		# real_type_table
	end

	protected
	def parse_include(inc, dir, fname)
		if dir
			search_paths = @search_paths + [dir]
		else
			search_paths = @search_paths
		end
		search_paths.each {|dir|
			real_path = File.join(dir, inc)
			if File.file?(real_path)
				return parse_file(real_path)
			end
		}
		raise IncludeError, format_include_error(inc, fname)
	end

	def format_include_error(inc, fname)
		[
			"#{fname}:",
			"  Can't include file #{inc}"
		].join("\n")
	end
end


end

msgspec_visitor.rb

module MessageSpec


module AST
	class Element
	end


	module ValueAssigned
		attr_reader :value
	end


	class Document < Array
	end


	class Include
		def initialize(path)
			@path = path
		end

		attr_reader :path
	end


	class Namespace < Element
		def initialize(scopes, lang)
			@scopes = scopes
			@lang = lang
		end

		attr_reader :scopes, :lang

		def scope(separator='::')
			@scopes.join(separator)
		end

		def lang_specific?
			!!@lang
		end
	end


	class Generics < Element
		def initialize(type_params)
			@type_params = type_params
		end

		attr_reader :type_params
	end


	class Message < Element
		def initialize(name, super_class, fields)
			@name = name
			@super_class = super_class
			@fields = fields
		end

		attr_reader :name, :super_class, :fields
	end


	class GenericMessage < Generics
		def initialize(name, super_class, fields, type_params)
			super(type_params)
			@name = name
			@super_class = super_class
			@fields = fields
		end

		attr_reader :name, :super_class, :fields
	end


	class Exception < Message
	end

	class GenericException < GenericMessage
	end


	class Field < Element
		def initialize(field_id, field_type, modifier, name)
			@field_id = field_id
			@field_type = field_type
			@name = name
			@modifier = modifier
		end

		attr_reader :field_id, :field_type, :name

		def required?
			@modifier == FIELD_REQUIRED
		end

		def optional?
			@modifier == FIELD_OPTIONAL
		end
	end


	class ValueAssignedField < Field
		include ValueAssigned

		def initialize(field_id, type, modifier, name, value)
			@field_id = field_id
			@type = type
			@modifier = modifier
			@name = name
			@value = value
		end
	end


	class Enum < Element
		def initialize(name, fields)
			@name = name
			@fields = fields
		end

		attr_reader :name, :fields
	end

	class EnumField < Element
		def initialize(field_id, name)
			@field_id = field_id
			@name = name
		end
	end


	class Typedef < Element
		def initialize(type, new_type)
			@type = type
			@new_type = new_type
		end

		attr_reader :type, :new_type
	end


	class GenericTypedef < Generics
		def initialize(type, new_type, type_params)
			super(type_params)
			@type = type
			@new_type = new_type
		end

		attr_reader :type, :new_type
	end


	class Const < Element
		include ValueAssigned

		def initialize(field_type, name, value)
			@field_type = field_type
			@name = name
			@value = value
		end

		attr_reader :field_type, :name
	end


	class FieldSpec < Element
		def initialize(name, target_class, target_field, spec)
			@name = name
			@target_class = target_class
			@target_field = target_field
			@spec = spec
		end

		attr_reader :name, :target_class, :target_field, :spec
	end

	class GenericFieldSpec < Generics
		def initialize(name, target_class, target_field, spec, type_params)
			super(type_params)
			@name = name
			@target_class = target_class
			@target_field = target_field
			@spec = spec
		end

		attr_reader :name, :target_class, :target_field, :spec
	end

	class TypeSpec < Element
		def initialize(name, target_type, spec)
			@name = name
			@target_type = target_type
			@spec = spec
		end

		attr_reader :name, :target_type, :spec
	end

	class GenericTypeSpec < Generics
		def initialize(name, target_type, spec, type_params)
			super(type_params)
			@name = name
			@target_type = target_type
			@spec = spec
		end

		attr_reader :name, :target_type, :spec
	end

	class LangType < Element
		def initialize(tokens)
			@tokens = tokens
		end

		attr_reader :tokens
	end


	class Service < Element
		def initialize(name, super_class, versions)
			@name = name
			@super_class = super_class
			@versions = versions
		end

		attr_reader :name, :super_class, :versions
	end

	class ServiceVersion < Element
		def initialize(version, funcs)
			@version = version
			@funcs = funcs
		end

		attr_reader :version, :funcs
	end


	class Server < Element
		def initialize(name, scopes)
			@name = name
			@scopes = scopes
		end

		attr_reader :name
		attr_reader :scopes
	end


	class Scope < Element
		def initialize(type, name, default)
			@type = type
			@name = name
			@default = default
		end

		attr_reader :type, :name

		def default?
			@default
		end
	end


	class Func < Element
		def initialize(name, modifier, return_type, args, exceptions)
			@name = name
			@modifier = modifier
			@return_type = return_type
			@args = args
			@exceptions = exceptions
		end

		attr_reader :name, :return_type, :args, :exceptions

		def override?
			@modifier == FUNC_OVERRIDE
		end

		def remove?
			@modifier == FUNC_REMOVE
		end

		def add?
			@modifier == FUNC_ADD
		end

		attr_reader :modifier

		def has_exceptions?
			!@exceptions.empty?
		end
	end


	class FieldType
		def initialize(type, nullable)
			@type = type
			@nullable = nullable
		end

		attr_reader :type

		def nullable?
			@nullable
		end
	end


	class Type < Element
		def initialize(name)
			@name = name
		end

		attr_reader :name
	end

	class GenericSpecifiedType < Type
		def initialize(name, type_params)
			super(name)
			@type_params = type_params
		end

		attr_reader :type_params
	end


	class Literal
	end

	class ConstLiteral < Literal
		def initialize(name)
			@name = name
		end
	end

	class IntLiteral < Literal
		def initialize(value)
			@value = value
		end
	end

	class FlaotLiteral < Literal
		def initialize(value)
			@value = value
		end
	end

	class NilLiteral < Literal
	end

	class BoolLiteral < Literal
	end

	class TrueLiteral < BoolLiteral
	end

	class FalseLiteral < BoolLiteral
	end

	class StringLiteral < Literal
		def initialize(value)
			@value = value
		end
	end

	# TODO container literal
	#class ListLiteral < Literal
	#	def initialize(array)
	#		@array = array
	#	end
	#end

	# TODO container literal
	#class MapLiteralPair
	#	def initialize(k, v)
	#		@key = k
	#		@value = v
	#	end
	#end

	# TODO container literal
	#class MapLiteral < Literal
	#	def initialize(pairs)
	#		@pairs = pairs
	#	end
	#end


	FIELD_OPTIONAL = :optional
	FIELD_REQUIRED = :required

	FUNC_OVERRIDE = :override
	FUNC_REMOVE = :remove
	FUNC_ADD = :add


	class Sequence < Array
	end
end


class Visitor < Parslet::Transform
	rule(:name => simple(:n)) {
		n.to_s
	}


	rule(:sequence_x => simple(:x)) {
		x
	}

	rule(:sequence_xs => simple(:xs)) {
		xs
	}

	rule(:sequence => simple(:x)) {
		x ? AST::Sequence.new([x]) : AST::Sequence.new
	}

	rule(:sequence => sequence(:x)) {
		AST::Sequence.new(x)
	}


	rule(:val_int => simple(:i)) {
		i.to_i
	}

	rule(:val_optional => simple(:x)) {
		AST::FIELD_OPTIONAL
	}

	rule(:val_required => simple(:x)) {
		AST::FIELD_REQUIRED
	}

	rule(:val_override => simple(:x)) {
		AST::FUNC_OVERRIDE
	}

	rule(:val_remove => simple(:x)) {
		AST::FUNC_REMOVE
	}

	rule(:val_add => simple(:x)) {
		AST::FUNC_ADD
	}


	rule(:generic_type => simple(:n),
			 :type_params => simple(:tp)) {
		if tp
			AST::GenericSpecifiedType.new(n, tp)
		else
			AST::Type.new(n)
		end
	}


	rule(:field_id => simple(:i),
			 :field_modifier => simple(:m),
			 :field_type => simple(:t),
			 :field_name => simple(:n),
			 :field_default => simple(:v)) {
		m ||= AST::FIELD_REQUIRED
		if v == nil
			AST::Field.new(i, t, m, n)
		else
			AST::ValueAssignedField.new(i, t, m, n, v)
		end
	}

	rule(:field_type => simple(:t),
			 :field_type_maybe => simple(:n)) {
		if n
			AST::FieldType.new(t, true)
		else
			AST::FieldType.new(t, false)
		end
	}


	rule(:lang_type_token => simple(:t)) {
		t.to_s
	}

	rule(:lang_type_tokens => sequence(:ts)) {
		AST::LangType.new(ts)
	}


	rule(:literal_const => simple(:n)) {
		AST::ConstLiteral.new(n)
	}

	rule(:literal_int => simple(:i)) {
		AST::IntLiteral.new(i.to_i)
	}

	rule(:literal_float => simple(:f)) {
		AST::FloatLiteral.new(f.to_f)
	}

	rule(:literal_str_dq => simple(:s)) {
		s.to_s.gsub(/\\(.)/) {|e|
			eval("\"\\#{$~[1]}\"")  # TODO escape
		}
	}

	rule(:literal_str_sq => simple(:s)) {
		s.to_s
	}

	rule(:literal_str_seq => sequence(:ss)) {
		AST::StringLiteral.new(ss.join)
	}

	rule(:literal_nil => simple(:_)) {
		AST::NilLiteral.new
	}

	rule(:literal_true => simple(:_)) {
		AST::TrueLiteral.new
	}

	rule(:literal_false => simple(:_)) {
		AST::FalseLiteral.new
	}

	# TODO container literal
	#rule(:literal_list => simple(:a)) {
	#	AST::ListLiteral.new(Array.new(a))
	#}

	# TODO container literal
	#rule(:literal_map => simple(:ps)) {
	#	AST::MapLiteral.new(Array.new(ps))
	#}

	# TODO container literal
	#rule(:literal_map_key => simple(:k), :literal_map_value => simple(:v)) {
	#	AST::MapLiteralPair.new(k, v)
	#}


	rule(:type_param_decl => simple(:tp),
			 :message_name => simple(:n),
			 :message_body => sequence(:b),
			 :super_class => simple(:sc)) {
		if tp
			AST::GenericMessage.new(n, sc, b, tp)
		else
			AST::Message.new(n, sc, b)
		end
	}

	rule(:type_param_decl => simple(:tp),
			 :exception_name => simple(:n),
			 :exception_body => sequence(:b),
			 :super_class => simple(:sc)) {
		if tp
			AST::GenericException.new(n, sc, b, tp)
		else
			AST::Exception.new(n, sc, b)
		end
	}


	rule(:const_type => simple(:t),
			 :const_name => simple(:n),
			 :const_value => simple(:v)) {
		AST::Const.new(t, n, v)
	}


	rule(:type_param_decl => simple(:tp),
			 :typedef_type => simple(:t),
			 :typedef_name => simple(:n)) {
		if tp
			AST::GenericTypedef.new(t, n, tp)
		else
			AST::Typedef.new(t, n)
		end
	}


	rule(:type_param_decl => simple(:tp),
			 :typespec_lang => simple(:n),
			 :typespec_class => simple(:c),
			 :typespec_field => simple(:f),
			 :typespec_spec => simple(:s)) {
		if tp
			AST::GenericFieldSpec.new(n, c, f, s, tp)
		else
			AST::FieldSpec.new(n, c, f, s)
		end
	}

	rule(:type_param_decl => simple(:tp),
			 :typespec_lang => simple(:n),
			 :typespec_type => simple(:t),
			 :typespec_spec => simple(:s)) {
		if tp
			AST::GenericTypeSpec.new(n, t, s, tp)
		else
			AST::TypeSpec.new(n, t, s)
		end
	}


	rule(:enum_field_id => simple(:i),
			 :enum_field_name => simple(:n)) {
		AST::EnumField.new(i, n)
	}

	rule(:enum_name => simple(:n),
			 :enum_body => sequence(:b)) {
		AST::Enum.new(n, b)
	}


	rule(:func_modifier => simple(:m),
			 :return_type => simple(:rt),
			 :func_name => simple(:n),
			 :func_args => simple(:a),
			 :func_throws => simple(:ex)) {
		AST::Func.new(n, m, rt, a, ex)
	}

	rule(:service_description => sequence(:s)) {
		current = AST::ServiceVersion.new(0, [])
		versions = [current]
		s.each {|l|
			case l
			when Integer
				v = versions.find {|v| v.version == l }
				if v
					current = v
				else
					current = AST::ServiceVersion.new(l, [])
					versions << current
				end
			else
				current.funcs << l
			end
		}
		versions
	}

	rule(:service_name => simple(:n),
			 :service_versions => sequence(:vs),
			 :super_class => simple(:sc)) {
		AST::Service.new(n, sc, vs)
	}


	rule(:scope_type => simple(:t),
			 :scope_name => simple(:n),
			 :scope_default => simple(:d)) {
		if d
			AST::Scope.new(t, n, true)
		else
			AST::Scope.new(t, n, false)
		end
	}

	rule(:server_name => simple(:n),
			 :server_body => sequence(:b)) {
		AST::Server.new(n, b)
	}


	rule(:namespace_name => simple(:n)) {
		AST::Namespace.new(n, nil)
	}

	rule(:namespace_name => simple(:n),
			 :namespace_lang => simple(:l)) {
		AST::Namespace.new(n, l)
	}


	rule(:path => simple(:n)) {
		n
	}

	rule(:include => simple(:n)) {
		AST::Include.new(n.to_s)
	}

	rule(:document => sequence(:es)) {
		AST::Document.new(es)
	}
end


end