Class: MessagePack::IDL::Evaluator

Inherits:

Object

• Object
• MessagePack::IDL::Evaluator

Includes:

ProcessorModule

Defined in:

lib/msgpack/idl/evaluator.rb

Defined Under Namespace

Classes: InheritAllMark, InheritMark, InheritMarkWithCheck, Template

Instance Attribute Summary

Attributes included from ProcessorModule

#log

Instance Method Summary

• #evaluate(ast) ⇒ Object
• #evaluate_inheritance ⇒ Object
• #evaluate_one(e) ⇒ Object
• #evaluate_spec(lang) ⇒ Object
• #initialize ⇒ Evaluator constructor

  A new instance of Evaluator.

Methods included from ProcessorModule

#log_error, #log_trace, #log_warn

Constructor Details

#initialize ⇒ Evaluator

Returns a new instance of Evaluator.

# File 'lib/msgpack/idl/evaluator.rb', line 84

def initialize
	@names = {}  # name:String => AST::Element

	@types = {}  # name:String => AST::Type
	@generic_types = []  # Template

	@global_namespace = [""]   # Namespace
	@lang_namespace = {}     # lang:String => scope:Namespace

	@service_versions = {} # serviceName:String => (IR::Service, [(IR::ServiceVersion, AST::ServiceVersion)])

	init_built_in

	@ir_types = []
	@ir_services = []
	@ir_applications = []
end

Instance Method Details

#evaluate(ast) ⇒ Object

# File 'lib/msgpack/idl/evaluator.rb', line 102

def evaluate(ast)
	ast.each {|e|
		evaluate_one(e)
	}
end

#evaluate_inheritance ⇒ Object

# File 'lib/msgpack/idl/evaluator.rb', line 159

def evaluate_inheritance
	@ir_services = @service_versions.values.map {|s,versions|
		versions = versions.sort_by {|sv,ast| sv.version }

		super_versions = []
		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

					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

				sv.functions = real_functions

				super_versions << sv
			rescue => error
				raise_error(error, ast)
			end
		end
		s.versions = super_versions

		s
	}

	self
end

#evaluate_one(e) ⇒ Object

# File 'lib/msgpack/idl/evaluator.rb', line 108

def evaluate_one(e)
	case e
	when AST::Namespace
		add_namespace(e)

	when AST::Exception
		check_name(e.name, e)
		if e.super_class
			super_message = resolve_type(e.super_class)
			if !super_message.is_a?(IR::Exception)
				raise InvalidNameError, "Super class of the exception `#{e.super_class}' must be an exception"
			end
		end
		new_fields = resolve_fields(e.fields, super_message)
		add_exception(e.name, super_message, new_fields)

	when AST::Message
		check_name(e.name, e)
		if e.super_class
			super_message = resolve_type(e.super_class)
			if !super_message.is_a?(IR::Message)
				raise InvalidNameError, "Super class of the message `#{e.super_class}' must be a message"
			end
		end
		new_fields = resolve_fields(e.fields, super_message)
		add_message(e.name, super_message, new_fields)

	when AST::Enum
		check_name(e.name, e)
		fields = resolve_enum_fields(e.fields)
		add_enum(e.name, fields)

	when AST::Service
		v = e.version || 0
		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)
		scopes = resolve_scopes(e.scopes)
		add_application(e.name, scopes)

	else
		raise SemanticsError, "Unknown toplevel AST element `#{e.class}'"
	end

rescue => error
	raise_error(error, e)
end

#evaluate_spec(lang) ⇒ Object

# File 'lib/msgpack/idl/evaluator.rb', line 242

def evaluate_spec(lang)
	lang = lang.to_s
	ns = spec_namespace(lang)
	types = spec_types(lang)
	services = spec_services(lang)
	applications = spec_applications(lang)
	IR::Spec.new(ns, types, services, applications)
end