ridl 2.8.1 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d24bac3b0aa52e6c84a1ef61d0939d84b3277b139a69db8cfc1f7f95130bf6a2
-  data.tar.gz: 3f773ed9d639811aaba53a68e0ace506b5e6b11591875326665d102faeff5a8f
+  metadata.gz: 25c3bce199d061c1831b488200a21eb0406c7b373d3343d07c9c30de95b75618
+  data.tar.gz: e69b6f0ae05819f53315ca9853b989c3710adb4a226d941d1f3905eaa8d4767c
 SHA512:
-  metadata.gz: 1aa10dbfdb821544c474bc3f41bf48c156a42bf51d909ed631c6030ebd546145f9f9e70945bf4aa54a68e74cfe4a4d27b38dfab937e1576338febc67ea18dc8c
-  data.tar.gz: b96af7bb90418102bfb030dbd798bd15384232ab2547887fd68d4a3e1dc4142c0d997ab15f4de93daf06f39e764d8d8d04720774e81031b537b343daf6570862
+  metadata.gz: ffc5501446d39835035a8a88005daf4a9ada39c2edb6124cfabdc3645f0fa5b8327e6c7671c232f46e7aede73c4252ad784131da1222f70c8752dc90d127c648
+  data.tar.gz: d29f08458378ef6b36516984f8f6d67ff556fb4553c542848e932dc786c7c852e2b2ed91fff7e38684bbedf5e923d2f5a5314980418769e047967a08c8d1a2ac

data/README.rdoc

@@ -1,6 +1,8 @@
-{<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]
+{rdoc-image:https://badge.fury.io/rb/ridl.svg}[https://badge.fury.io/rb/ridl]
+{rdoc-image:https://github.com/RemedyIT/ridl/workflows/r2corba/badge.svg}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Ar2corba]
+{rdoc-image:https://github.com/RemedyIT/ridl/workflows/taox11/badge.svg}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Ataox11]
+{rdoc-image:https://github.com/RemedyIT/ridl/workflows/ciaox11/badge.svg}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Aciaox11]
+{rdoc-image:https://www.codefactor.io/repository/github/remedyit/ridl/badge}[https://www.codefactor.io/repository/github/remedyit/ridl]
 
 = RIDL Compiler
 
@@ -46,3 +48,7 @@ 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].
+
+== Regenerating `lib/racc/parser.rb`
+
+The file `lib/racc/parser.rb` can be regenerated using `racc -o parser.rb -E parser.ry`. The option `-E` embeds the racc parser within RIDL which is required for RIDL because jruby doesn't contain `RACC` as cruby does.

data/lib/ridl/backend.rb

@@ -11,15 +11,14 @@
 #--------------------------------------------------------------------
 
 module IDL
-
   class Backend
-
     @@backends = {}
 
     class ProcessStop < RuntimeError; end
 
     class Configurator
       attr_reader :backend
+
       def initialize(be_name, root, title, copyright, version)
         @backend = IDL::Backend.new(be_name, root, title, copyright, version)
         @be_ext_klass = class << @backend; self; end
@@ -47,10 +46,10 @@ module IDL
         IDL.log(1, "> loaded RIDL backend :#{be_name} from #{@@backends[be_name.to_sym].root}")
         # return backend
         return @@backends[be_name.to_sym]
-      rescue LoadError => ex
+      rescue LoadError => e
         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 e.inspect
+        IDL.error(e.backtrace.join("\n")) if IDL.verbose_level.positive?
         exit 1
       end
     end
@@ -62,7 +61,7 @@ module IDL
     end
 
     # stop processing of current input and skip to next or exit RIDL
-    def self.stop_processing(msg='')
+    def self.stop_processing(msg = '')
       raise ProcessStop, msg, caller(1).first
     end
 
@@ -71,7 +70,7 @@ module IDL
       @root = root
       @title = ttl
       @copyright = cpr
-      @version = (Hash === ver ? ver : { :major => ver.to_i, :minor => 0, :release => 0 })
+      @version = (Hash === ver ? ver : { major: ver.to_i, minor: 0, release: 0 })
       @base_backends = []
     end
 
@@ -84,24 +83,25 @@ module IDL
     def print_version
       puts "#{title} #{version}"
       puts copyright
-      @base_backends.each {|be| puts '---'; be.print_version }
+      @base_backends.each { |be| puts '---'
+ be.print_version }
     end
 
     def lookup_path
-      @base_backends.inject([@root]) {|paths, bbe| paths.concat(bbe.lookup_path) }
+      @base_backends.inject([@root]) { |paths, bbe| paths.concat(bbe.lookup_path) }
     end
 
     def setup_be(optlist, idl_options)
       # initialize base backends in reverse order so each dependent BE can overrule its
       # base settings
-      @base_backends.reverse.each {|be| be.setup_be(optlist, idl_options) }
+      @base_backends.reverse.each { |be| be.setup_be(optlist, idl_options) }
       # initialize this backend
       _setup_be(optlist, idl_options) if self.respond_to?(:_setup_be, true)
     end
 
     def process_input(parser, params)
       # process input bottom-up
-      @base_backends.reverse.each {|be| be.process_input(parser, params) }
+      @base_backends.reverse.each { |be| be.process_input(parser, params) }
       _process_input(parser, params) if self.respond_to?(:_process_input, true)
     end
 
@@ -115,6 +115,5 @@ module IDL
         end
       end
     end
-
   end
 end

data/lib/ridl/delegate.rb

@@ -13,11 +13,9 @@ require 'ridl/node'
 require 'ridl/expression'
 
 module IDL
-
 ORB_PIDL = 'orb.pidlc'.freeze
 
 class Delegator
-
   # #pragma handler registry
   # each keyed entry a callable object:
   # - responds to #call(delegator, cur_node, pragma_string)
@@ -25,7 +23,8 @@ class Delegator
   @@pragma_handlers = {}
 
   def self.add_pragma_handler(key, h = nil, &block)
-    raise '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&.respond_to?(:call) || block_given?
+
     @@pragma_handlers[key] = block_given? ? block : h
   end
 
@@ -41,7 +40,7 @@ class Delegator
     @preprocout = params[:output] if @preprocess
     @ignore_pidl = params[:ignore_pidl] || false
     @root_namespace = nil
-    if not params[:namespace].nil?
+    unless params[:namespace].nil?
       @root_namespace = IDL::AST::Module.new(params[:namespace], nil, {})
     end
   end
@@ -58,8 +57,8 @@ class Delegator
           begin
             @root, @includes = Marshal.load(f)
             @cur = @root
-          rescue Exception => ex
-            IDL.error("RIDL - failed to load ORB pidlc [#{ex}]\n You probably need to rebuild the bootstrap file (compile orb.idl to orb.pidlc).")
+          rescue Exception => e
+            IDL.error("RIDL - failed to load ORB pidlc [#{e}]\n You probably need to rebuild the bootstrap file (compile orb.idl to orb.pidlc).")
             exit(1)
           ensure
             f.close
@@ -73,6 +72,7 @@ class Delegator
     @last = nil
     @last_pos = nil
   end
+
   def post_parse
     if @preprocess
       Marshal.dump([@root, @includes], @preprocout)
@@ -100,7 +100,7 @@ class Delegator
   def walk_member(m, w)
     case m
     when IDL::AST::Include
-      if !m.is_preprocessed?
+      unless m.is_preprocessed?
         if @expand_includes
           if m.is_defined?
             w.enter_include(m)
@@ -131,6 +131,7 @@ class Delegator
       _te = w.respond_to?(:enter_home)
       _tl = w.respond_to?(:leave_home)
       return unless _te || _tl
+
       w.enter_home(m) if _te
       m.walk_members { |cm| walk_member(cm, w) }
       w.leave_home(m) if _tl
@@ -141,6 +142,7 @@ class Delegator
         _te = w.respond_to?(:enter_component)
         _tl = w.respond_to?(:leave_component)
         return unless _te || _tl
+
         w.enter_component(m) if _te
         m.walk_members { |cm| walk_member(cm, w) }
         w.leave_component(m) if _tl
@@ -149,6 +151,7 @@ class Delegator
       _te = w.respond_to?(:enter_connector)
       _tl = w.respond_to?(:leave_connector)
       return unless _te || _tl
+
       w.enter_connector(m) if _te
       m.walk_members { |cm| walk_member(cm, w) }
       w.leave_connector(m) if _tl
@@ -210,7 +213,7 @@ class Delegator
   end
 
   def enter_include(s, fullpath)
-    params = { :filename => s, :fullpath => fullpath }
+    params = { filename: s, fullpath: fullpath }
     params[:defined] = true
     params[:preprocessed] = @preprocess
     @cur = @cur.define(IDL::AST::Include, "$INC:" + s, params)
@@ -219,13 +222,13 @@ class Delegator
     @cur
   end
 
-  def leave_include()
+  def leave_include
     set_last
     @cur = @cur.enclosure
   end
 
   def declare_include(s)
-    params = { :filename => s, :fullpath => @includes[s].fullpath }
+    params = { filename: s, fullpath: @includes[s].fullpath }
     params[:defined] = false
     params[:preprocessed] = @includes[s].is_preprocessed?
     @cur.define(IDL::AST::Include, "$INC:" + s, params)
@@ -258,7 +261,7 @@ class Delegator
   end
 
   def handle_pragma(pragma_string)
-    unless @@pragma_handlers.values.reduce(false) {|rc, h| h.call(self, @cur, pragma_string) || rc }
+    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,7 +292,8 @@ class Delegator
     set_last
     @cur
   end
-  def end_module(node)
+
+  def end_module(_node)
     set_last(@cur)
     @cur = @cur.enclosure # must equals to argument mod
   end
@@ -302,6 +306,7 @@ class Delegator
     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)
     @annotation_stack = IDL::AST::Annotations.new
@@ -316,7 +321,7 @@ class Delegator
       @template_module_name = nil # reset
       define_template_module(*tmp)
     end
-    params = { :type => type }
+    params = { type: type }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::TemplateParam, name, params))
@@ -330,7 +335,8 @@ class Delegator
     unless template_type.node.is_a?(IDL::AST::TemplateModule)
       raise "invalid module template specification: #{template_type.node.typename} #{template_type.node.scoped_lm_name}"
     end
-    params = { :template => template_type.node, :template_params => parameters }
+
+    params = { template: template_type.node, template_params: parameters }
     mod_inst = @cur.define(IDL::AST::Module, name, params)
     mod_inst.annotations.concat(@annotation_stack)
     @annotation_stack = IDL::AST::Annotations.new
@@ -348,13 +354,14 @@ class Delegator
     @cur
   end
 
-  def declare_interface(name, attrib=nil)
+  def declare_interface(name, attrib = nil)
     params = {}
     params[:abstract] = attrib == :abstract
     params[:local] = attrib == :local
     params[:forward] = true
     params[:pseudo] = false
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     @cur.define(IDL::AST::Interface, name, params)
     set_last
     @cur
@@ -372,7 +379,8 @@ class Delegator
     set_last
     @cur = @cur.define(IDL::AST::Interface, name, params)
   end
-  def end_interface(node)
+
+  def end_interface(_node)
     set_last(@cur)
     @cur = @cur.enclosure # must equals to argument mod
   end
@@ -389,7 +397,7 @@ class Delegator
     @cur = @cur.define(IDL::AST::Home, name, params)
   end
 
-  def end_home(node)
+  def end_home(_node)
     set_last(@cur)
     @cur = @cur.enclosure
   end
@@ -398,6 +406,7 @@ class Delegator
     params = {}
     params[:forward] = true
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     set_last
     @cur.define(IDL::AST::Component, name, params)
   end
@@ -412,7 +421,7 @@ class Delegator
     @cur = @cur.define(IDL::AST::Component, name, params)
   end
 
-  def end_component(node)
+  def end_component(_node)
     set_last(@cur)
     @cur = @cur.enclosure
   end
@@ -426,7 +435,7 @@ class Delegator
     @cur = @cur.define(IDL::AST::Connector, name, params)
   end
 
-  def end_connector(node)
+  def end_connector(_node)
     set_last(@cur)
     @cur = @cur.enclosure
   end
@@ -439,7 +448,7 @@ class Delegator
     @cur = @cur.define(IDL::AST::Porttype, name, params)
   end
 
-  def end_porttype(node)
+  def end_porttype(_node)
     set_last(@cur)
     @cur = @cur.enclosure
   end
@@ -455,17 +464,18 @@ class Delegator
     @cur
   end
 
-  def declare_eventtype(name, attrib=nil)
+  def declare_eventtype(name, attrib = nil)
     params = {}
     params[:abstract] = attrib == :abstract
     params[:forward] = true
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     set_last
     @cur.define(IDL::AST::Eventtype, name, params)
     @cur
   end
 
-  def define_eventtype(name, attrib, inherits={})
+  def define_eventtype(name, attrib, inherits = {})
     params = {}
     params[:abstract] = attrib == :abstract
     params[:custom] = attrib == :custom
@@ -478,17 +488,18 @@ class Delegator
     @cur
   end
 
-  def declare_valuetype(name, attrib=nil)
+  def declare_valuetype(name, attrib = nil)
     params = {}
     params[:abstract] = attrib == :abstract
     params[:forward] = true
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     set_last
     @cur.define(IDL::AST::Valuetype, name, params)
     @cur
   end
 
-  def define_valuetype(name, attrib, inherits={})
+  def define_valuetype(name, attrib, inherits = {})
     params = {}
     params[:abstract] = attrib == :abstract
     params[:custom] = attrib == :custom
@@ -521,7 +532,7 @@ class Delegator
   end
 
   def define_valuebox(name, type)
-    params = { :type => type }
+    params = { type: type }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Valuebox, name, params))
@@ -556,6 +567,7 @@ class Delegator
       if n.nil?
         raise "cannot find type name '#{nm}' in scope '#{node.scoped_name}'"
       end
+
       node = n
       first = node if first.nil?
     end
@@ -594,11 +606,12 @@ class Delegator
         Type::Short,
         Type::Long,
         Type::LongLong,
-        Type::ULongLong,
-      ].detect {|t| t::Range === _value }
+        Type::ULongLong
+      ].detect { |t| t::Range === _value }
       if _type.nil?
         raise "it's not a valid integer: #{v.to_s}"
       end
+
       k.new(_type.new, _value)
     when :string
       k.new(Type::String.new, _value)
@@ -623,15 +636,16 @@ class Delegator
     else
       if not ::Integer === _expression.value
         raise "must be integer: #{_expression.value.inspect}"
-      elsif _expression.value < 0
-        raise "must be positive integer: #{_expression.value.to_s}"
+      elsif _expression.value.negative?
+        raise "must be positive integer: #{_expression.value}"
       end
+
       _expression.value
     end
   end
 
   def define_const(_type, _name, _expression)
-    params = { :type => _type, :expression => _expression }
+    params = { type: _type, expression: _expression }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.define(IDL::AST::Const, _name, params))
@@ -639,7 +653,7 @@ class Delegator
   end
 
   def declare_op_header(_oneway, _type, _name)
-    params = Hash.new
+    params = {}
     params[:oneway] = (_oneway == :oneway)
     params[:type]   = _type
     params[:annotations] = @annotation_stack
@@ -647,8 +661,9 @@ class Delegator
     set_last
     @cur = @cur.define(IDL::AST::Operation, _name, params)
   end
+
   def declare_op_parameter(_attribute, _type, _name)
-    params = Hash.new
+    params = {}
     params[:attribute] = _attribute
     params[:type] = _type
     params[:annotations] = @annotation_stack
@@ -656,18 +671,20 @@ class Delegator
     set_last(@cur.define(IDL::AST::Parameter, _name, params))
     @cur
   end
+
   def declare_op_footer(_raises, instantiation_context)
     @cur.raises = _raises || []
     @cur.context = instantiation_context
-    if not @cur.context.nil?
+    unless @cur.context.nil?
       raise "context phrase's not supported"
     end
+
     set_last(@cur)
     @cur = @cur.enclosure
   end
 
-  def declare_attribute(_type, _name, _readonly=false)
-    params = Hash.new
+  def declare_attribute(_type, _name, _readonly = false)
+    params = {}
     params[:type] = _type
     params[:readonly] = _readonly
     params[:annotations] = @annotation_stack
@@ -675,28 +692,32 @@ class Delegator
     set_last(@cur.define(IDL::AST::Attribute, _name, params))
   end
 
-  def declare_struct(_name)
-    params = { :forward => true }
+  def declare_struct(name)
+    params = { forward: true }
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     set_last
-    @cur.define(IDL::AST::Struct, _name, params)
+    @cur.define(IDL::AST::Struct, name, params)
     @cur
   end
-  def define_struct(_name)
-    params = { :forward => false }
+
+  def define_struct(name)
+    params = { forward: false }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last
-    @cur = @cur.define(IDL::AST::Struct, _name, params)
+    @cur = @cur.define(IDL::AST::Struct, name, params)
   end
-  def declare_member(_type, _name)
-    params = Hash.new
+
+  def declare_member(_type, name)
+    params = {}
     params[:type] = _type
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
-    set_last(@cur.define(IDL::AST::Member, _name, params))
+    set_last(@cur.define(IDL::AST::Member, name, params))
     @cur
   end
+
   def end_struct(node)
     node.defined = true
     set_last(@cur)
@@ -704,42 +725,48 @@ class Delegator
     @cur = @cur.enclosure
     ret
   end
-  def define_exception(_name)
-    params = { :forward => false }
+
+  def define_exception(name)
+    params = { forward: false }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last
-    @cur = @cur.define(IDL::AST::Exception, _name, params)
+    @cur = @cur.define(IDL::AST::Exception, name, params)
   end
-  def end_exception(node)
+
+  def end_exception(_node)
     set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
     ret
   end
 
-  def declare_union(_name)
-    params = { :forward => true }
+  def declare_union(name)
+    params = { forward: true }
     raise "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+
     set_last
-    @cur.define(IDL::AST::Union, _name, params)
+    @cur.define(IDL::AST::Union, name, params)
     @cur
   end
-  def define_union(_name)
-    params = { :forward => false }
+
+  def define_union(name)
+    params = { forward: false }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last
-    @cur = @cur.define(IDL::AST::Union, _name, params)
+    @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)
     @annotation_stack = IDL::AST::Annotations.new
     union_node
   end
+
   def define_case(_labels, _type, _name)
-    params = Hash.new
+    params = {}
     params[:type] = _type
     params[:labels] = _labels
     params[:annotations] = @annotation_stack
@@ -747,6 +774,7 @@ class Delegator
     set_last(@cur.define(IDL::AST::UnionMember, _name, params))
     @cur
   end
+
   def end_union(node)
     node.validate_labels
     node.defined = true
@@ -763,18 +791,20 @@ class Delegator
     set_last
     @cur = @cur.define(IDL::AST::Enum, _name, params)
   end
+
   def declare_enumerator(_name)
     n = @cur.enumerators.length
     params = {
-      :value => n,
-      :enum => @cur
+      value: n,
+      enum: @cur
     }
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new
     set_last(@cur.enclosure.define(IDL::AST::Enumerator, _name, params))
     @cur
   end
-  def end_enum(node)
+
+  def end_enum(_node)
     set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
@@ -782,7 +812,7 @@ class Delegator
   end
 
   def declare_typedef(_type, _name)
-    params = Hash.new
+    params = {}
     params[:type] = _type
     params[:annotations] = @annotation_stack
     @annotation_stack = IDL::AST::Annotations.new