msgpack-idl 0.1.0 → 0.1.1

data/lib/msgpack/idl/command/vimcolor.rb

@@ -0,0 +1,254 @@
+#
+# VimColor for Ruby
+#
+# Copyright (c) 2008-2011 FURUHASHI Sadayuki
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+class VimColor
+	VIM_COMMAND = "vim"
+	VIM_OPTIONS = %w[-R -X -Z -i NONE -u NONE -N]
+	VIM_PRESET  = ["+set nomodeline", '+set expandtab'] # +set shiftwidth
+	VIM_POSTSET = [":let b:is_bash=1", ":filetype on"]
+	VIM_MARK_SCRIPT = File.join(File.dirname(__FILE__), 'vimcolor', 'mark.vim')
+	VIM_UNESCAPE = {'&l' => '<', '&g' => '>', '&a' => '&'}
+
+	def initialize(command=nil, options=nil, preset=nil, postset=nil)
+		require 'tempfile'
+		@command = VIM_COMMAND.dup
+		@options = VIM_OPTIONS + (options || [])
+		@preset  = VIM_PRESET  + (preset  || [])
+		@postset = VIM_POSTSET + (postset || [])
+	end
+
+	attr_accessor :command, :options, :preset, :postset
+
+	def run_file(path, options, formatter_class, *formatter_args)
+		preset = @preset.dup
+		postset = @postset.dup
+
+		if formatter_class.class == Symbol
+			formatter_class = self.class.const_get("Format_#{formatter_class}")
+		end
+
+		if options.is_a? Hash
+			if options.include? :filetype
+				postset.unshift(":set filetype=#{options[:filetype]}")
+			end
+			if options.include? :encoding
+				preset.unshift("+set encoding=#{options[:encoding]}")
+			end
+		else
+			postset.unshift(":set filetype=#{options}")
+		end
+
+		vimout = nil
+		tmp_stream = Tempfile.new('ruby-vimcolor')
+		begin
+			tmp_path = tmp_stream.path
+			tmp_stream.puts <<SCRIPT
+:syntax on
+#{postset.join("\n")}
+:source #{VIM_MARK_SCRIPT}
+:write! #{tmp_path}
+:qall!
+
+SCRIPT
+			tmp_stream.flush
+			pid = Process.fork {
+				STDIN.reopen "/dev/null"
+				STDOUT.reopen "/dev/null", "a"
+				STDERR.reopen "/dev/null", "a"
+				args = []
+				args.concat @options
+				args.concat ['-s', tmp_path]
+				args.push path
+				args.concat preset
+				exec(@command, *args)
+				exit 127
+			}
+			Process.waitpid(pid)
+			tmp_stream.seek(0)
+			vimout = tmp_stream.read
+		ensure
+			tmp_stream.close
+		end
+
+		require 'strscan'
+		s = StringScanner.new(vimout)
+
+		formatter = formatter_class.new(*formatter_args)
+		while s.scan_until(/(.*?)>(.*?)>(.*?)<\2</m)
+			formatter.push('', s[1]) unless s[1].empty?
+			type = s[2]
+			text = s[3]
+			text.gsub!(/&[agl]/) do
+				VIM_UNESCAPE[$&]
+			end
+			formatter.push(type, text)
+		end
+		formatter.result
+	end
+
+
+	def run_stream(stream, options, formatter_class, *formatter_args)
+		tmp_in = Tempfile.new('ruby-vimcolor-input')
+		begin
+			tmp_in.write(stream.read)
+			tmp_in.flush
+			run_file(tmp_in.path, options, formatter_class, *formatter_args)
+		ensure
+			tmp_in.close
+		end
+	end
+
+
+	def run(str, options, formatter_class, *formatter_args)
+		tmp_in = Tempfile.new('ruby-vimcolor-input')
+		begin
+			tmp_in.write(str)
+			tmp_in.flush
+			run_file(tmp_in.path, options, formatter_class, *formatter_args)
+		ensure
+			tmp_in.close
+		end
+	end
+end
+
+
+
+class VimColor
+
+	class Format_array
+		def initialize
+			@result = []
+		end
+		def push(type, text)
+			@result.push [type, text]
+		end
+		attr_reader :result
+	end
+
+
+	class Format_xml
+		def initialize
+			@result = ''
+		end
+		def push(type, text)
+			VimColor._escape_xml!(text)
+			type = 'Normal' if type.empty?
+			@result << %[<#{type}>#{text}</#{type}>]
+		end
+		attr_reader :result
+	end
+
+
+	class Format_html
+		def initialize(class_prefix = 'syn')
+			@result = ''
+			@prefix = class_prefix
+		end
+		def push(type, text)
+			VimColor._escape_xml!(text)
+			if type.empty?
+				@result << text
+			else
+				@result << %[<span class="#{@prefix}#{type}">#{text}</span>]
+			end
+		end
+		attr_reader :result
+	end
+
+
+	def self._escape_xml!(text)
+		text.gsub!("&", "&amp;")
+		text.gsub!("<", "&lt;")
+		text.gsub!(">", "&gt;")
+		text.gsub!("'", "&#39;")
+		text.gsub!('"', "&quot;")
+		text
+	end
+
+
+	class Format_ansi
+		AnsiCodes = {
+			:normal        =>  0,
+			:reset         =>  0,
+			:bold          =>  1,
+			:dark          =>  2,
+			:italic        =>  3,
+			:underline     =>  4,
+			:blink         =>  5,
+			:rapid_blink   =>  6,
+			:negative      =>  7,
+			:concealed     =>  8,
+			:strikethrough =>  9,
+			:black         => 30,
+			:red           => 31,
+			:green         => 32,
+			:yellow        => 33,
+			:blue          => 34,
+			:magenta       => 35,
+			:cyan          => 36,
+			:white         => 37,
+			:on_black      => 40,
+			:on_red        => 41,
+			:on_green      => 42,
+			:on_yellow     => 43,
+			:on_blue       => 44,
+			:on_magenta    => 45,
+			:on_cyan       => 46,
+			:on_white      => 47,
+		}
+		def initialize(colors = {})
+			@result = ''
+			@colors = Hash.new([])
+			@colors.merge!({
+				'Comment'    => [ :cyan ],
+				'Constant'   => [ :red ],
+				'Identifier' => [ :green  ],
+				'Statement'  => [ :yellow ],
+				'PreProc'    => [ :magenta ],
+				'Type'       => [ :green ],
+				'Special'    => [ :magenta ],
+				'Underlined' => [ :underline ],
+				'Error'      => [ :red ],
+				'Todo'       => [ :black, :on_yellow ],
+			})
+			@colors.merge!(colors)
+		end
+		def push(type, text)
+			seq = ''
+			codes = @colors[type].dup
+			codes.unshift(:reset)
+			codes.each {|c|
+				num = AnsiCodes[c]
+				seq << "\e[#{num}m" if num
+			}
+			@result << seq << text
+		end
+		def result
+			@result << "\e[0m"
+			@result
+		end
+	end
+
+end
+

data/lib/msgpack/idl/command/vimcolor/mark.vim

@@ -0,0 +1,67 @@
+" mark.vim - turn Vim syntax highlighting into an ad-hoc markup language that
+" can be parsed by the Text::VimColor Perl module.
+"
+" Maintainer: Geoff Richards <qef@laxan.com>
+" Based loosely on 2html.vim, by Bram Moolenaar <Bram@vim.org>,
+"   modified by David Ne\v{c}as (Yeti) <yeti@physics.muni.cz>.
+
+set report=1000000
+
+" For some reason (I'm sure it used to work) we now need to get Vim
+" to make another attempt to detect the filetype if it wasn't set
+" explicitly.
+if !strlen(&filetype)
+   filetype detect
+endif
+"syn on
+
+" Set up the output buffer.
+new
+set modifiable
+set paste
+
+" Expand tabs. Without this they come out as '^I'.
+set isprint+=9
+
+wincmd p
+
+" Loop over all lines in the original text
+let s:end = line("$")
+let s:lnum = 1
+while s:lnum <= s:end
+
+  " Get the current line
+  let s:line = getline(s:lnum)
+  let s:len = strlen(s:line)
+  let s:new = ""
+
+  " Loop over each character in the line
+  let s:col = 1
+  while s:col <= s:len
+    let s:startcol = s:col " The start column for processing text
+    let s:id = synID(s:lnum, s:col, 1)
+    let s:col = s:col + 1
+    " Speed loop (it's small - that's the trick)
+    " Go along till we find a change in synID
+    while s:col <= s:len && s:id == synID(s:lnum, s:col, 1) | let s:col = s:col + 1 | endwhile
+
+    " Output the text with the same synID, with class set to c{s:id}
+    let s:id = synIDtrans(s:id)
+    let s:name = synIDattr(s:id, 'name')
+    let s:new = s:new . '>' . s:name . '>' . substitute(substitute(substitute(strpart(s:line, s:startcol - 1, s:col - s:startcol), '&', '\&a', 'g'), '<', '\&l', 'g'), '>', '\&g', 'g') . '<' . s:name . '<'
+
+    if s:col > s:len
+      break
+    endif
+  endwhile
+
+  exe "normal \<C-W>pa" . strtrans(s:new) . "\n\e\<C-W>p"
+  let s:lnum = s:lnum + 1
+  +
+endwhile
+
+" Strip whitespace from the ends of lines
+%s:\s\+$::e
+
+wincmd p
+normal dd

data/lib/msgpack/idl/command/vimcolor/msgspec.vim

@@ -0,0 +1,68 @@
+
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+syn case match
+
+" Todo
+syn keyword msgspecTodo TODO FIXME XXX contained
+
+" Comments
+syn match msgspecComment "#.*" contains=msgspecTodo
+syn match msgspecComment "\/\/.*$" contains=msgspecTodo
+syn region msgspecComment start="/\*" end="\*/" contains=msgspecTodo,msgspecComment
+
+" Literal
+syn match msgspecString "'\(\\.\|[^'\\]\)*'"
+syn match msgspecString "\"\(\\.\|[^\"\\]\)*\""
+syn match msgspecNumber "\<[0-9][0-9]*\(\.[0-9][0-9]*\)\?\>"
+syn keyword msgspecBoolean true false
+
+" Keywords
+syn keyword msgspecKeyword default
+syn keyword msgspecDeclareKeyword include namespace
+syn keyword msgspecTypeKeyword const typedef typespec
+syn keyword msgspecStructure interface service message exception enum application
+"syn keyword msgspecStructureDeclaration import
+syn keyword msgspecException throws
+syn keyword msgspecModifier required optional
+syn keyword msgspecBasicType void
+syn keyword msgspecBasicType byte int short long
+syn keyword msgspecBasicType ubyte uint ushort ulong
+syn keyword msgspecBasicType float double bool string raw
+syn keyword msgspecContainerType map list
+"syn match msgspecSpecial "?"
+syn keyword msgspecSpecial inherit
+"syn keyword msgspecSpecial obsolete
+
+" Special
+syn match msgspecId "\<\d\+:"
+syn match msgspecServiceVersion ":\d\+\>"
+
+" Block
+syn region msgspecBlock matchgroup=NONE start="{" end="}" contains=@msgspecBlockItems
+syn cluster msgspecBlockItems contains=msgspecComment,msgspecString,msgspecNumber,msgspecKeyword,msgspecId,msgspecServiceVersion,msgspecStructureDeclaration,msgspecException,msgspecModifier,msgspecBasicType,msgspecContainerType,msgspecSpecial,msgspecBlock
+
+hi link msgspecTodo Todo
+hi link msgspecComment Comment
+hi link msgspecString String
+hi link msgspecNumber Number
+hi link msgspecBoolean Boolean
+hi link msgspecTypeKeyword Type
+hi link msgspecStructure Structure
+hi link msgspecStructureDeclaration Special
+hi link msgspecException Exception
+hi link msgspecModifier Special
+hi link msgspecDeclareKeyword PreProc
+hi link msgspecKeyword Keyword
+hi link msgspecBasicType Type
+hi link msgspecSpecial Special
+"hi link msgspecContainerType Type
+hi link msgspecId Label
+hi link msgspecServiceVersion Label
+
+let b:current_syntax = "msgspec"
+

data/lib/msgpack/idl/error.rb

@@ -49,7 +49,7 @@ end
 class TypeError < SemanticsError
 end
 
-class InheritanceError < IDLError
+class InheritanceError < SemanticsError
 end
 
 class GeneratorError < IDLError

data/lib/msgpack/idl/evaluator.rb

@@ -55,16 +55,42 @@ class Evaluator
 		end
 	end
 
+	class InheritAllMark
+		def initialize(ast)
+			@ast = ast
+		end
+		attr_reader :ast
+		def name
+			""
+		end
+	end
+
+	class InheritMark
+		def initialize(ast, name)
+			@ast = ast
+			@name = name
+		end
+		attr_reader :ast, :name
+	end
+
+	class InheritMarkWithCheck < InheritMark
+		def initialize(ast, func)
+			super(ast, func.name)
+			@func = func
+		end
+		attr_reader :func
+	end
+
 	def initialize
 		@names = {}  # name:String => AST::Element
 
 		@types = {}  # name:String => AST::Type
 		@generic_types = []  # Template
 
-		@global_namespace = ""   # Namespace
+		@global_namespace = [""]   # Namespace
 		@lang_namespace = {}     # lang:String => scope:Namespace
 
-		@services = []  # name:String => IR::Service
+		@service_versions = {} # serviceName:String => (IR::Service, [(IR::ServiceVersion, AST::ServiceVersion)])
 
 		init_built_in
 
@@ -89,7 +115,7 @@ class Evaluator
 			if e.super_class
 				super_message = resolve_type(e.super_class)
 				if !super_message.is_a?(IR::Exception)
-					raise InvalidNameError, "`#{e.super_class}' is not a #{IR::Exception} but a #{super_message.class}"
+					raise InvalidNameError, "Super class of the exception `#{e.super_class}' must be an exception"
 				end
 			end
 			new_fields = resolve_fields(e.fields, super_message)
@@ -100,7 +126,7 @@ class Evaluator
 			if e.super_class
 				super_message = resolve_type(e.super_class)
 				if !super_message.is_a?(IR::Message)
-					raise InvalidNameError, "`#{e.super_class}' is not a #{IR::Message} but a #{super_message.class}"
+					raise InvalidNameError, "Super class of the message `#{e.super_class}' must be a message"
 				end
 			end
 			new_fields = resolve_fields(e.fields, super_message)
@@ -113,9 +139,9 @@ class Evaluator
 
 		when AST::Service
 			v = e.version || 0
-			s = check_service_version(e.name, v)
-			funcs = resolve_funcs(e.funcs)
-			add_service_version(s, e.name, v, funcs)
+			check_service_version(e.name, v)
+			funcs = resolve_service_partial(e.functions)
+			add_service_version(e, e.name, v, funcs)
 
 		when AST::Application
 			check_name(e.name, e)
@@ -123,34 +149,93 @@ class Evaluator
 			add_application(e.name, scopes)
 
 		else
-			raise SemanticsError, "Unknown toplevel AST element `#{e.class}': #{e.inspect}"
+			raise SemanticsError, "Unknown toplevel AST element `#{e.class}'"
 		end
+
+	rescue => error
+		raise_error(error, e)
 	end
 
 	def evaluate_inheritance
-		@services.each {|s|
+		@ir_services = @service_versions.values.map {|s,versions|
+			versions = versions.sort_by {|sv,ast| sv.version }
+
 			super_versions = []
-			s.versions = s.versions.sort_by {|sv| sv.version }
-			s.versions.each do |sv|
-
-				sv.functions.each {|f|
-					f.super_version = nil
-					f.super_func = nil
-					super_versions.reverse_each do |ssv|
-						if sf = ssv.functions.find {|sf| sf.name == f.name }
-							if f.args == sf.args && f.return_type == sf.return_type
-								f.super_version = ssv.version
-								f.super_func = sf
+			versions.each do |sv,ast|
+				begin
+					real_functions = []
+					sv.functions.each {|f|
+						case f
+						when InheritAllMark
+							begin
+								if super_versions.empty?
+									raise InheritanceError, "Inherit on the oldest version is invalid"
+								end
+								last = super_versions.last
+								last.functions.each {|ifunc|
+									real_functions << IR::InheritedFunction.new(last.version, ifunc)
+								}
+							rescue => error
+								raise_error(error, f.ast)
 							end
-							break
+
+						when InheritMark
+							begin
+								if super_versions.empty?
+									raise InheritanceError, "Inherit on the oldest version is invalid"
+								end
+								inherit_func = nil
+								inherit_version = nil
+								super_versions.reverse_each do |ssv|
+									inherit_func = ssv.functions.find {|ifunc| f.name == ifunc.name }
+									if inherit_func
+										inherit_version = ssv.version
+										break
+									end
+								end
+
+								unless inherit_func
+									raise InheritanceError, "No such function: #{f.name}"
+								end
+
+								if f.is_a?(InheritMarkWithCheck)
+									if inherit_func.args != f.func.args ||
+											inherit_func.return_type != f.func.return_type ||
+											inherit_func.exceptions != f.func.exceptions
+										raise InheritanceError, "Function signature is mismatched with #{s.name}:#{inherit_version}.#{f.name}"
+									end
+								end
+
+								real_functions << IR::InheritedFunction.new(inherit_version, inherit_func)
+							rescue => error
+								raise_error(error, f.ast)
+							end
+
+						when IR::Function
+							real_functions << f
+
+						else
+							raise "Unknown partially evaluated function: #{f.inspect}"
 						end
+					}
+
+					if real_functions.uniq!
+						# may be caused by InheritAllMark
+						# FIXME show warning?
 					end
-				}
 
-				super_versions << sv
+					sv.functions = real_functions
+
+					super_versions << sv
+				rescue => error
+					raise_error(error, ast)
+				end
 			end
+			s.versions = super_versions
+
+			s
 		}
-		@ir_services = @services
+
 		self
 	end
 
@@ -164,6 +249,22 @@ class Evaluator
 	end
 
 	private
+	def raise_error(error, ast = nil)
+		if ast
+			msg = %[#{error.message}
+
+while processing:
+#{ast.summary.split("\n").map {|l| "  #{l}" }.join("\n")}]
+
+		else
+			msg = error.message
+		end
+
+		wrap = error.class.new(msg)
+		wrap.set_backtrace(error.backtrace)
+		raise wrap
+	end
+
 	def spec_namespace(lang)
 		if ns = @lang_namespace[lang]
 			return ns
@@ -186,7 +287,7 @@ class Evaluator
 
 	def check_name(name, e)
 		if ee = @names[name]
-			raise DuplicatedNameError, "duplicated name `#{name}': #{e.inspect}"
+			raise DuplicatedNameError, "Duplicated name `#{name}'"
 		end
 		@names[name] = e
 	end
@@ -195,7 +296,7 @@ class Evaluator
 	def resolve_simple_type(e)
 		type = @types[e.name]
 		unless type
-			raise NameNotFoundError, "type not found: #{e.name}"
+			raise NameNotFoundError, "Type not found `#{e.name}'"
 		end
 		if e.nullable? && !type.is_a?(IR::NullableType)
 			IR::NullableType.new(type)
@@ -217,7 +318,7 @@ class Evaluator
 			end
 		}
 		unless resolved_types
-			raise NameNotFoundError, "generic type not matched: #{e.name}"
+			raise NameNotFoundError, "Generic type not matched `#{e.name}'"
 		end
 		type = IR::ParameterizedType.new(resolved_types, template.generic_type)
 		if template.nullable || e.nullable?
@@ -249,42 +350,46 @@ class Evaluator
 		end
 
 		new_fields = fields.map {|e|
-			if e.id == 0
-				raise InvalidNameError, "field id 0 is invalid"
-			end
-			if e.id < 0
-				raise InvalidNameError, "field id < 0 is invalid"
-			end
-			if n = used_ids[e.id]
-				raise DuplicatedNameError, "duplicated field id #{e.id}: #{n}, #{e.name}"
-			end
-			if used_names[e.name]
-				raise DuplicatedNameError, "duplicated field name: #{e.name}"
-			end
-			if super_used_ids[e.id]
-				raise InheritanceError, "field id is duplicated with super class: #{e.is}"
-			end
-			if super_used_names[e.name]
-				raise InheritanceError, "field name is duplicated with super class: #{e.name}"
-			end
+			begin
+				if e.id == 0
+					raise InvalidNameError, "Field id 0 is invalid"
+				end
+				if e.id < 0
+					raise InvalidNameError, "Field id < 0 is invalid"
+				end
+				if n = used_ids[e.id]
+					raise DuplicatedNameError, "Field id #{e.id} is duplicated with field `#{n}'"
+				end
+				if i = used_names[e.name]
+					raise DuplicatedNameError, "Field name `#{e.name}' is duplicated with id #{i}"
+				end
+				if super_used_ids[e.id]
+					raise InheritanceError, "Field id #{e.id} is duplicated with super class `#{e.name}'"
+				end
+				if super_used_names[e.name]
+					raise InheritanceError, "Field name is duplicated with super class `#{e.name}'"
+				end
 
-			used_ids[e.id] = e.name
-			used_names[e.name] = e.name
+				used_ids[e.id] = e.name
+				used_names[e.name] = e.id
 
-			type = resolve_type(e.type)
-			if e.modifier == AST::FIELD_OPTIONAL
-				option  = IR::FIELD_OPTIONAL
-			else
-				option  = IR::FIELD_REQUIRED
-			end
+				type = resolve_type(e.type)
+				if e.modifier == AST::FIELD_OPTIONAL
+					option  = IR::FIELD_OPTIONAL
+				else
+					option  = IR::FIELD_REQUIRED
+				end
 
-			if e.is_a?(AST::ValueAssignedField)
-				v = resolve_initial_value(type, e.value)
-			else
-				v = resolve_implicit_value(type)
-			end
+				if e.is_a?(AST::ValueAssignedField)
+					v = resolve_initial_value(type, e.value)
+				else
+					v = resolve_implicit_value(type)
+				end
 
-			IR::Field.new(e.id, type, e.name, option, v)
+				IR::Field.new(e.id, type, e.name, option, v)
+			rescue => error
+				raise_error(error, e)
+			end
 		}.sort_by {|f|
 			f.id
 		}
@@ -327,21 +432,21 @@ class Evaluator
 		when AST::EnumLiteral
 			enum = resolve_type(e.name)
 			if !enum.is_a?(IR::Enum)
-				raise NameNotFoundError, "not a enum type: #{e.name}"
+				raise NameNotFoundError, "Not a enum type `#{e.name}'"
 			end
 			f = enum.fields.find {|f|
 				f.name == e.field
 			}
 			if !f
-				raise NameNotFoundError, "no such field in enum `#{e.name}': #{e.field}"
+				raise NameNotFoundError, "No such field at enum `#{e.name}': #{e.field}"
 			end
 			IR::EnumValue.new(enum, f)
 
 		when AST::ConstLiteral
-			raise NameNotFoundError, "unknown constant: #{name}"
+			raise NameNotFoundError, "Unknown constant `#{name}'"
 
 		else
-			raise SemanticsError, "Unknown literal type: #{e.class}"
+			raise SemanticsError, "unknown literal type: #{e.class}"
 		end
 
 		check_assignable(type, v)
@@ -350,24 +455,24 @@ class Evaluator
 
 	def check_assignable(type, v)
 		if type.nullable_type? && v != IR::NilValue.nil
-			raise TypeError, "not-nullable value for nullable type is not allowed"
+			raise TypeError, "Non-null value for nullable type is not allowed"
 		end
 
 		case v
 		when IR::NilValue
 			unless type.nullable_type?
-				raise TypeError, "nullable is expected: #{type}"
+				raise TypeError, "Assigning null to non-nullable field"
 			end
 
 		when IR::IntValue
 			unless IR::Primitive::INT_TYPES.include?(type)
-				raise TypeError, "integer type is expected: #{type}"
+				raise TypeError, "Integer type is expected: #{type}"
 			end
 			# TODO overflow
 
 		when IR::BoolValue
 			if type != IR::Primitive::bool
-				raise TypeError, "bool type is expected: #{type}"
+				raise TypeError, "Bool type is expected: #{type}"
 			end
 
 		end
@@ -386,7 +491,7 @@ class Evaluator
 
 		elsif t.is_a?(IR::Enum)
 			if t.fields.empty?
-				raise TypeError, "empty enum: #{t.name}"
+				raise TypeError, "Empty enum is not allowed: enum #{t.name}"
 			end
 			IR::EnumValue.new(t, t.fields.first)
 
@@ -400,20 +505,24 @@ class Evaluator
 		used_names = {}
 
 		fields = fields.map {|e|
-			if e.id < 0
-				raise InvalidNameError, "enum id < 0 is invalid"
-			end
-			if n = used_ids[e.id]
-				raise DuplicatedNameError, "duplicated enum id #{e.id}: #{n}, #{e.name}"
-			end
-			if used_names[e.name]
-				raise DuplicatedNameError, "duplicated field name: #{e.name}"
-			end
+			begin
+				if e.id < 0
+					raise InvalidNameError, "Enum id < 0 is invalid"
+				end
+				if n = used_ids[e.id]
+					raise DuplicatedNameError, "Enum field id #{e.id} is duplicated with `#{n}'"
+				end
+				if i = used_names[e.name]
+					raise DuplicatedNameError, "Enum field name `#{e.name}' is duplicated with id #{i}"
+				end
 
-			used_ids[e.id] = e.name
-			used_names[e.name] = e.name
+				used_ids[e.id] = e.name
+				used_names[e.name] = e.id
 
-			IR::EnumField.new(e.id, e.name)
+				IR::EnumField.new(e.id, e.name)
+			rescue => error
+				raise_error(error, e)
+			end
 		}.sort_by {|f|
 			f.id
 		}
@@ -422,39 +531,52 @@ class Evaluator
 	end
 
 	def check_service_version(name, version)
-		s = @services.find {|s|
-			s.name == name
-		}
+		s, versions = @service_versions[name]
 		if s
-			s.versions.each {|sv|
+			versions.each {|sv,ast|
 				if sv.version == version
-					raise DuplicatedNameError, "duplicated version #{version}"
+					raise DuplicatedNameError, "Duplicated version #{version}"
 				end
 			}
 		else
 			check_name(name, nil)
 		end
-		s
+		nil
 	end
 
-	def resolve_funcs(funcs)
+	def resolve_service_partial(funcs)
 		used_names = {}
 
 		funcs = funcs.map {|e|
-			if used_names[e.name]
-				raise DuplicatedNameError, "duplicated function name: #{e.name}"
-			end
+			case e
+			when AST::InheritAll
+				InheritAllMark.new(e)
 
-			used_names[e.name] = true
+			when AST::InheritName, AST::InheritFunc
+				if used_names[e.name]
+					raise DuplicatedNameError, "Duplicated function name `#{e.name}'"
+				end
+				used_names[e.name] = true
+
+				if e.is_a?(AST::InheritFunc)
+					func = resolve_func(e)
+					InheritMarkWithCheck.new(e, func)
+				else
+					InheritMark.new(e, e.name)
+				end
+
+			when AST::Func
+				if used_names[e.name]
+					raise DuplicatedNameError, "Duplicated function name `#{e.name}'"
+				end
+				used_names[e.name] = true
+
+				resolve_func(e)
 
-			args = resolve_args(e.args)
-			if e.return_type.name == "void"
-				return_type = IR::Primitive.void
 			else
-				return_type = resolve_type(e.return_type)
+				raise SemanticsError, "Unknown service body AST element `#{e.class}': #{e.inspect}"
 			end
 
-			IR::Function.new(e.name, return_type, args, nil, nil)
 		}.sort_by {|f|
 			f.name
 		}
@@ -462,41 +584,62 @@ class Evaluator
 		return funcs
 	end
 
+	def resolve_func(e)
+		args = resolve_args(e.args)
+
+		if e.return_type.name == "void"
+			return_type = IR::Primitive.void
+		else
+			return_type = resolve_type(e.return_type)
+		end
+
+		exceptions = resolve_exceptions(e.exceptions)
+
+		IR::Function.new(e.name, return_type, args, exceptions)
+
+	rescue => error
+		raise_error(error, e)
+	end
+
 	def resolve_args(args)
 		used_ids = []
 		used_names = {}
 
 		args = args.map {|e|
-			if e.id == 0
-				raise InvalidNameError, "argument id 0 is invalid"
-			end
-			if e.id < 0
-				raise InvalidNameError, "argument id < 0 is invalid"
-			end
-			if n = used_ids[e.id]
-				raise DuplicatedNameError, "duplicated argument id #{e.id}: #{n}, #{e.name}"
-			end
-			if used_names[e.name]
-				raise DuplicatedNameError, "duplicated argument name: #{e.name}"
-			end
+			begin
+				if e.id == 0
+					raise InvalidNameError, "Argument id 0 is invalid"
+				end
+				if e.id < 0
+					raise InvalidNameError, "Argument id < 0 is invalid"
+				end
+				if n = used_ids[e.id]
+					raise DuplicatedNameError, "Argument id #{e.id} is duplicated with `#{n}'"
+				end
+				if i = used_names[e.name]
+					raise DuplicatedNameError, "Argument name `#{e.name}' is duplicated with id #{i}"
+				end
 
-			used_ids[e.id] = e.name
-			used_names[e.name] = e.name
+				used_ids[e.id] = e.name
+				used_names[e.name] = e.id
 
-			type = resolve_type(e.type)
-			if e.modifier == AST::FIELD_OPTIONAL
-				option  = IR::FIELD_OPTIONAL
-			else
-				option  = IR::FIELD_REQUIRED
-			end
+				type = resolve_type(e.type)
+				if e.modifier == AST::FIELD_OPTIONAL
+					option  = IR::FIELD_OPTIONAL
+				else
+					option  = IR::FIELD_REQUIRED
+				end
 
-			if e.is_a?(AST::ValueAssignedField)
-				v = resolve_initial_value(type, e.value)
-			else
-				v = resolve_implicit_value(type)
-			end
+				if e.is_a?(AST::ValueAssignedField)
+					v = resolve_initial_value(type, e.value)
+				else
+					v = resolve_implicit_value(type)
+				end
 
-			IR::Argument.new(e.id, type, e.name, option, v)
+				IR::Argument.new(e.id, type, e.name, option, v)
+			rescue => error
+				raise_error(error, e)
+			end
 		}.sort_by {|a|
 			a.id
 		}
@@ -504,12 +647,17 @@ class Evaluator
 		return args
 	end
 
+	def resolve_exceptions(exceptions)
+		# TODO
+		[]
+	end
+
 	def resolve_scopes(scopes)
 		ds = scopes.find_all {|e|
 			e.default?
 		}
 		if ds.size > 1
-			raise DuplicatedNameError, "multiple default scope: #{ds.map {|e| e.name}.join(', ')}"
+			raise DuplicatedNameError, "Multiple default scope: #{ds.map {|e| e.name}.join(', ')}"
 		end
 
 		if	ds.empty?
@@ -522,21 +670,17 @@ class Evaluator
 
 		scopes = scopes.map {|e|
 			if used_names[e.name]
-				raise DuplicatedNameError, "duplicated scope name: #{e.name}"
+				raise DuplicatedNameError, "Duplicated scope name: #{e.name}"
 			end
 
-			s = @services.find {|s|
-				s.name == e.service
-			}
+			s, versions = @service_versions[e.service]
 			unless s
-				raise NameNotFoundError, "no such service: #{e.name}"
+				raise NameNotFoundError, "No such service: #{e.name}"
 			end
 
-			sv = s.versions.find {|sv|
-				sv.version == e.version
-			}
+			sv = versions.find {|sv,ast| sv.version == e.version }
 			unless sv
-				raise NameNotFoundError, "no such service version: #{e.service}:#{s.version}"
+				raise NameNotFoundError, "No such service version: #{e.service}:#{s.version}"
 			end
 
 			used_names[e.name] = true
@@ -579,14 +723,15 @@ class Evaluator
 		e
 	end
 
-	def add_service_version(s, name, version, funcs)
+	def add_service_version(e, name, version, funcs)
 		sv = IR::ServiceVersion.new(version, funcs)
-		if s
-			s.versions << sv
-		else
-			s = IR::Service.new(name, [sv])
-			@services << s
+		s, versions = @service_versions[name]
+		unless s
+			s = IR::Service.new(name, nil)
+			versions = []
+			@service_versions[name] = [s, versions]
 		end
+		versions << [sv, e]
 		sv
 	end