class IDL::AST::Module

def _set_prefix(pfx)
  if @anchor.nil?
    self._set_prefix_(pfx)
  else
    @anchor._set_prefix_(pfx)
  end
end

def _set_prefix_(pfx)
  @prefix = pfx
  # propagate along chain
  self.next._set_prefix_(pfx) unless self.next.nil?
end

def _undo_link_introduction(node)
  @introduced.delete(node.intern)
end

def annotations
  (has_anchor? ? self.anchor : self).get_annotations
end

def copy_from(_template, _context)
  super
  if _template.has_anchor?
    # module anchor is first to be copied/instantiated and
    # should be registered in _context
    @anchor = IDL::AST::TemplateParam.concrete_param(_context, _template.anchor)
    # link ourself into module chain
    @anchor.find_last.set_next(self)
  end
  @next = nil # to be sure
  self
end

def find_last
  if @next.nil?
    self
  else
    @next.find_last
  end
end

def get_annotations
  @annotations
end

def has_anchor?
  !@anchor.nil?
end

def initialize(_name, _enclosure, params)
  super(_name, _enclosure)
  @anchor = params[:anchor]
  @prefix = params[:prefix] || @prefix
  @not_in_repo_id = params[:not_in_repo_id]
  @template = params[:template]
  @template_params = (params[:template_params] || []).dup
  @next = nil
end

def instantiate(_context, _enclosure)
  super(_context, _enclosure, {})
end

def is_templated?
  @template ? true : false
end

def marshal_dump
  super() << @anchor << @next
end

def marshal_load(vars)
  @next = vars.pop
  @anchor = vars.pop
  super(vars)
end

def redefine(node, params)
  case node
  when IDL::AST::Include
    if node.enclosure == self
      return node
    else
      _inc = IDL::AST::Include.new(node.name, self, params)
      _inc.annotations.concat(params[:annotations])
      @children << _inc
      return _inc
    end
  when IDL::AST::Module
    # Module reopening
    _anchor = node.has_anchor? ? node.anchor : node
    _anchor.annotations.concat(params.delete(:annotations))
    _last = _anchor.find_last
    _params = params.merge({ :anchor => _anchor, :prefix => node.prefix })
    _next = IDL::AST::Module.new(node.name, self, _params)
    _last.set_next(_next)
    @children << _next
    return _next
  when IDL::AST::Interface
    node.annotations.concat(params[:annotations])
    return node if params[:forward]
    if node.is_defined?
      raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
    end
    if (node.is_abstract? != params[:abstract]) || (node.is_local? != params[:local]) || (node.is_pseudo? != params[:pseudo])
      raise RuntimeError, "\"attributes are not the same: \"#{node.name}\"."
    end
    _intf = IDL::AST::Interface.new(node.name, self, params)
    _intf.annotations.concat(node.annotations)
    _intf.prefix = node.prefix
    _intf.instance_variable_set(:@repo_ver, node.instance_variable_get(:@repo_ver))
    _intf.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))
    @children << _intf
    # replace forward node registration
    node.enclosure.undo_introduction(node)
    introduce(_intf)
    return _intf
  when IDL::AST::Valuetype
    node.annotations.concat(params[:annotations])
    return node if params[:forward]
    if node.is_defined?
      raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
    end
    if (node.is_abstract? != params[:abstract])
      raise RuntimeError, "\"attributes are not the same: \"#{node.name}\"."
    end
    _new_node = node.class.new(node.name, self, params)
    _new_node.annotations.concat(node.annotations)
    _new_node.prefix = node.prefix
    _new_node.instance_variable_set(:@repo_ver, node.instance_variable_get(:@repo_ver))
    _new_node.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))
    @children << _new_node
    # replace forward node registration
    node.enclosure.undo_introduction(node)
    introduce(_new_node)
    return _new_node
  when IDL::AST::Struct, IDL::AST::Union
    node.annotations.concat(params[:annotations])
    return node if params[:forward]
    if node.is_defined?
      raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
    end
    _new_node = node.class.new(node.name, self, params)
    _new_node.annotations.concat(node.annotations)
    _new_node.prefix = node.prefix
    _new_node.instance_variable_set(:@repo_ver, node.instance_variable_get(:@repo_ver))
    _new_node.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))
    node.switchtype = params[:switchtype] if node.is_a?(IDL::AST::Union)
    @children << _new_node
    # replace forward node registration
    node.enclosure.undo_introduction(node)
    introduce(_new_node)
    return _new_node
  end
  raise RuntimeError,
        "#{node.name} is already introduced as #{node.typename} #{node.scoped_name}."
end

def replace_prefix(pfx)
  self.prefix = pfx   # handles validation
  if @anchor.nil?
    self.replace_prefix_(pfx)
  else
    @anchor.replace_prefix_(pfx)
  end
end

def replace_prefix_(pfx)
  walk_members { |m| m.replace_prefix(pfx) }
  # propagate along chain using fast method
  @next.replace_prefix_(pfx) unless @next.nil?
end

def repo_scopes
  @repo_scopes ||= (@enclosure.nil? ? [] : (@not_in_repo_id ? @enclosure.repo_scopes.dup : (@enclosure.repo_scopes.dup << self)))
end

def search_links(_name)
  _key = _name.downcase.intern
  node = @introduced[_key]
  if not node.nil? and node.name != _name
    raise RuntimeError, "\"#{_name}\" clashed with \"#{node.name}\"."
  end
  if node.nil? && @next
    node = @next.search_links(_name)
  end
  node
end

def search_self(_name)
  (@anchor || self).search_links(_name)
end

def set_next(mod)
  @next = mod
end

def template_param(param)
  return nil unless @template
  param = param.to_s if ::Symbol === param
  if ::String === param
    @template.params.each_with_index do |tp, ix|
      return @template_params[ix] if tp.name == param
    end
    nil
  else
    @template_params[param] rescue nil
  end
end

def undo_introduction(node)
  _mod = (@anchor || self)
  while _mod
    _mod._undo_link_introduction(node)
    _mod = _mod.next
  end
end