ridl 2.5.6 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 314694ac1e00cdc3cbc8d6afdc18e1e7e3884670
-  data.tar.gz: 9899c45caa2b63b1ac39c444e9e4a6c3adce1bfa
+SHA256:
+  metadata.gz: d24bac3b0aa52e6c84a1ef61d0939d84b3277b139a69db8cfc1f7f95130bf6a2
+  data.tar.gz: 3f773ed9d639811aaba53a68e0ace506b5e6b11591875326665d102faeff5a8f
 SHA512:
-  metadata.gz: 0d0dbd35ff3af48b46bc0fc8f3a0c34c136ce65a8a62e3a2314563af00ed73efa96938d16a7fa12526a6817b9dbb125781b7d36cdc5a166a483a79a3a2156bbf
-  data.tar.gz: 51ac6bf5289b2e18e87bc3f0389c43a980f0d3188f2c97c0cbccc315cb0f6bdecd72cc103bd2599d219a1ee5e6b1f4fe083d9dfda10719d434db0bbb228bb0da
+  metadata.gz: 1aa10dbfdb821544c474bc3f41bf48c156a42bf51d909ed631c6030ebd546145f9f9e70945bf4aa54a68e74cfe4a4d27b38dfab937e1576338febc67ea18dc8c
+  data.tar.gz: b96af7bb90418102bfb030dbd798bd15384232ab2547887fd68d4a3e1dc4142c0d997ab15f4de93daf06f39e764d8d8d04720774e81031b537b343daf6570862

data/LICENSE

@@ -1,49 +1,21 @@
-RIDL LICENSE
-
-RIDL (Licensed Product) is protected by copyright, and is distributed
-under the following terms.
-
-RIDL (Ruby IDL compiler) is an open source tool, developed by Remedy IT and
-written in Ruby. It is designed to provide a flexible parser/compiler
-frontend for OMG standard IDL.
-RIDL provides a generic parser component for OMG IDL and a flexible framework
-for plugging in (code) generation backends.
-
-Since RIDL is open source and free of licensing fees, you are free to use,
-modify, and distribute the source code, as long as you include this
-copyright statement.
-
-In particular, you can use RIDL to build proprietary software and are
-under no obligation to redistribute any of your source code that is built
-using RIDL. Note, however, that you may not do anything to the RIDL
-code, such as copyrighting it yourself or claiming authorship of the RIDL
-code, that will prevent RIDL from being distributed freely using an open
-source development model.
-
-Warranty
-
-LICENSED PRODUCT IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
-THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE, NON-INFRINGEMENT, OR ARISING FROM A COURSE OF DEALING, USAGE OR
-TRADE PRACTICE.
-
-Support
-
-LICENSED PRODUCT IS PROVIDED WITH NO SUPPORT AND WITHOUT ANY OBLIGATION ON
-THE PART OF REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES TO ASSIST IN
-ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT.
-
-Remedy IT provides support to users who have agreed on the terms of a support
-contract.
-
-Liability
-
-REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY
-WITH RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS
-BY LICENSED PRODUCT OR ANY PART THEREOF.
-
-IN NO EVENT WILL REMEDY IT OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE
-FOR ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL
-DAMAGES, EVEN IF REMEDY IT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-RIDL is Copyright Remedy IT. Nijkerk, The Netherlands, 2006-2015.
+MIT License
+
+Copyright (c) 2019 Remedy IT Expertise BV
+
+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.

data/README.rdoc

@@ -1,42 +1,48 @@
-= RIDL Compiler
+{<img src="https://badge.fury.io/rb/ridl.svg" alt="Gem Version" />}[https://badge.fury.io/rb/ridl]
+{<img src="https://github.com/RemedyIT/ridl/workflows/linux/badge.svg" alt="Linux CI" />}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Alinux]
+{<img src="https://www.codefactor.io/repository/github/remedyit/ridl/badge" alt="CodeFactor" />}[https://www.codefactor.io/repository/github/remedyit/ridl]
 
-home :: https://osportal.remedy.nl/projects/ridl
+= RIDL Compiler
 
 == Description
- 
-RIDL is a Ruby library implementing an OMG \IDL parser/compiler 
-frontend with support for pluggable (and stackable) backends.
 
-== Synopsis
+{RIDL}[https://www.remedy.nl/opensource/ridl.html] is a Ruby library implementing an Object Management Group (OMG) {IDL}[https://www.omg.org/spec/IDL] parser/compiler frontend with support for pluggable (and stackable) backends created by {Remedy IT}[https://www.remedy.nl].
 
-RIDL provides a framework for implementing compiler/generators for
-OMG standard \IDL interface definitions.
-The framework includes:
+== Synopsis
 
-* a RACC based parser supplemented with a custom scanner/tokenizer
-* a complete AST class hierarchy for representing parsed \IDL specifications
+RIDL provides a framework for implementing compiler/generators for OMG standard IDL definitions. The framework includes:
+* a {RACC}[https://github.com/ruby/racc] based parser supplemented with a custom scanner/tokenizer
+* a complete AST class hierarchy for representing parsed IDL specifications
 * a complete Type class hierarchy
-* \IDL constants expression support
-* a builtin \IDL preprocessor expression parser/evaluator
+* IDL constants expression support
+* a builtin IDL preprocessor expression parser/evaluator
 * a flexible framework for pluggable (and stackable) backends
-* basic support for backend code <b>re</b>generation
+* basic support for backend code re-generation
+* compliant with the {OMG IDL 3.5}[https://www.omg.org/spec/IDL/3.5] standard.
+
+Remedy IT has developed multiple backends for RIDL. These include:
+* {R2CORBA}[https://www.remedy.nl/opensource/r2corba.html] generating Ruby code
+* {TAOX11}[https://www.taox11.org] generating C++11 code
+* {AXCIOMA}[https://www.axcioma.org] generating C++11 code
 
-RIDL is compliant with the latest OMG \IDL standard.
+When you want to know more about how Remedy IT can assist you with developing your own backend for RIDL contact {sales@remedy.nl}[mailto:sales@remedy.nl].
 
 == Bugs
 
-If you find a bug, please report it at the RIDL project's
-{issues tracker}[https://osportal.remedy.nl/projects/ridl/issues].
+If you find a bug, please report it as {RIDL issue}[https://github.com/RemedyIT/ridl/issues].
 
-== License
+== Warranty
 
-RIDL is Copyright (c) 2007-2015 Remedy IT Expertise BV, The Netherlands.
+This software is provided "as is" and without any express or implied warranties, including, without limitation, the implied warranties of merchantibility and fitness for a particular purpose.
 
-It is free software, and may be redistributed under the terms specified in
-the LICENSE file.
+== Installing RIDL
 
-== Warranty
+RIDL is distributed as a Ruby Gem. You can download and install RIDL as a Ruby Gem from the common {Rubygems.org}[https://www.rubygems.org/gems/ridl] repository by executing the following command:
+
+ $ gem install ridl
+
+The RIDL Gem is a Ruby-only Gem without any dependencies.
+
+== Releasing new RIDL Ruby Gem
 
-This software is provided "as is" and without any express or implied
-warranties, including, without limitation, the implied warranties of
-merchantibility and fitness for a particular purpose.
+A new RIDL ruby gem release can be made by incrementing the RIDL version in link:lib/ridl/version.rb and create a new release on {github}[https://github.com/RemedyIT/ridl/releases] matching the new version (for example v2.7.0). The github {Ruby Gem Release}[https://github.com/RemedyIT/ridl/actions?query=workflow%3A%22Ruby+Gem+Release%22] action will automatically create a new gem and push it to {Rubygems.org}[https://www.rubygems.org/gems/ridl].

data/lib/ridl/backend.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 
 module IDL
@@ -51,7 +50,7 @@ module IDL
       rescue LoadError => ex
         IDL.error "ERROR: Cannot load RIDL backend [:#{be_name}]"
         IDL.error ex.inspect
-        IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level>0
+        IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level > 0
         exit 1
       end
     end
@@ -97,28 +96,25 @@ module IDL
       # base settings
       @base_backends.reverse.each {|be| be.setup_be(optlist, idl_options) }
       # initialize this backend
-      _setup_be(optlist, idl_options)
+      _setup_be(optlist, idl_options) if self.respond_to?(:_setup_be, true)
     end
 
     def process_input(parser, params)
-      # process input top-down
-      _process_input(parser, params)
-      @base_backends.each {|be| be.process_input(parser, params) }
+      # process input bottom-up
+      @base_backends.reverse.each {|be| be.process_input(parser, params) }
+      _process_input(parser, params) if self.respond_to?(:_process_input, true)
     end
 
     @@null_be = nil
 
     def self.null_be
-      @@null_be ||= self.configure('null', '.', 'RIDL Null backend', 'Copyright (c) 2013 Remedy IT Expertise BV, The Netherlands', 1) do |becfg|
+      @@null_be ||= self.configure('null', '.', 'RIDL Null backend', "Copyright (c) 2013-#{Time.now.year} Remedy IT Expertise BV, The Netherlands", 1) do |becfg|
         becfg.on_setup do |optlist, params|
           # noop
           IDL.log(0, "Setup called for #{becfg.backend.title}")
         end
-        becfg.on_process_input do |parser, params|
-          # noop
-        end
       end
     end
 
   end
-end
+end

data/lib/ridl/delegate.rb

@@ -8,14 +8,13 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'ridl/node'
 require 'ridl/expression'
 
 module IDL
 
-ORB_PIDL = 'orb.pidlc'
+ORB_PIDL = 'orb.pidlc'.freeze
 
 class Delegator
 
@@ -26,7 +25,7 @@ class Delegator
   @@pragma_handlers = {}
 
   def self.add_pragma_handler(key, h = nil, &block)
-    raise RuntimeError, 'add_pragma_handler requires a callable object or a block' unless (h && h.respond_to?(:call)) || block_given?
+    raise 'add_pragma_handler requires a callable object or a block' unless (h && h.respond_to?(:call)) || block_given?
     @@pragma_handlers[key] = block_given? ? block : h
   end
 
@@ -202,14 +201,10 @@ class Delegator
     when IDL::AST::Enumerator
       w.visit_enumerator(m)
     else
-      raise RuntimeError, "Invalid IDL member type for walkthrough: #{m.class.name}"
+      raise "Invalid IDL member type for walkthrough: #{m.class.name}"
     end
   end
 
-  def cur_parsed_name_scope
-    @cur ? @cur.parsed_name_scope : ''
-  end
-
   def is_included?(s)
     @includes.has_key?(s)
   end
@@ -218,7 +213,7 @@ class Delegator
     params = { :filename => s, :fullpath => fullpath }
     params[:defined] = true
     params[:preprocessed] = @preprocess
-    @cur = @cur.define(IDL::AST::Include, "$INC:"+s, params)
+    @cur = @cur.define(IDL::AST::Include, "$INC:" + s, params)
     @includes[s] = @cur
     set_last
     @cur
@@ -233,7 +228,7 @@ class Delegator
     params = { :filename => s, :fullpath => @includes[s].fullpath }
     params[:defined] = false
     params[:preprocessed] = @includes[s].is_preprocessed?
-    @cur.define(IDL::AST::Include, "$INC:"+s, params)
+    @cur.define(IDL::AST::Include, "$INC:" + s, params)
   end
 
   def pragma_prefix(s)
@@ -263,7 +258,7 @@ class Delegator
   end
 
   def handle_pragma(pragma_string)
-    unless @@pragma_handlers.values.any? {|h| h.call(self, @cur, pragma_string)}
+    unless @@pragma_handlers.values.reduce(false) {|rc, h| h.call(self, @cur, pragma_string) || rc }
       IDL.log(1, "RIDL - unrecognized pragma encountered: #{pragma_string}.")
     end
   end
@@ -289,8 +284,8 @@ class Delegator
 
   def define_module(name)
     @cur = @cur.define(IDL::AST::Module, name)
-    @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    @cur.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur
   end
@@ -304,12 +299,12 @@ class Delegator
   end
 
   def define_template_module(global, names)
-    if global || names.size>1
-      raise RuntimeError, "no scoped identifier allowed for template module: #{(global ? '::' : '')+names.join('::')}"
+    if global || names.size > 1
+      raise "no scoped identifier allowed for template module: #{(global ? '::' : '') + names.join('::')}"
     end
     @cur = @cur.define(IDL::AST::TemplateModule, names[0])
-    @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    @cur.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur
   end
@@ -322,8 +317,8 @@ class Delegator
       define_template_module(*tmp)
     end
     params = { :type => type }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::TemplateParam, name, params))
     @cur
   end
@@ -333,12 +328,12 @@ class Delegator
     @template_module_name = nil # reset
     template_type = parse_scopedname(*tmp)
     unless template_type.node.is_a?(IDL::AST::TemplateModule)
-      raise RuntimeError, "invalid module template specification: #{template_type.node.typename} #{template_type.node.scoped_lm_name}"
+      raise "invalid module template specification: #{template_type.node.typename} #{template_type.node.scoped_lm_name}"
     end
     params = { :template => template_type.node, :template_params => parameters }
     mod_inst = @cur.define(IDL::AST::Module, name, params)
-    mod_inst.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    mod_inst.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(mod_inst.template.instantiate(mod_inst))
     @cur
   end
@@ -347,8 +342,8 @@ class Delegator
     params = {}
     params[:tpl_type] = type
     params[:tpl_params] = tpl_params || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::TemplateModuleReference, name, params))
     @cur
   end
@@ -359,8 +354,7 @@ class Delegator
     params[:local] = attrib == :local
     params[:forward] = true
     params[:pseudo] = false
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     @cur.define(IDL::AST::Interface, name, params)
     set_last
     @cur
@@ -373,8 +367,8 @@ class Delegator
     params[:pseudo] = attrib == :pseudo
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Interface, name, params)
   end
@@ -389,8 +383,8 @@ class Delegator
     params[:component] = component
     params[:key] = key
     params[:supports] = supports || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Home, name, params)
   end
@@ -403,8 +397,7 @@ class Delegator
   def declare_component(name)
     params = {}
     params[:forward] = true
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     set_last
     @cur.define(IDL::AST::Component, name, params)
   end
@@ -413,8 +406,8 @@ class Delegator
     params = {}
     params[:base] = base
     params[:supports] = supports || []
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Component, name, params)
   end
@@ -427,8 +420,8 @@ class Delegator
   def define_connector(name, base = nil)
     params = {}
     params[:base] = base
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Connector, name, params)
   end
@@ -440,8 +433,8 @@ class Delegator
 
   def define_porttype(name)
     params = {}
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Porttype, name, params)
   end
@@ -456,8 +449,8 @@ class Delegator
     params[:porttype] = porttype
     params[:type] = type
     params[:multiple] = multiple
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Port, name, params))
     @cur
   end
@@ -466,8 +459,7 @@ class Delegator
     params = {}
     params[:abstract] = attrib == :abstract
     params[:forward] = true
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     set_last
     @cur.define(IDL::AST::Eventtype, name, params)
     @cur
@@ -479,8 +471,8 @@ class Delegator
     params[:custom] = attrib == :custom
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Eventtype, name, params)
     @cur
@@ -490,8 +482,7 @@ class Delegator
     params = {}
     params[:abstract] = attrib == :abstract
     params[:forward] = true
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     set_last
     @cur.define(IDL::AST::Valuetype, name, params)
     @cur
@@ -503,8 +494,8 @@ class Delegator
     params[:custom] = attrib == :custom
     params[:forward] = false
     params[:inherits] = inherits
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Valuetype, name, params)
     @cur
@@ -523,16 +514,16 @@ class Delegator
     params = {}
     params[:type] = type
     params[:visibility] = (public_ ? :public : :private)
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::StateMember, name, params))
     @cur
   end
 
   def define_valuebox(name, type)
     params = { :type => type }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Valuebox, name, params))
     @cur
   end
@@ -541,8 +532,8 @@ class Delegator
     params = {}
     params[:params] = params_
     params[:raises] = raises_
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Initializer, name, params))
     @cur
   end
@@ -551,8 +542,8 @@ class Delegator
     params = {}
     params[:params] = params_
     params[:raises] = raises_
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Finder, name, params))
     @cur
   end
@@ -563,8 +554,7 @@ class Delegator
     namelist.each do |nm|
       n = node.resolve(nm)
       if n.nil?
-        raise RuntimeError,
-          "cannot find type name '#{nm}' in scope '#{node.scoped_name}'"
+        raise "cannot find type name '#{nm}' in scope '#{node.scoped_name}'"
       end
       node = n
       first = node if first.nil?
@@ -572,7 +562,7 @@ class Delegator
     root.introduce(first)
     case node
     when IDL::AST::Module, IDL::AST::TemplateModule,
-         IDL::AST::Interface,IDL::AST::Home, IDL::AST::Component,
+         IDL::AST::Interface, IDL::AST::Home, IDL::AST::Component,
          IDL::AST::Porttype, IDL::AST::Connector,
          IDL::AST::Struct, IDL::AST::Union, IDL::AST::Typedef,
          IDL::AST::Exception, IDL::AST::Enum,
@@ -589,8 +579,7 @@ class Delegator
     when IDL::AST::Enumerator
       Expression::Enumerator.new(node)
     else
-      raise RuntimeError,
-         "invalid reference to #{node.class.name}: #{node.scoped_name}"
+      raise "invalid reference to #{node.class.name}: #{node.scoped_name}"
     end
   end
 
@@ -608,8 +597,7 @@ class Delegator
         Type::ULongLong,
       ].detect {|t| t::Range === _value }
       if _type.nil?
-        raise RuntimeError,
-          "it's not a valid integer: #{v.to_s}"
+        raise "it's not a valid integer: #{v.to_s}"
       end
       k.new(_type.new, _value)
     when :string
@@ -634,9 +622,9 @@ class Delegator
       _expression
     else
       if not ::Integer === _expression.value
-        raise RuntimeError, "must be integer: #{_expression.value.inspect}"
+        raise "must be integer: #{_expression.value.inspect}"
       elsif _expression.value < 0
-        raise RuntimeError, "must be positive integer: #{_expression.value.to_s}"
+        raise "must be positive integer: #{_expression.value.to_s}"
       end
       _expression.value
     end
@@ -644,8 +632,8 @@ class Delegator
 
   def define_const(_type, _name, _expression)
     params = { :type => _type, :expression => _expression }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Const, _name, params))
     @cur
   end
@@ -654,8 +642,8 @@ class Delegator
     params = Hash.new
     params[:oneway] = (_oneway == :oneway)
     params[:type]   = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Operation, _name, params)
   end
@@ -663,16 +651,16 @@ class Delegator
     params = Hash.new
     params[:attribute] = _attribute
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Parameter, _name, params))
     @cur
   end
-  def declare_op_footer(_raises, _context)
+  def declare_op_footer(_raises, instantiation_context)
     @cur.raises = _raises || []
-    @cur.context = _context
+    @cur.context = instantiation_context
     if not @cur.context.nil?
-      raise RuntimeError, "context phrase's not supported"
+      raise "context phrase's not supported"
     end
     set_last(@cur)
     @cur = @cur.enclosure
@@ -682,31 +670,30 @@ class Delegator
     params = Hash.new
     params[:type] = _type
     params[:readonly] = _readonly
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Attribute, _name, params))
   end
 
   def declare_struct(_name)
     params = { :forward => true }
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     set_last
     @cur.define(IDL::AST::Struct, _name, params)
     @cur
   end
   def define_struct(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Struct, _name, params)
   end
   def declare_member(_type, _name)
     params = Hash.new
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Member, _name, params))
     @cur
   end
@@ -719,8 +706,8 @@ class Delegator
   end
   def define_exception(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Exception, _name, params)
   end
@@ -733,31 +720,30 @@ class Delegator
 
   def declare_union(_name)
     params = { :forward => true }
-    raise RuntimeError,
-       "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     set_last
     @cur.define(IDL::AST::Union, _name, params)
     @cur
   end
   def define_union(_name)
     params = { :forward => false }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Union, _name, params)
   end
   def define_union_switchtype(union_node, switchtype)
     union_node.set_switchtype(switchtype)
-    union_node.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
+    union_node.annotations.concat(@annotation_stack)
+    @annotation_stack = IDL::AST::Annotations.new
     union_node
   end
   def define_case(_labels, _type, _name)
     params = Hash.new
     params[:type] = _type
     params[:labels] = _labels
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::UnionMember, _name, params))
     @cur
   end
@@ -772,8 +758,8 @@ class Delegator
 
   def define_enum(_name)
     params = {}
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Enum, _name, params)
   end
@@ -783,8 +769,8 @@ class Delegator
       :value => n,
       :enum => @cur
     }
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.enclosure.define(IDL::AST::Enumerator, _name, params))
     @cur
   end
@@ -798,8 +784,8 @@ class Delegator
   def declare_typedef(_type, _name)
     params = Hash.new
     params[:type] = _type
-    params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
-    @annotation_stack.clear
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Typedef, _name, params))
     @cur
   end