ridl 2.7.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18e62df6c0bae092d3d8f3da6ab5cf8fad2fadfe5e839c72d59660868c187f1a
-  data.tar.gz: 5a51e665b994e566b6579e7f76dab959947b1294ddacc7bd566febef1dbe1766
+  metadata.gz: 87ce802ae63d060ff0417d998795740726aaf67f631484735aa56191404bf78d
+  data.tar.gz: 888f4de7ff1a2146928c42b60298d6662d765dd7406c43287457182a81deb4ab
 SHA512:
-  metadata.gz: d6cce4394f7a366135dd636f935ea90348cba4c2bd20aa95d9f712a88c45cfaacdc82381039e329c1be1bb3d34f9fe70269a1891296ea63179ad8cea0c39ee77
-  data.tar.gz: b2eda0b126d08ed4cdb66bfbd7795b8f7660b45e24776fb655267885f07a444cd47e8fea42fc3893f464ec63fa3ef5e08b722549f9f90425d9708b702382699c
+  metadata.gz: d3c4384299da19d91f593c578003615949962270392ee9293296341bd15ccf72c29cd8e304feefc777d2d408b36b67c830f44154b27d86589c98b79e32ec9e7d
+  data.tar.gz: 8717656df74c22c74e23acbf8e80748e646ece8be1e68131126c5d58e64ce093c038e9687b44c8042a119bc66bbb2b77ab73001a7678b234ca1b7f6c8d5710e0

data/README.rdoc

@@ -1,5 +1,6 @@
 {<img src="https://badge.fury.io/rb/ridl.svg" alt="Gem Version" />}[https://badge.fury.io/rb/ridl]
 {<img src="https://dev.azure.com/remedyit/axcioma/_apis/build/status/ridl?branchName=master" alt="Azure pipeline" />}[https://dev.azure.com/remedyit/axcioma/_build?definitionId=7&_a=summary]
+{<img src="https://www.codefactor.io/repository/github/remedyit/ridl/badge" alt="CodeFactor" />}[https://www.codefactor.io/repository/github/remedyit/ridl]
 
 = RIDL Compiler
 
@@ -44,4 +45,4 @@ The RIDL Gem is a Ruby-only Gem without any dependencies.
 
 == Releasing new RIDL Ruby Gem
 
-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].
+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/delegate.rb

@@ -25,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
 
@@ -201,7 +201,7 @@ 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
 
@@ -304,7 +304,7 @@ class Delegator
 
   def define_template_module(global, names)
     if global || names.size>1
-      raise RuntimeError, "no scoped identifier allowed for template module: #{(global ? '::' : '')+names.join('::')}"
+      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?
@@ -332,7 +332,7 @@ 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)
@@ -358,8 +358,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
@@ -402,8 +401,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
@@ -465,8 +463,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
@@ -489,8 +486,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
@@ -562,8 +558,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?
@@ -588,8 +583,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
 
@@ -607,8 +601,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
@@ -633,9 +626,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
@@ -671,7 +664,7 @@ class Delegator
     @cur.raises = _raises || []
     @cur.context = _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
@@ -688,8 +681,7 @@ class Delegator
 
   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
@@ -732,8 +724,7 @@ 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

data/lib/ridl/expression.rb

@@ -37,8 +37,7 @@ module IDL
       def initialize(node)
         if $DEBUG
           unless IDL::AST::Const === node || (IDL::AST::TemplateParam === node && node.idltype.is_a?(IDL::Type::Const))
-            raise RuntimeError,
-              "#{node.scoped_name} must be constant: #{node.class.name}."
+            raise "#{node.scoped_name} must be constant: #{node.class.name}."
           end
         end
         @node = node
@@ -69,8 +68,7 @@ module IDL
       def initialize(node)
         if $DEBUG
           if not IDL::AST::Enumerator === node
-            raise RuntimeError,
-              "#{node.scoped_name} must be enumerator: #{node.class.name}."
+            raise "#{node.scoped_name} must be enumerator: #{node.class.name}."
           end
         end
         @node = node
@@ -87,8 +85,7 @@ module IDL
         n = self.class::NUMBER_OF_OPERANDS
 
         if _operands.size != n
-          raise RuntimeError,
-            format("%s must receive %d operand%s.",
+          raise format("%s must receive %d operand%s.",
             self.typename, n, if (n>1) then "s" else "" end)
         end
 
@@ -114,8 +111,7 @@ module IDL
       def Operation.suite_type(*types)
         types.each do |t|
           if not self::Applicable.include? t.class
-            raise RuntimeError,
-              "#{self.name} cannot be applicable for #{t.typename}"
+            raise "#{self.name} cannot be applicable for #{t.typename}"
           end
         end
 
@@ -173,8 +169,7 @@ module IDL
 
           t = IDL::Type::Boolean
           if (t1 == t && t2 != t) or (t1 != t && t2 == t)
-            raise RuntimeError,
-              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+            raise "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
           end
         end
       end
@@ -191,8 +186,7 @@ module IDL
           # it's expected that Double, LongDouble is a Float.
           s1,s2 = IDL::Type::Float, IDL::Type::Fixed
           if (t1 === s1 && t2 === s2) or (t1 === s2 && t2 === s1)
-            raise RuntimeError,
-              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+            raise "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
           end
         end
       end
@@ -237,8 +231,7 @@ module IDL
       protected
         def check_rop(rop)
           if not (0...64) === rop
-            raise RuntimeError,
-              "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
+            raise "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
           end
         end
       end

data/lib/ridl/genfile.rb

@@ -109,7 +109,7 @@ module IDL
         :output_file => nil,
         :create_missing_dir => false
       }.merge(opts)
-      if @options[:regenerate] && File.exists?(@fullpath)
+      if @options[:regenerate] && File.exist?(@fullpath)
         parse_regeneration_content
       else
         @content = Content.new
@@ -159,7 +159,7 @@ module IDL
         fgen = @fout
         @fout = nil
         fgen.close(false) # close but do NOT unlink
-        if File.exists?(@fullpath)
+        if File.exist?(@fullpath)
           # create temporary backup
           ftmp = Tempfile.new(@name)
           ftmp_name = ftmp.path.dup
@@ -224,22 +224,22 @@ module IDL
           if regen_marker_re =~ line
             case $1
             when 'BEGIN'
-              raise RuntimeError, "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
+              raise "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
               in_section = [$2, linenr]
               section = []
             when 'END'
-              raise RuntimeError, "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
+              raise "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
               sections[$2] = section
               in_section = nil
               section = []
             when 'HEADER_END'
-              raise RuntimeError, "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
+              raise "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
                                                                                                          ('HEADER' == in_section.first ) && (0 == in_section.last)
               sections[$2] = section
               in_section = nil
               section = []
             else
-              raise RuntimeError, "ERROR: Found invalid regeneration marker at #{@path}:#{linenr}."
+              raise "ERROR: Found invalid regeneration marker at #{@path}:#{linenr}."
             end
           elsif in_section
             section << line

data/lib/ridl/node.rb

@@ -159,24 +159,22 @@ module IDL::AST
     def set_repo_id(id)
       if @repo_id
         if id != @repo_id
-          raise RuntimeError,
-            "#{self.scoped_name} already has a different repository ID assigned: #{@repo_id}"
+          raise "#{self.scoped_name} already has a different repository ID assigned: #{@repo_id}"
         end
       end
       id_arr = id.split(':')
       if @repo_ver
         if id_arr.first != 'IDL' or id_arr.last != @repo_ver
-          raise RuntimeError,
-            "supplied repository ID (#{id}) does not match previously assigned repository version for #{self.scoped_name} = #{@repo_ver}"
+          raise "supplied repository ID (#{id}) does not match previously assigned repository version for #{self.scoped_name} = #{@repo_ver}"
         end
       end
       # check validity of IDL format repo IDs
       if id_arr.first == 'IDL'
         id_arr.shift
         id_str = id_arr.shift.to_s
-        raise RuntimeError, 'ID identifiers should not start or end with \'/\'' if id_str[0,1]=='/' or id_str[-1, 1]=='/'
-        raise RuntimeError, "ID identifiers should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(id_str[0,1])
-        raise RuntimeError, 'Invalid ID! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed for identifiers' unless REPO_ID_RE =~ id_str
+        raise 'ID identifiers should not start or end with \'/\'' if id_str[0,1]=='/' or id_str[-1, 1]=='/'
+        raise "ID identifiers should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(id_str[0,1])
+        raise 'Invalid ID! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed for identifiers' unless REPO_ID_RE =~ id_str
       end
       @repo_id = id
     end
@@ -185,15 +183,13 @@ module IDL::AST
       ver = "#{ma}.#{mi}"
       if @repo_ver
         if ver != @repo_ver
-          raise RuntimeError,
-            "#{self.scoped_name} already has a repository version assigned: #{@repo_ver}"
+          raise "#{self.scoped_name} already has a repository version assigned: #{@repo_ver}"
         end
       end
       if @repo_id
         l = @repo_id.split(':')
         if l.last != ver
-          raise RuntimeError,
-            "supplied repository version (#{ver}) does not match previously assigned repository ID for #{self.scoped_name}: #{@repo_id}"
+          raise "supplied repository version (#{ver}) does not match previously assigned repository ID for #{self.scoped_name}: #{@repo_id}"
         end
       end
       @repo_ver = ver
@@ -201,9 +197,9 @@ module IDL::AST
 
     def prefix=(pfx)
       unless pfx.to_s.empty?
-        raise RuntimeError, 'ID prefix should not start or end with \'/\'' if pfx[0,1]=='/' or pfx[-1, 1]=='/'
-        raise RuntimeError, "ID prefix should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(pfx[0,1])
-        raise RuntimeError, 'Invalid ID prefix! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed' unless REPO_ID_RE =~ pfx
+        raise 'ID prefix should not start or end with \'/\'' if pfx[0,1]=='/' or pfx[-1, 1]=='/'
+        raise "ID prefix should not start with one of '#{REPO_ID_XCHARS.join("', '")}'" if REPO_ID_XCHARS.include?(pfx[0,1])
+        raise 'Invalid ID prefix! Only a..z, A..Z, 0..9, \'.\', \'-\', \'_\' or \'\/\' allowed' unless REPO_ID_RE =~ pfx
       end
       self._set_prefix(pfx)
     end
@@ -270,8 +266,7 @@ module IDL::AST
 
     def introduce(node)
       n = (@introduced[node.intern] ||= node)
-      raise RuntimeError,
-        "#{node.name} is already introduced as a #{n.scoped_name} of #{n.typename}." if n != node
+      raise "#{node.name} is already introduced as a #{n.scoped_name} of #{n.typename}." if n != node
     end
 
     def undo_introduction(node)
@@ -279,7 +274,7 @@ module IDL::AST
     end
 
     def redefine(node, params)
-      raise RuntimeError, "\"#{node.name}\" is already defined."
+      raise "\"#{node.name}\" is already defined."
     end
 
     def is_definable?(_type)
@@ -290,8 +285,7 @@ module IDL::AST
 
     def define(_type, _name, params = Hash.new)
       if not is_definable?(_type)
-        raise RuntimeError,
-          "#{_type.to_s} is not definable in #{self.typename}."
+        raise "#{_type.to_s} is not definable in #{self.typename}."
       end
       node = search_self(_name)
       if node.nil?
@@ -302,8 +296,7 @@ module IDL::AST
         @children << node
       else
         if _type != node.class
-          raise RuntimeError,
-            "#{_name} is already defined as a type of #{node.typename}"
+          raise "#{_name} is already defined as a type of #{node.typename}"
         end
         node = redefine(node, params)
       end
@@ -342,7 +335,7 @@ module IDL::AST
       key = _name.downcase.intern
       node = @introduced[key]
       if not node.nil? and node.name != _name
-        raise RuntimeError, "\"#{_name}\" clashed with \"#{node.name}\"."
+        raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
       node
     end
@@ -493,10 +486,10 @@ module IDL::AST
           # forward declaration in different scope (other module section in same file or other file)
         elsif node.is_defined?
           # multiple full declarations are illegal
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{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}\"."
+          raise "\"attributes are not the same: \"#{node.name}\"."
         end
 
         _intf = IDL::AST::Interface.new(node.name, self, params)
@@ -521,10 +514,10 @@ module IDL::AST
         node.annotations.concat(params[:annotations])
         return node if params[:forward]
         if node.is_defined?
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
         if (node.is_abstract? != params[:abstract])
-          raise RuntimeError, "\"attributes are not the same: \"#{node.name}\"."
+          raise "\"attributes are not the same: \"#{node.name}\"."
         end
 
         _new_node = node.class.new(node.name, self, params)
@@ -543,7 +536,7 @@ module IDL::AST
         node.annotations.concat(params[:annotations])
         return node if params[:forward]
         if node.is_defined?
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
 
         _new_node = node.class.new(node.name, self, params)
@@ -561,8 +554,7 @@ module IDL::AST
 
         return _new_node
       end
-      raise RuntimeError,
-            "#{node.name} is already introduced as #{node.typename} #{node.scoped_name}."
+      raise "#{node.name} is already introduced as #{node.typename} #{node.scoped_name}."
     end
 
     def undo_introduction(node)
@@ -629,7 +621,7 @@ module IDL::AST
       _key = _name.downcase.intern
       node = @introduced[_key]
       if not node.nil? and node.name != _name
-        raise RuntimeError, "\"#{_name}\" clashed with \"#{node.name}\"."
+        raise "\"#{_name}\" clashed with \"#{node.name}\"."
       end
       if node.nil? && @next
         node = @next.search_links(_name)
@@ -696,7 +688,7 @@ module IDL::AST
           # referenced template node should have been instantiated already and available through context
           _context[_node]
         end
-        raise RuntimeError, "cannot resolve concrete node for template #{_node.typename} #{_node.scoped_lm_name}" unless _cnode
+        raise "cannot resolve concrete node for template #{_node.typename} #{_node.scoped_lm_name}" unless _cnode
         _cnode
       else
         _node
@@ -736,14 +728,13 @@ module IDL::AST
     def instantiate(_module_instance, _context = {})
       # process concrete parameters
       @template_params.each_with_index do |_tp, _ix|
-        raise RuntimeError,
-              "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
+        raise "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
         _cp = _module_instance.template_params[_ix]
         if _cp.is_a?(IDL::Type)
-          raise RuntimeError, "anonymous type definitions are not allowed!" if _cp.is_anonymous?
+          raise "anonymous type definitions are not allowed!" if _cp.is_anonymous?
           # parameter should be a matching IDL::Type
           unless _tp.idltype.is_a?(IDL::Type::Any) || _tp.idltype.class === _cp.resolved_type
-            raise RuntimeError, "mismatched instantiation parameter \##{_ix} #{_cp.typename} for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+            raise "mismatched instantiation parameter \##{_ix} #{_cp.typename} for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
           end
           # verify concrete parameter
           case _tp.idltype
@@ -764,19 +755,19 @@ module IDL::AST
                 unless _tptype.basetype.is_a?(IDL::Type::ScopedName) &&
                        _tptype.basetype.is_node?(IDL::AST::TemplateParam) &&
                        _tptype.basetype.node.concrete_matches?(_cp.resolved_type.basetype)
-                  raise RuntimeError, "invalid sequence type as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+                  raise "invalid sequence type as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
                 end
               end
           end
         elsif _cp.is_a?(IDL::Expression)
           # template param should be 'const <const_type>'
           unless _tp.idltype.is_a?(IDL::Type::Const)
-            raise RuntimeError, "unexpected expression as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
+            raise "unexpected expression as instantiation parameter for #{typename} #{scoped_lm_name}: expected #{_tp.idltype.typename} for #{_tp.name}"
           end
           # match constant type
           _tp.idltype.narrow(_cp.value)
         else
-          raise RuntimeError, "invalid instantiation parameter for #{typename} #{scoped_lm_name}: #{_cp.class.name}"
+          raise "invalid instantiation parameter for #{typename} #{scoped_lm_name}: #{_cp.class.name}"
         end
         # if we  get here all is well -> store concrete param
         _tp.set_concrete_param(_cp.is_a?(IDL::Type::ScopedName) ? _cp.node : _cp)
@@ -797,12 +788,12 @@ module IDL::AST
     def initialize(_name, _enclosure, _params)
       super(_name, _enclosure)
       unless _params[:tpl_type].is_a?(IDL::Type::ScopedName) && _params[:tpl_type].is_node?(IDL::AST::TemplateModule)
-        raise RuntimeError, "templated module reference type required for #{typename} #{scoped_lm_name}: got #{_params[:tpl_type].typename}"
+        raise "templated module reference type required for #{typename} #{scoped_lm_name}: got #{_params[:tpl_type].typename}"
       end
       @template = _params[:tpl_type].resolved_type.node
       _params[:tpl_params].each do |p|
         unless (p.is_a?(IDL::Type::ScopedName) || p.is_a?(IDL::Expression::ScopedName)) && p.is_node?(IDL::AST::TemplateParam)
-          raise RuntimeError, "invalid template module parameter for template module reference #{typename} #{scoped_lm_name}: #{p.typename}"
+          raise "invalid template module parameter for template module reference #{typename} #{scoped_lm_name}: #{p.typename}"
         end
       end
       @params = _params[:tpl_params].collect { |p| p.resolved_node }
@@ -940,7 +931,7 @@ module IDL::AST
         r_one = results.shift
         unless results.all? {|r| r_one == r || (r_one.class == r.class && r_one.scoped_name == r.scoped_name) }
           s = results.inject([r_one]) {|l,r| l << r unless l.include?(r); l }.collect{ |n| n.scoped_name }.join(", ")
-          raise RuntimeError, "\"#{_name}\" is ambiguous. " + s
+          raise "\"#{_name}\" is ambiguous. " + s
         end
       end
       results.first
@@ -1026,37 +1017,29 @@ module IDL::AST
       inherits_.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
           unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Interface))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+            raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
           rtc = tc.resolved_type
           if rtc.node.has_ancestor?(self)
-            raise RuntimeError,
-                  "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
+            raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_local? and not self.is_local?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_pseudo? and not self.is_pseudo?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_abstract? and not rtc.node.is_abstract?
-            raise RuntimeError,
-                  "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_local? and rtc.node.is_abstract?
-            raise RuntimeError,
-                  "'local' #{typename} #{scoped_lm_name} cannot inherit from 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'local' #{typename} #{scoped_lm_name} cannot inherit from 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.has_base?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
           # check if we indirectly derive from this base multiple times (which is ok; no further need to check)
           unless @resolved_bases.any? { |b| b.has_ancestor?(rtc.node) }
@@ -1066,8 +1049,7 @@ module IDL::AST
               new_op_att_ << m if m.is_a?(IDL::AST::Operation) || m.is_a?(IDL::AST::Attribute)
             end
             if new_op_att_.any? {|n| n_ = self.search_self(n.name); n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
-              raise RuntimeError,
-                    "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
+              raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
             end
             # no need to check for duplicate member names; this inheritance is ok
           end
@@ -1102,7 +1084,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1121,13 +1103,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -1193,12 +1175,10 @@ module IDL::AST
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
         unless (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+          raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
         if parent.resolved_type.node.has_base?(self)
-          raise RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
         @resolved_base = parent.resolved_type.node
       end
@@ -1217,22 +1197,18 @@ module IDL::AST
       intfs.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
           unless (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Interface))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+            raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
           rtc = tc.resolved_type
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot support forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           ## TODO : is this legal?
           if rtc.node.is_local?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot support 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if rtc.node.is_pseudo?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot support 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           ## TODO : is this legal?
           #if tc.node.is_abstract?
@@ -1240,8 +1216,7 @@ module IDL::AST
           #        "'abstract' #{typename} #{scoped_lm_name} cannot support 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           #end
           if self.has_support?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            raise "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
           # check if we indirectly support this base multiple times (which is ok; no further need to check)
           unless @resolved_interfaces.any? { |b| b.has_ancestor?(rtc.node) }
@@ -1251,8 +1226,7 @@ module IDL::AST
               new_op_att_ << m if m.is_a?(IDL::AST::Operation) || m.is_a?(IDL::AST::Attribute)
             end
             if new_op_att_.any? {|n| n_ = self.search_self(n.name); n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
-              raise RuntimeError,
-                    "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
+              raise "#{typename} #{scoped_lm_name} cannot support #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
             end
             # no need to check for duplicate member names; this support is ok
           end
@@ -1275,7 +1249,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1294,13 +1268,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -1365,22 +1339,19 @@ module IDL::AST
     def set_component_and_key(comp, key)
       unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::TemplateParam)
         unless comp && comp.is_a?(IDL::Type::ScopedName) && comp.is_node?(IDL::AST::Component)
-          raise RuntimeError,
-                (comp ?
+          raise (comp ?
                   "invalid managed component for #{typename} #{scoped_lm_name}: #{comp.typename}" :
                   "missing managed component specification for #{typename} #{scoped_lm_name}")
         end
         unless comp.resolved_type.node.is_defined?
-          raise RuntimeError,
-            "#{scoped_lm_name}: #{comp.typename} cannot manage forward declared component #{comp.node.scoped_lm_name}"
+          raise "#{scoped_lm_name}: #{comp.typename} cannot manage forward declared component #{comp.node.scoped_lm_name}"
         end
         @resolved_comp = comp.resolved_type.node
       end
       unless key && key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::TemplateParam)
         ## TODO : add check for Components::PrimaryKeyBase base type
         unless key.nil? || (key.is_a?(IDL::Type::ScopedName) && key.is_node?(IDL::AST::Valuetype))
-          raise RuntimeError,
-            "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
+          raise "invalid primary key for #{typename} #{scoped_lm_name}: #{key.typename}"
         end
         @resolved_pk = key.resolved_type.node if key
       end
@@ -1428,19 +1399,17 @@ module IDL::AST
     def is_forward?; false; end
 
     def add_interfaces(intfs)
-      raise RuntimeError, "interface support not allowed for #{typename} #{scoped_lm_name}" if intfs && !intfs.empty?
+      raise "interface support not allowed for #{typename} #{scoped_lm_name}" if intfs && !intfs.empty?
     end
 
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
         if not (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+          raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
         @resolved_base = parent.resolved_type.node
         if @resolved_base.has_base?(self)
-          raise RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
       end
       @base = parent.node
@@ -1513,17 +1482,14 @@ module IDL::AST
     def set_base(parent)
       unless parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(IDL::AST::TemplateParam)
         if not (parent.is_a?(IDL::Type::ScopedName) && parent.is_node?(self.class))
-          raise RuntimeError,
-                "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
+          raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{parent.typename}"
         end
         @resolved_base = parent.resolved_type.node
         if not @resolved_base.is_defined?
-          raise RuntimeError,
-                "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{parent.node.typename} #{parent.node.scoped_lm_name}"
+          raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{parent.node.typename} #{parent.node.scoped_lm_name}"
         end
         if @resolved_base.has_base?(self)
-          raise RuntimeError,
-                "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
+          raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{parent.node.scoped_lm_name} is descendant"
         end
       end
       @base = parent.node
@@ -1603,20 +1569,20 @@ module IDL::AST
       super(_name, _enclosure)
       @idltype  = params[:type]
       @porttype = params[:porttype]
-      raise RuntimeError, "unknown porttype for  #{typename} #{scoped_lm_name}: #{@porttype}" unless PORTTYPES.include?(@porttype)
+      raise "unknown porttype for  #{typename} #{scoped_lm_name}: #{@porttype}" unless PORTTYPES.include?(@porttype)
       case @porttype
       when :facet, :receptacle
         unless @idltype.is_a?(IDL::Type::Object) ||
               (@idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Interface) || @idltype.is_node?(IDL::AST::TemplateParam)))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       when :port, :mirrorport
         unless @idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Porttype) || @idltype.is_node?(IDL::AST::TemplateParam))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       else
         unless @idltype.is_a?(IDL::Type::ScopedName) && (@idltype.is_node?(IDL::AST::Eventtype) ||  @idltype.is_node?(IDL::AST::TemplateParam))
-          raise RuntimeError, "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
+          raise "invalid type for #{typename} #{scoped_lm_name}:  #{@idltype.typename}"
         end
       end
       @multiple = params[:multiple] ? true : false
@@ -1681,8 +1647,7 @@ module IDL::AST
       @boxed_type  = params[:type]
       unless @boxed_type.is_a?(IDL::Type::ScopedName) && @boxed_type.is_node?(IDL::AST::TemplateParam)
         if @boxed_type.resolved_type.is_a?(IDL::Type::Valuetype)
-          raise RuntimeError,
-            "boxing valuetype #{@boxed_type.scoped_lm_name} in Valuebox #{scoped_lm_name} not allowed"
+          raise "boxing valuetype #{@boxed_type.scoped_lm_name} in Valuebox #{scoped_lm_name} not allowed"
         end
       end
     end
@@ -1737,8 +1702,7 @@ module IDL::AST
         _base = _inherits[:base] || {}
         @truncatable = _base[:truncatable] || false
         if @custom && @truncatable
-            raise RuntimeError,
-                  "'truncatable' attribute *not* allowed for 'custom' #{typename} #{scoped_lm_name}"
+            raise "'truncatable' attribute *not* allowed for 'custom' #{typename} #{scoped_lm_name}"
         end
         add_bases(_base[:list] || [])
         add_interfaces(_inherits[:supports] || [])
@@ -1838,33 +1802,26 @@ module IDL::AST
       inherits_.each do |tc|
         unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
           if not (tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::Valuetype))
-            raise RuntimeError,
-                  "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
+            raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
           end
           rtc = tc.resolved_type
           if rtc.node.has_ancestor?(self)
-            raise RuntimeError,
-                  "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
+            raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
           end
           if not rtc.node.is_defined?
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if self.is_abstract? and not rtc.node.is_abstract?
-            raise RuntimeError,
-                  "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if (not self.is_custom?) and rtc.node.is_custom?
-            raise RuntimeError,
-                  "non-'custom' #{typename} #{scoped_lm_name} cannot inherit from 'custom' #{tc.node.typename} #{tc.node.scoped_lm_name}"
+            raise "non-'custom' #{typename} #{scoped_lm_name} cannot inherit from 'custom' #{tc.node.typename} #{tc.node.scoped_lm_name}"
           end
           if @resolved_bases.include?(rtc.node)
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
+            raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
           end
           if (not rtc.node.is_abstract?) and @bases.size > 0
-            raise RuntimeError,
-                  "concrete basevalue #{tc.node.typename} #{tc.node.scoped_lm_name} MUST "+
+            raise "concrete basevalue #{tc.node.typename} #{tc.node.scoped_lm_name} MUST "+
                   "be first and only non-abstract in inheritance list for #{typename} #{scoped_lm_name}"
           end
           @resolved_bases << rtc.node
@@ -1877,18 +1834,15 @@ module IDL::AST
       iflist_.each do |if_|
         unless if_.is_a?(IDL::Type::ScopedName) && if_.is_node?(IDL::AST::TemplateParam)
           if not (if_.is_a?(IDL::Type::ScopedName) && if_.is_node?(IDL::AST::Interface))
-            raise RuntimeError,
-                  "invalid support identifier for #{typename} #{scoped_lm_name}: #{if_.typename}"
+            raise "invalid support identifier for #{typename} #{scoped_lm_name}: #{if_.typename}"
           end
           rif_ = if_.resolved_type
           ### @@TODO@@ further validation
           if (not rif_.node.is_abstract?) and @interfaces.size > 0
-            raise RuntimeError,
-                  "concrete interface '#{rif_.node.scoped_lm_name}' inheritance not allowed for #{typename} #{scoped_lm_name}. Valuetypes can only inherit (support) a single concrete interface."
+            raise "concrete interface '#{rif_.node.scoped_lm_name}' inheritance not allowed for #{typename} #{scoped_lm_name}. Valuetypes can only inherit (support) a single concrete interface."
           end
           if (not rif_.node.is_abstract?) && (not is_interface_compatible?(rif_.node))
-            raise RuntimeError,
-                  "#{typename} #{scoped_lm_name} cannot support concrete interface #{rif_.node.scoped_lm_name} because it does not derive from inherited concrete interfaces"
+            raise "#{typename} #{scoped_lm_name} cannot support concrete interface #{rif_.node.scoped_lm_name} because it does not derive from inherited concrete interfaces"
           end
           @resolved_interfaces << rif_.node
         end
@@ -1910,7 +1864,7 @@ module IDL::AST
 
     def define(_type, _name, *args)
       if self.is_abstract? && [IDL::AST::StateMember, IDL::AST::Initializer].include?(_type)
-        raise RuntimeError, "cannot define statemember #{_name} on abstract #{typename} #{scoped_lm_name}"
+        raise "cannot define statemember #{_name} on abstract #{typename} #{scoped_lm_name}"
       end
       super(_type, _name, *args)
     end
@@ -1947,7 +1901,7 @@ module IDL::AST
         case node
         when IDL::AST::Struct, IDL::AST::Union
           if node.is_defined?
-            raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+            raise "#{node.typename} \"#{node.name}\" is already defined."
           end
           node.annotations.concat(params[:annotations])
 
@@ -1966,13 +1920,13 @@ module IDL::AST
 
           return _new_node
         else
-          raise RuntimeError, "#{node.typename} \"#{node.name}\" is already defined."
+          raise "#{node.typename} \"#{node.name}\" is already defined."
         end
       end
 
       case node
       when IDL::AST::Operation, IDL::AST::Attribute, IDL::AST::StateMember, IDL::AST::Initializer
-        raise RuntimeError, "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
+        raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
       else
         newnode = node.class.new(node.name, self, params)
         newnode.annotations.concat(params[:annotations])
@@ -2023,7 +1977,7 @@ module IDL::AST
       @idltype  = params[:type]
       @visibility = (params[:visibility] == :public ? :public : :private)
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
         ## check for use of incomplete types
         if !@idltype.is_complete?
           ## verify type is used in sequence
@@ -2079,7 +2033,7 @@ module IDL::AST
             @has_incomplete_type = true
             return
           end
-          raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+          raise "Incomplete type #{@idltype.typename} not allowed here!"
         end
       end
     end
@@ -2137,7 +2091,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.'
+          raise 'Only IDL Exception types allowed in raises declaration.'
         end
         @raises << extype
       end
@@ -2192,9 +2146,8 @@ module IDL::AST
       @expression = params[:expression]
       @value = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
-        raise RuntimeError,
-              "Incomplete type #{@idltype.typename} not allowed here!" if !@idltype.is_complete?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Incomplete type #{@idltype.typename} not allowed here!" if !@idltype.is_complete?
         unless @expression.is_a?(IDL::Expression::ScopedName) && @expression.is_node?(IDL::AST::TemplateParam)
           @value = @idltype.narrow(@expression.value)
         end
@@ -2239,20 +2192,19 @@ module IDL::AST
       @idltype  = params[:type]
       @attribute = params[:attribute]
       unless ATTRIBUTE_MAP.has_key?(@attribute)
-        raise RuntimeError,
-          "invalid attribute for parameter: #{params[:attribute]}"
+        raise "invalid attribute for parameter: #{params[:attribute]}"
       end
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
         if @idltype.is_local?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface) && !_enclosure.enclosure.is_local?
-            raise RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
         if !@idltype.is_complete?
           if _enclosure.enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2297,16 +2249,16 @@ module IDL::AST
       @raises = []
       @context = nil
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if params[:type].is_anonymous?
         if @idltype.is_local?
           if _enclosure.is_a?(IDL::AST::Interface) && !_enclosure.is_local?
-            raise RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
         if !@idltype.is_complete?
           if _enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2342,7 +2294,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                 (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception or Native types allowed in raises declaration.'
+          raise 'Only IDL Exception or Native types allowed in raises declaration.'
         end
         @raises << extype
       end
@@ -2407,16 +2359,16 @@ module IDL::AST
       @get_raises = []
       @set_raises = []
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
         if @idltype.is_local?
           if _enclosure.is_a?(IDL::AST::Interface) && !_enclosure.is_local?
-            raise RuntimeError, "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
+            raise "Local type #{@idltype.typename} not allowed for operation on unrestricted interface"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
         if !@idltype.is_complete?
           if _enclosure.is_a?(IDL::AST::Interface)
-            raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+            raise "Incomplete type #{@idltype.typename} not allowed here!"
           end
           ## IDL_Valuetype: no problem as valuetype operations are local
         end
@@ -2451,7 +2403,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
+          raise 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
         end
         @get_raises << extype
       end
@@ -2461,7 +2413,7 @@ module IDL::AST
       exlist.each do |extype|
         unless extype.is_a?(IDL::Type::ScopedName) &&
                   (extype.is_node?(IDL::AST::Exception) || extype.is_node?(IDL::AST::TemplateParam) || extype.resolved_type.is_a?(IDL::Type::Native))
-          raise RuntimeError, 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
+          raise 'Only IDL Exception types allowed in raises declaration.' unless extype.resolved_type.node.is_a?(IDL::AST::Exception)
         end
         @set_raises << extype
       end
@@ -2567,7 +2519,7 @@ module IDL::AST
       super(_name, _enclosure)
       @idltype  = params[:type]
       unless @idltype.is_a?(IDL::Type::ScopedName) && @idltype.is_node?(IDL::AST::TemplateParam)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if @idltype.is_anonymous?
         ## check for use of incomplete types
         if !@idltype.is_complete?
           ## verify type is used in sequence
@@ -2601,7 +2553,7 @@ module IDL::AST
               end
             end
           end
-          raise RuntimeError, "Incomplete type #{@idltype.typename} not allowed here!"
+          raise "Incomplete type #{@idltype.typename} not allowed here!"
         end
       end
     end
@@ -2693,16 +2645,14 @@ module IDL::AST
         ## check union case labels for validity
         m.labels.each { |lbl|
           if lbl == :default
-            raise RuntimeError,
-                  "duplicate case label 'default' for #{typename} #{lm_name}" if default_
+            raise "duplicate case label 'default' for #{typename} #{lm_name}" if default_
             default_ = true
           else
             # correct type
             lv = @switchtype.resolved_type.narrow(lbl.value)
             # doubles
             if labelvals.include? lv
-              raise RuntimeError,
-                    "duplicate case label #{lv.to_s} for #{typename} #{lm_name}"
+              raise "duplicate case label #{lv.to_s} for #{typename} #{lm_name}"
             end
             labelvals << lv
           end
@@ -2711,8 +2661,7 @@ module IDL::AST
       ## check if default allowed if defined
       if default_
         if @switchtype.resolved_type.range_length == labelvals.size
-          raise RuntimeError,
-                "'default' case label superfluous for #{typename} #{lm_name}"
+          raise "'default' case label superfluous for #{typename} #{lm_name}"
         end
       end
     end
@@ -2836,7 +2785,7 @@ module IDL::AST
     def instantiate(_context, _enclosure)
       # find already instantiated Enum parent
       _enum = _enclosure.resolve(@enum.name)
-      raise RuntimeError, "Unable to resolve instantiated Enum scope for enumerator #{@enum.name}::#{name} instantiation" unless _enum
+      raise "Unable to resolve instantiated Enum scope for enumerator #{@enum.name}::#{name} instantiation" unless _enum
       super(_context, _enclosure, { :enum => _enum, :value => @value })
     end
   end # Enumerator

data/lib/ridl/options.rb

@@ -44,7 +44,7 @@ module IDL
     end
 
     def delete(k)
-      modifiable.delete(k)
+      table.delete(k)
     end
 
     def has_key?(k)

data/lib/ridl/optparse_ext.rb

@@ -23,8 +23,9 @@ require 'optparse'
 class OptionParser::Switch::RequiredArgument
   def initialize(pattern = nil, conv = nil,
                  short = nil, long = nil, arg = nil,
-                 desc = ([] if short or long), block = Proc.new)
-    super
+                 desc = ([] if short or long), block = nil, &_block)
+    block ||= _block
+    super(pattern, conv, short, long, arg, desc, block)
     if (@long.nil? || @long.empty?) && (@arg =~ /^(<.*>|[\{].*[\}])((=|\s).*)?/)
       @multichar_short = true
       @has_arg = (@arg =~ /^(<.*>|[\{].*[\}])(=|\s).*$/ ? true : false)
@@ -162,7 +163,7 @@ module IDL
 
           def define_param_set(id, options = {}, &block)
             id = id.to_sym
-            raise RuntimeError, "option parameter set [#{id}] already exists" if @group.sets.has_key?(id)
+            raise "option parameter set [#{id}] already exists" if @group.sets.has_key?(id)
             @group.sets[id] = ParamSet.new(options)
             block.call(ParamSet::Configurator.new(@group.sets[id])) if block_given?
           end
@@ -242,7 +243,7 @@ module IDL
 
         def define_group(id, options = {}, &block)
           id = id.to_sym
-          raise RuntimeError, "option group [#{id}] already exists" if @option.groups.has_key?(id)
+          raise "option group [#{id}] already exists" if @option.groups.has_key?(id)
           @option.groups[id] = Group.new(id, options)
           block.call(Group::Configurator.new(@option.groups[id])) if block_given?
         end
@@ -328,7 +329,7 @@ module IDL
 
     def define_switch(switch, options = {}, &block)
       switch = switch.to_s
-      raise RuntimeError, "switch types mismatch" if @options.has_key?(switch) && options[:type] && options[:type] != @options[switch].type
+      raise "switch types mismatch" if @options.has_key?(switch) && options[:type] && options[:type] != @options[switch].type
       @options[switch] ||= Option.new(switch, options)
       block.call(Option::Configurator.new(@options[switch])) if block_given?
     end
@@ -353,4 +354,4 @@ module IDL
 
   end # OptionList
 
-end # IDL
+end # IDL

data/lib/ridl/runner.rb

@@ -85,7 +85,7 @@ module IDL
     # Production management
 
     def push_production(id, producer)
-      raise RuntimeError, "Producer #{id} already queued" if @productionbatch.has_key?(id.to_sym)
+      raise "Producer #{id} already queued" if @productionbatch.has_key?(id.to_sym)
       @productionbatch[id.to_sym] = @productionstack.size
       @productionstack << [id.to_sym, producer]
     end
@@ -185,7 +185,7 @@ module IDL
                    else
                      File.open(_idlfile, 'r')
                    end
-            raise RuntimeError, 'cannot read from STDOUT' if $stdout == _fio
+            raise 'cannot read from STDOUT' if $stdout == _fio
 
             # parse IDL source
             IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN': (StringIO === _idlfile ? 'from string' : _idlfile)}")

data/lib/ridl/scanner.rb

@@ -517,9 +517,8 @@ module IDL
       else
         if s2[0] == ?_
           s2.slice!(0) ## if starts with CORBA IDL escape => remove
-        else
-          parse_error "identifier must begin with alphabet character: #{s2}" unless ALPHA_LC.include?(s2[0]) || ALPHA_UC.include?(s2[0])
         end
+        parse_error "identifier must begin with alphabet character: #{s2}" unless ALPHA_LC.include?(s2[0]) || ALPHA_UC.include?(s2[0])
       end
 
       # preprocessor check

data/lib/ridl/type.rb

@@ -15,7 +15,7 @@ module IDL
       self.class.name
     end
     def typeerror(val)
-      raise RuntimeError, "#{val.inspect} cannot narrow to #{self.typename}"
+      raise "#{val.inspect} cannot narrow to #{self.typename}"
     end
     def narrow(obj)
       obj
@@ -51,7 +51,7 @@ module IDL
 
     class UndefinedType
       def initialize(*args)
-        raise RuntimeError, "#{self.class.name}'s not implemented yet."
+        raise "#{self.class.name}'s not implemented yet."
       end
     end
 
@@ -222,7 +222,7 @@ module IDL
     class Fixed < Type
       attr_reader :digits, :scale
       def initialize(digits=nil, scale=nil)
-        raise RuntimeError, "significant digits for Fixed should be in the range 0-31" unless digits.nil? || (0..31) === digits.to_i
+        raise "significant digits for Fixed should be in the range 0-31" unless digits.nil? || (0..31) === digits.to_i
         @digits = digits.nil? ? digits : digits.to_i
         @scale = scale.nil? ? scale : scale.to_i
       end
@@ -277,7 +277,7 @@ module IDL
       attr_accessor :recursive
       def length; @size; end
       def initialize(t, size)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if t.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if t.is_anonymous?
         @basetype = t
         @size = size
         @typename = format("sequence<%s%s>", t.typename,
@@ -321,7 +321,7 @@ module IDL
       attr_reader :basetype
       attr_reader :sizes
       def initialize(t, sizes)
-        raise RuntimeError, "Anonymous type definitions are not allowed!" if t.is_anonymous?
+        raise "Anonymous type definitions are not allowed!" if t.is_anonymous?
         @basetype = t
         if sizes.nil?
           @sizes = []

data/lib/ridl/version.rb

@@ -12,9 +12,9 @@
 
 module IDL
 
-  RIDL_VERSION_MAJOR = 2.freeze
-  RIDL_VERSION_MINOR = 7.freeze
-  RIDL_VERSION_RELEASE = 0.freeze
+  RIDL_VERSION_MAJOR = 2
+  RIDL_VERSION_MINOR = 7
+  RIDL_VERSION_RELEASE = 1
   RIDL_VERSION = "#{RIDL_VERSION_MAJOR}.#{RIDL_VERSION_MINOR}.#{RIDL_VERSION_RELEASE}"
   RIDL_COPYRIGHT = "Copyright (c) 2007-#{Time.now.year} Remedy IT Expertise BV, The Netherlands".freeze
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridl
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.7.1
 platform: ruby
 authors:
 - Martin Corino
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-02 00:00:00.000000000 Z
+date: 2020-02-06 00:00:00.000000000 Z
 dependencies: []
 description: OMG v3.3 compliant native Ruby IDL compiler frontend with support for
   pluggable (and stackable) backends.
@@ -41,7 +41,9 @@ files:
 homepage: https://www.remedy.nl/opensource/ridl.html
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/RemedyIT/ridl/issues
+  source_code_uri: https://github.com/RemedyIT/ridl
 post_install_message: 
 rdoc_options:
 - "--main"
@@ -54,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="