ridl 2.5.6 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 314694ac1e00cdc3cbc8d6afdc18e1e7e3884670
-  data.tar.gz: 9899c45caa2b63b1ac39c444e9e4a6c3adce1bfa
+SHA256:
+  metadata.gz: 18e62df6c0bae092d3d8f3da6ab5cf8fad2fadfe5e839c72d59660868c187f1a
+  data.tar.gz: 5a51e665b994e566b6579e7f76dab959947b1294ddacc7bd566febef1dbe1766
 SHA512:
-  metadata.gz: 0d0dbd35ff3af48b46bc0fc8f3a0c34c136ce65a8a62e3a2314563af00ed73efa96938d16a7fa12526a6817b9dbb125781b7d36cdc5a166a483a79a3a2156bbf
-  data.tar.gz: 51ac6bf5289b2e18e87bc3f0389c43a980f0d3188f2c97c0cbccc315cb0f6bdecd72cc103bd2599d219a1ee5e6b1f4fe083d9dfda10719d434db0bbb228bb0da
+  metadata.gz: d6cce4394f7a366135dd636f935ea90348cba4c2bd20aa95d9f712a88c45cfaacdc82381039e329c1be1bb3d34f9fe70269a1891296ea63179ad8cea0c39ee77
+  data.tar.gz: b2eda0b126d08ed4cdb66bfbd7795b8f7660b45e24776fb655267885f07a444cd47e8fea42fc3893f464ec63fa3ef5e08b722549f9f90425d9708b702382699c

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,47 @@
-= RIDL Compiler
+{<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]
 
-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
@@ -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
 

data/lib/ridl/expression.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'ridl/node'
 

data/lib/ridl/genfile.rb

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'tempfile'
 require 'fileutils'

data/lib/ridl/node.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::AST
 
@@ -488,8 +487,12 @@ module IDL::AST
         return _next
       when IDL::AST::Interface
         node.annotations.concat(params[:annotations])
-        return node if params[:forward]
-        if node.is_defined?
+        # in case of a forward declaration in the same module ignore it since a previous declaration already exists
+        if params[:forward]
+          return node if node.enclosure == self
+          # 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."
         end
         if (node.is_abstract? != params[:abstract]) || (node.is_local? != params[:local]) || (node.is_pseudo? != params[:pseudo])
@@ -503,9 +506,15 @@ module IDL::AST
         _intf.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))
 
         @children << _intf
-        # replace forward node registration
-        node.enclosure.undo_introduction(node)
-        introduce(_intf)
+
+        # in case of a full declaration undo the preceding forward introduction and
+        # replace by full node
+        # (no need to introduce forward declaration since there is a preceding introduction)
+        unless params[:forward]
+          # replace forward node registration
+          node.enclosure.undo_introduction(node)
+          introduce(_intf)
+        end
 
         return _intf
       when IDL::AST::Valuetype
@@ -671,6 +680,14 @@ module IDL::AST
       @concrete = _param
     end
 
+    def concrete_matches?(idl_type)
+      if @concrete
+        concrete_type = (@concrete.is_a?(IDL::Type) ? @concrete : @concrete.idltype).resolved_type
+        return concrete_type.matches?(idl_type.resolved_type)
+      end
+      false
+    end
+
     def self.concrete_param(_context, _node)
       if _node.is_template?
         _cnode = if _node.is_a?(IDL::AST::TemplateParam)
@@ -746,8 +763,7 @@ module IDL::AST
                 # check basetype
                 unless _tptype.basetype.is_a?(IDL::Type::ScopedName) &&
                        _tptype.basetype.is_node?(IDL::AST::TemplateParam) &&
-                       _tptype.basetype.node.concrete &&
-                       _tptype.basetype.node.concrete.idltype.resolved_type == _cp.resolved_type.basetype.resolved_type
+                       _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}"
                 end
               end
@@ -2792,6 +2808,7 @@ module IDL::AST
     def instantiate(_context, _enclosure)
       super(_context, _enclosure, {})
     end
+
   end # Enum
 
   class Enumerator < Leaf
@@ -2817,7 +2834,10 @@ module IDL::AST
     end
 
     def instantiate(_context, _enclosure)
-      super(_context, _enclosure, { :enum => @enum, :value => @value })
+      # 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
+      super(_context, _enclosure, { :enum => _enum, :value => @value })
     end
   end # Enumerator
 

data/lib/ridl/options.rb

@@ -0,0 +1,176 @@
+#--------------------------------------------------------------------
+# options.rb - Ruby IDL compiler options class
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+
+require 'ostruct'
+require 'json'
+
+module IDL
+
+  RIDLRC = '.ridlrc'
+  RIDLRC_GLOBAL = File.expand_path(File.join(ENV['HOME'] || ENV['HOMEPATH'] || '~', RIDLRC))
+
+  class Options < OpenStruct
+
+    def initialize(hash=nil, marked=nil)
+      super(hash)
+      @marked = marked
+    end
+
+    def merge!(from, *keys)
+      _merge(@table, from, *keys)
+      self
+    end
+
+    def merge(from, *keys)
+      self.dup.merge!(from, *keys)
+    end
+
+    def copy!(from, *keys)
+      keys.flatten.each {|k| self[k] = from[k] }
+      self
+    end
+
+    def copy(from, *keys)
+      self.dup.copy!(from, *keys)
+    end
+
+    def delete(k)
+      modifiable.delete(k)
+    end
+
+    def has_key?(k)
+      @table.has_key?(k)
+    end
+
+    def keys
+      @table.keys
+    end
+
+    def dup
+      self.class.new(_dup_elem(@table), @marked)
+    end
+
+    def mark
+      @marked = _dup_elem(@table)
+    end
+
+    def restore
+      self.class.new(_dup_elem(@marked || @table), @marked)
+    end
+
+
+    def load(rcpath)
+      IDL.log(3, "Loading #{RIDLRC} from #{rcpath}")
+      _cfg = JSON.parse(IO.read(rcpath))
+      IDL.log(4, "Read from #{rcpath}: [#{_cfg}]")
+      _rcdir = File.dirname(rcpath)
+      # handle automatic env var expansion in ridl be_paths
+      _cfg['be_path'] = (_cfg['be_path'] || []).collect do |p|
+        IDL.log(5, "Examining RIDL be path [#{p}]")
+        # for paths coming from rc files environment vars are immediately expanded and
+        p.gsub!(/\$([^\s\/]+)/) { |m| ENV[$1] }
+        IDL.log(6, "Expanded RIDL be path [#{p}]")
+        # resulting relative paths converted to absolute paths
+        _fp = File.expand_path(p, _rcdir)
+        if File.directory?(_fp) # relative to rc location?
+          p = _fp
+        end # or relative to working dir
+        IDL.fatal("Cannot access RIDL backend search path #{p} configured in #{rcpath}") unless File.directory?(p)
+        IDL.log(4, "Adding RIDL backend search path : #{p}")
+        p
+      end
+      merge!(_cfg)
+    end
+
+    protected
+
+    def _merge(to, from, *keys)
+      keys = keys.flatten.collect {|k| k.to_sym}
+      keys = from.keys if keys.empty?
+      keys.each do |k|
+        if from.has_key?(k)
+          v = from[k]
+          k = k.to_sym
+          if to.has_key?(k)
+            case to[k]
+            when Array
+              to[k].concat v
+            when Hash
+              to[k].merge!(Hash === v ? v : v.to_h)
+            when OpenStruct
+              _merge(to[k].__send__(:table), v)
+            else
+              to[k] = v
+            end
+          else
+            to[k] = v
+          end
+        end
+      end
+      to
+    end
+
+    def _dup_elem(v)
+      case v
+      when Array
+        v.collect {|e| _dup_elem(e) }
+      when Hash
+        v.inject({}) {|h, (k,e)| h[k] = _dup_elem(e); h }
+      when OpenStruct
+        v.class.new(_dup_elem(v.__send__(:table)))
+      else
+        v
+      end
+    end
+
+    public
+
+    def self.load_config(opt)
+      # first collect config from known (standard and configured) locations
+      _rc_paths = [ RIDLRC_GLOBAL ]
+      _loaded_rc_paths = []
+      (ENV['RIDLRC'] || '').split(/:|;/).each do |p|
+        _rc_paths << p unless _rc_paths.include?(p)
+      end
+      _rc_paths.collect {|path| File.expand_path(path) }.each do |rcp|
+        IDL.log(3, "Testing rc path #{rcp}")
+        if File.readable?(rcp) && !_loaded_rc_paths.include?(rcp)
+          opt.load(rcp)
+          _loaded_rc_paths << rcp
+        else
+          IDL.log(3, "Ignoring #{File.readable?(rcp) ? 'already loaded' : 'inaccessible'} rc path #{rcp}")
+        end
+      end
+      # now scan working path for any rc files
+      _cwd = File.expand_path(Dir.getwd)
+      IDL.log(3, "scanning working path #{_cwd} for rc files")
+      # first collect any rc files found
+      _rc_paths = []
+      begin
+        _rcp = File.join(_cwd, RIDLRC)
+        if File.readable?(_rcp) && !_loaded_rc_paths.include?(_rcp)
+          _rc_paths << _rcp unless _rc_paths.include?(_rcp)
+        else
+          IDL.log(3, "Ignoring #{File.readable?(_rcp) ? 'already loaded' : 'inaccessible'} rc path #{_rcp}")
+        end
+        break if /\A(.:(\\|\/)|\.|\/)\Z/ =~ _cwd
+        _cwd = File.dirname(_cwd)
+      end while true
+      # now load them in reverse order
+      _rc_paths.reverse.each do |_rcp|
+        opt.load(_rcp)
+        _loaded_rc_paths << _rcp
+      end
+    end
+  end
+
+end