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

# 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