ridl 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c3bce199d061c1831b488200a21eb0406c7b373d3343d07c9c30de95b75618
-  data.tar.gz: e69b6f0ae05819f53315ca9853b989c3710adb4a226d941d1f3905eaa8d4767c
+  metadata.gz: c813bc37b6ebda1ec576dd678c82e9764a3ecf7160b199c7c55794c7da36c3c8
+  data.tar.gz: 83b7e565b4a8bacdef3b3d3e5cdef124b2314018d54050f48ab5ef8ae4a8d28a
 SHA512:
-  metadata.gz: ffc5501446d39835035a8a88005daf4a9ada39c2edb6124cfabdc3645f0fa5b8327e6c7671c232f46e7aede73c4252ad784131da1222f70c8752dc90d127c648
-  data.tar.gz: d29f08458378ef6b36516984f8f6d67ff556fb4553c542848e932dc786c7c852e2b2ed91fff7e38684bbedf5e923d2f5a5314980418769e047967a08c8d1a2ac
+  metadata.gz: 88ac006539e173dae2972e9c8fa5181afdc7d6418c047b241600b8142507e5f16ee7a977f11e23333a685afc1b8da9cb554a84f36de27089d10c94b0c420e1bb
+  data.tar.gz: 6ab751d08491dd63c33a4608f2ae17d6f603aa401dcf282ef81b9761bbf765463ddbd64a6b79e05e95bfc61f841313347f0abfd65e8287ca256cf4894ce2eb89

data/README.rdoc

@@ -1,7 +1,6 @@
 {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://github.com/RemedyIT/ridl/actions/workflows/r2corba.yml/badge.svg}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Ar2corba]
+{rdoc-image:https://github.com/RemedyIT/ridl/actions/workflows/taox11.yml/badge.svg}[https://github.com/RemedyIT/ridl/actions?query=workflow%3Ataox11]
 {rdoc-image:https://www.codefactor.io/repository/github/remedyit/ridl/badge}[https://www.codefactor.io/repository/github/remedyit/ridl]
 
 = RIDL Compiler
@@ -20,9 +19,11 @@ RIDL provides a framework for implementing compiler/generators for OMG standard
 * a builtin IDL preprocessor expression parser/evaluator
 * a flexible framework for pluggable (and stackable) backends
 * basic support for backend code re-generation
-* compliant with the {OMG IDL 3.5}[https://www.omg.org/spec/IDL/3.5] standard.
+* compliant with the {OMG IDL 3.5}[https://www.omg.org/spec/IDL/3.5] standard
+* support for {OMG IDL 4.2}[https://www.omg.org/spec/IDL/4.2] annotations
+* support for IDL 4.2 map, int8/uint8, explicitly-named integer types, bitmask, bitset, empty struct, and struct inheritance
 
-Remedy IT has developed multiple backends for RIDL. These include:
+Remedy IT has developed multiple backends for RIDL. These include the following open source backends:
 * {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
@@ -49,6 +50,6 @@ The RIDL Gem is a Ruby-only Gem without any dependencies.
 
 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`
+== Regenerating `lib/ridl/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.
+The file `lib/ridl/parser.rb` can be regenerated using `racc -o parser.rb -F -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/delegate.rb

@@ -203,6 +203,14 @@ class Delegator
       w.visit_enum(m)
     when IDL::AST::Enumerator
       w.visit_enumerator(m)
+    when IDL::AST::BitMask
+      w.visit_bitmask(m)
+    when IDL::AST::BitValue
+      w.visit_bitvalue(m)
+    when IDL::AST::BitSet
+      w.visit_bitset(m)
+    when IDL::AST::BitField
+      w.visit_bitfield(m)
     else
       raise "Invalid IDL member type for walkthrough: #{m.class.name}"
     end
@@ -577,8 +585,8 @@ class Delegator
          IDL::AST::Interface, IDL::AST::Home, IDL::AST::Component,
          IDL::AST::Porttype, IDL::AST::Connector,
          IDL::AST::Struct, IDL::AST::Union, IDL::AST::Typedef,
-         IDL::AST::Exception, IDL::AST::Enum,
-         IDL::AST::Valuetype, IDL::AST::Valuebox
+         IDL::AST::Exception, IDL::AST::Enum, IDL::AST::BitMask,
+         IDL::AST::Valuetype, IDL::AST::Valuebox, IDL::AST::BitSet
       Type::ScopedName.new(node)
     when IDL::AST::TemplateParam
       if node.idltype.is_a?(IDL::Type::Const)
@@ -590,6 +598,10 @@ class Delegator
       Expression::ScopedName.new(node)
     when IDL::AST::Enumerator
       Expression::Enumerator.new(node)
+    when IDL::AST::BitValue
+      Expression::BitValue.new(node)
+    when IDL::AST::BitField
+      Expression::BitField.new(node)
     else
       raise "invalid reference to #{node.class.name}: #{node.scoped_name}"
     end
@@ -603,9 +615,11 @@ class Delegator
     when :integer
       _type = [
         Type::Octet,
+        Type::TinyShort,
         Type::Short,
         Type::Long,
         Type::LongLong,
+        Type::UTinyShort,
         Type::ULongLong
       ].detect { |t| t::Range === _value }
       if _type.nil?
@@ -638,6 +652,8 @@ class Delegator
         raise "must be integer: #{_expression.value.inspect}"
       elsif _expression.value.negative?
         raise "must be positive integer: #{_expression.value}"
+      elsif _expression.value.zero?
+        raise "must be positive integer"
       end
 
       _expression.value
@@ -701,9 +717,10 @@ class Delegator
     @cur
   end
 
-  def define_struct(name)
+  def define_struct(name, inherits = nil)
     params = { forward: false }
     params[:annotations] = @annotation_stack
+    params[:inherits] = inherits
     @annotation_stack = IDL::AST::Annotations.new
     set_last
     @cur = @cur.define(IDL::AST::Struct, name, params)
@@ -804,7 +821,67 @@ class Delegator
     @cur
   end
 
-  def end_enum(_node)
+  def end_enum(node)
+    node.determine_bitbound
+    set_last(@cur)
+    ret = IDL::Type::ScopedName.new(@cur)
+    @cur = @cur.enclosure
+    ret
+  end
+
+  def define_bitmask(name)
+    params = {}
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
+    set_last
+    @cur = @cur.define(IDL::AST::BitMask, name, params)
+  end
+
+  def declare_bitvalue(name)
+    p = 0
+    unless @cur.bitvalues.empty?
+      p = @cur.bitvalues.last.position.next
+    end
+    params = {
+      position: p,
+      bitmask: @cur,
+      annotations: @annotation_stack
+    }
+    @annotation_stack = IDL::AST::Annotations.new
+    set_last(@cur.define(IDL::AST::BitValue, name, params))
+    @cur
+  end
+
+  def end_bitmask(node)
+    node.determine_bitbound
+    set_last(@cur)
+    ret = IDL::Type::ScopedName.new(@cur)
+    @cur = @cur.enclosure
+    ret
+  end
+
+  def define_bitset(_name, inherits = nil)
+    params = {}
+    params[:annotations] = @annotation_stack
+    params[:inherits] = inherits
+    @annotation_stack = IDL::AST::Annotations.new
+    set_last
+    @cur = @cur.define(IDL::AST::BitSet, _name, params)
+  end
+
+  def declare_bitfield(name_, bits_, idltype_)
+    params = {
+      bits: bits_,
+      bitset: @cur,
+      idltype: idltype_
+    }
+    params[:annotations] = @annotation_stack
+    @annotation_stack = IDL::AST::Annotations.new
+    set_last(@cur.define(IDL::AST::BitField, name_, params))
+    @cur
+  end
+
+  def end_bitset(_node)
     set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure

data/lib/ridl/expression.rb

@@ -148,13 +148,15 @@ module IDL
           IDL::Type::LongLong, IDL::Type::ULongLong,
           IDL::Type::Long, IDL::Type::ULong,
           IDL::Type::Short, IDL::Type::UShort,
+          IDL::Type::TinyShort, IDL::Type::UTinyShort,
           IDL::Type::Octet
         ]
 
         def Integer2.suite_sign(_t, _v)
           [[IDL::Type::LongLong, IDL::Type::ULongLong],
             [IDL::Type::Long,     IDL::Type::ULong],
-            [IDL::Type::Short,    IDL::Type::UShort]
+            [IDL::Type::Short,    IDL::Type::UShort],
+            [IDL::Type::TinyShort, IDL::Type::UTinyShort]
 ].each do |t|
             next unless t.include? _t
 

data/lib/ridl/node.rb

@@ -269,7 +269,7 @@ module IDL::AST
 
     def define(_type, _name, params = {})
       unless is_definable?(_type)
-        raise "#{_type.to_s} is not definable in #{self.typename}."
+        raise "#{_type} is not definable in #{self.typename}."
       end
 
       node = search_self(_name)
@@ -382,12 +382,17 @@ module IDL::AST
   class UnionMember < Member; end
   class Enum < Leaf; end
   class Enumerator < Leaf; end
+  class BitMask < Node; end
+  class BitValue < Leaf; end
+  class BitSet < Node; end
+  class BitField < Leaf; end
 
   class Module < Node
     DEFINABLE = [
       IDL::AST::Module, IDL::AST::Interface, IDL::AST::Valuebox, IDL::AST::Valuetype, IDL::AST::Const, IDL::AST::Struct,
       IDL::AST::Union, IDL::AST::Enum, IDL::AST::Enumerator, IDL::AST::Typedef, IDL::AST::Include,
-      IDL::AST::Home, IDL::AST::Porttype, IDL::AST::Component, IDL::AST::Connector
+      IDL::AST::Home, IDL::AST::Porttype, IDL::AST::Component, IDL::AST::Connector, IDL::AST::BitMask, IDL::AST::BitValue,
+      IDL::AST::BitSet, IDL::AST::BitField
     ]
     attr_reader :anchor, :next, :template, :template_params
 
@@ -742,6 +747,8 @@ module IDL::AST
                  IDL::Type::Union, # 'union'
                  IDL::Type::Exception, # 'exception'
                  IDL::Type::Enum # 'enum'
+                 IDL::Type::BitMask# 'bitmask'
+                 IDL::Type::BitSet# 'bitset'
                # no further checks
             when IDL::Type::Sequence # 'sequence' or 'sequence<...>'
               _tptype = _tp.idltype
@@ -2515,6 +2522,24 @@ module IDL::AST
       @forward = params[:forward] ? true : false
       super(_name, _enclosure)
       @idltype = IDL::Type::Struct.new(self)
+      @base = set_base(params[:inherits])
+    end
+
+    def set_base(inherits)
+      unless inherits.nil?
+        rtc = inherits.resolved_type
+        unless rtc.node.is_defined?
+         raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        unless rtc.node.is_a?(IDL::AST::Struct)
+          raise "#{typename} #{scoped_lm_name} cannot inherit from non structure #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        inherits.node
+      end
+    end
+
+    def base
+      @base
     end
 
     def is_defined?
@@ -2545,6 +2570,10 @@ module IDL::AST
       @children.find_all { |c| c.is_a? IDL::AST::Member }
     end
 
+    def types
+      @children.reject { |c| c.is_a? IDL::AST::Member }
+    end
+
     def is_local?(recurstk = [])
       # not local if forward decl or recursion detected
       return false if is_forward? || recurstk.include?(self)
@@ -2556,10 +2585,11 @@ module IDL::AST
     end
 
     def marshal_dump
-      super() << @idltype << @defined << @recursive << @forward
+      super() << @idltype << @defined << @recursive << @forward << @base
     end
 
     def marshal_load(vars)
+      @base = vars.pop
       @forward = vars.pop
       @recursive = vars.pop
       @defined = vars.pop
@@ -2706,6 +2736,10 @@ module IDL::AST
       @children.find_all { |c| c.is_a? IDL::AST::UnionMember }
     end
 
+    def types
+      @children.reject { |c| c.is_a? IDL::AST::UnionMember }
+    end
+
     def is_local?(recurstk = [])
       # not local if forward decl or recursion detected
       return false if is_forward? || recurstk.include?(self)
@@ -2722,6 +2756,7 @@ module IDL::AST
 
     def default_label
       swtype = @switchtype.resolved_type
+      return nil if IDL::Type::WChar === swtype # No default label detection for wchar
       lbls = members.collect { |m| m.labels.include?(:default) ? [] : m.labels.collect { |l| l.value } }.flatten
       lbls = lbls.sort unless IDL::Type::Boolean === swtype ## work around bug in Ruby 1.9.2
       def_lbl = swtype.min
@@ -2828,20 +2863,25 @@ module IDL::AST
   end # UnionMember
 
   class Enum < Leaf
-    attr_reader :idltype
+    attr_reader :idltype, :bitbound, :bitbound_bits
 
-    def initialize(_name, _enclosure, _params)
-      super(_name, _enclosure)
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
       @enums = []
       @idltype = IDL::Type::Enum.new(self)
+      @bitbound = IDL::Type::ULong.new
+      @bitbound_bits = 32
+      annotations.concat(params[:annotations])
     end
 
     def marshal_dump
-      super() << @idltype << @enums
+      super() << @idltype << @bitbound << @bitbound_bits << @enums
     end
 
     def marshal_load(vars)
       @enums = vars.pop
+      @bitbound = vars.pop
+      @bitbound_bits = vars.pop
       @idltype = vars.pop
       super(vars)
     end
@@ -2854,6 +2894,19 @@ module IDL::AST
       @enums << n
     end
 
+    def determine_bitbound
+      bitbound = annotations[:bit_bound].first
+      unless bitbound.nil?
+        @bitbound_bits = bitbound.fields[:value]
+        raise "Missing number of bits for bit_bound annotation for #{name}" if @bitbound_bits.nil?
+        raise "Illegal negative bit_bound #{bits} value for #{name}" if @bitbound_bits.negative?
+        raise "Illegal zero bit_bound value for #{name}, not #{bits}" if @bitbound_bits.zero?
+        raise "Bitbound for #{name} must be <= 32" unless @bitbound_bits <= 32
+      end
+      @bitbound = IDL::Type::UTinyShort.new if @bitbound_bits.between?(1,8)
+      @bitbound = IDL::Type::UShort.new if @bitbound_bits.between?(9,16)
+    end
+
     def instantiate(instantiation_context, _enclosure)
       super(instantiation_context, _enclosure, {})
     end
@@ -2890,11 +2943,235 @@ module IDL::AST
     end
   end # Enumerator
 
-  class Typedef < Leaf
+  class BitMask < Node
+    DEFINABLE = [IDL::AST::BitValue]
+    attr_reader :idltype, :bitbound, :bitbound_bits
+
+    def initialize(name, enclosure, params)
+      super(name, enclosure)
+      @bitvalues = []
+      @idltype = IDL::Type::BitMask.new(self)
+      annotations.concat(params[:annotations])
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitbound << @bitbound_bits << @bitvalues
+    end
+
+    def marshal_load(vars)
+      @bitvalues = vars.pop
+      @bitbound_bits = vars.pop
+      @bitbound = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def bitvalues
+      @bitvalues
+    end
+
+    def add_bitvalue(n)
+      @bitvalues << n
+    end
+
+    def determine_bitbound
+      bitbound = annotations[:bit_bound].first
+      @bitbound_bits = @bitvalues.size
+      unless bitbound.nil?
+        @bitbound_bits = bitbound.fields[:value]
+        raise "Missing number of bits for bit_bound annotation for #{name}" if @bitbound_bits.nil?
+        raise "Illegal negative bit_bound #{bits} value for #{name}" if @bitbound_bits.negative?
+        raise "Illegal zero bit_bound value for #{name}, not #{bits}" if @bitbound_bits.zero?
+        raise "Bitbound for #{name} must be <= 64" unless @bitbound_bits <= 64
+      end
+      @bitbound = IDL::Type::UTinyShort.new if @bitbound_bits.between?(1,8)
+      @bitbound = IDL::Type::UShort.new if @bitbound_bits.between?(9,16)
+      @bitbound = IDL::Type::ULong.new if @bitbound_bits.between?(17,32)
+      @bitbound = IDL::Type::ULongLong.new if @bitbound_bits.between?(33,64)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
+    end
+  end # BitMask
+
+  class BitValue < Leaf
+    attr_reader :idltype, :bitmask, :position
+
+    def initialize(name, enclosure, params)
+      super(name, enclosure)
+      @idltype = IDL::Type::ULong.new
+      @bitmask = params[:bitmask]
+      @position = params[:position]
+      annotations.concat(params[:annotations])
+      position_annotation = annotations[:position].first
+      unless position_annotation.nil?
+        @position = position_annotation.fields[:value]
+      end
+      @bitmask.add_bitvalue(self)
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitmask << @position
+    end
+
+    def marshal_load(vars)
+      @position = vars.pop
+      @bitmask = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      # find already instantiated BitMask parent
+      _bitmask = _enclosure.resolve(@bitmask.name)
+      raise "Unable to resolve instantiated BitMask scope for bitvalue #{@bitmask.name}::#{name} instantiation" unless _bitmask
+
+      super(instantiation_context, _enclosure, { bitmask: _bitmask, position: @position })
+    end
+  end # BitValue
+
+  class BitSet < Node
+    DEFINABLE = [IDL::AST::BitField]
     attr_reader :idltype
 
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
+      @bitfields = []
+      @bitset_bits = 0
+      @idltype = IDL::Type::BitSet.new(self)
+      @base = set_base(params[:inherits])
+    end
+
+    def set_base(inherits)
+      unless inherits.nil?
+        rtc = inherits.resolved_type
+        unless rtc.node.is_a?(IDL::AST::BitSet)
+          raise "#{typename} #{scoped_lm_name} cannot inherit from non bitset #{rtc.node.typename} #{rtc.node.scoped_lm_name}"
+        end
+        inherits.node
+      end
+    end
+
+    def base
+      @base
+    end
+
+    # Override from Node base to handle anonymous bitfields
+    def define(_type, _name, params = {})
+      unless is_definable?(_type)
+        raise "#{_type} is not definable in #{self.typename}."
+      end
+
+      # All IDL definables have a name except a bitfield, that has an optional name and can
+      # be anonymous
+      node = search_self(_name) unless _name.nil?
+      if node.nil?
+        node = _type.new(_name, self, params)
+        node.annotations.concat(params[:annotations])
+        node.prefix = @prefix
+        introduce(node) unless _name.nil? # If there is no name don't introduce it in our scope
+        @children << node
+      else
+        if _type != node.class
+          raise "#{_name} is already defined as a type of #{node.typename}"
+        end
+
+        node = redefine(node, params)
+      end
+      node
+    end
+
+    def marshal_dump
+      super() << @idltype << @bitset_bits << @bitfields << @base
+    end
+
+    def marshal_load(vars)
+      @base = vars.pop
+      @bitfields = vars.pop
+      @bitset_bits = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    # Total number of bits in this bitset including the optional base
+    def bitset_bits
+      base.nil? ? @bitset_bits : @bitset_bits + base.bitset_bits
+    end
+
+    # Underlying type which is large enough to contain the full bitset
+    # including its base
+    def underlying_type
+      return IDL::Type::UTinyShort.new if bitset_bits.between?(1,8)
+      return IDL::Type::UShort.new if bitset_bits.between?(9,16)
+      return IDL::Type::ULong.new if bitset_bits.between?(17,32)
+      return IDL::Type::ULongLong.new if bitset_bits.between?(33,64)
+    end
+
+    def bitfields
+      @bitfields
+    end
+
+    def add_bitfield(n)
+      @bitfields << n
+      @bitset_bits += n.bits
+      raise "Bitset size #{bitset_bits} must be between 1 and 64" unless bitset_bits.between?(1, 64)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      super(instantiation_context, _enclosure, {})
+    end
+  end # BitSet
+
+  class BitField < Leaf
+    attr_reader :idltype, :bitset, :bits
+
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
+      @idltype = params[:idltype]
+      @bitset = params[:bitset]
+      @bits = params[:bits]
+
+      raise "Amount of bits for bitfield #{_name} must <= 64, not #{bits}" if bits > 64
+
+      # When no IDL type has been specified for the bitfield in IDL we need to determine
+      # the underlying type based on the number of bits
+      if @idltype.nil?
+        @idltype = IDL::Type::Boolean.new if bits == 1
+        @idltype = IDL::Type::TinyShort.new if bits.between?(2,8)
+        @idltype = IDL::Type::Short.new if bits.between?(9,16)
+        @idltype = IDL::Type::Long.new if bits.between?(17,32)
+        @idltype = IDL::Type::LongLong.new if bits.between?(33,64)
+      end
+      @bitset.add_bitfield(self)
+    end
+
+    def marshal_dump
+      super() << @idltype << @bits << @bitset << @value
+    end
+
+    def marshal_load(vars)
+      @value = vars.pop
+      @bitset = vars.pop
+      @bits = vars.pop
+      @idltype = vars.pop
+      super(vars)
+    end
+
+    def instantiate(instantiation_context, _enclosure)
+      # find already instantiated BitSet parent
+      _bitmask = _enclosure.resolve(@bitset.name)
+      raise "Unable to resolve instantiated BitSet scope for bitfield #{@bitset.name}::#{name} instantiation" unless _bitset
+
+      super(instantiation_context, _enclosure, { bitset: _bitset, bits: @bits })
+    end
+  end # BitField
+
+  class Typedef < Leaf
+    attr_reader :idltype
+
+    def initialize(_name, enclosure, params)
+      super(_name, enclosure)
       @idltype = params[:type]
     end
 

data/lib/ridl/options.rb

@@ -67,7 +67,7 @@ module IDL
 
     def load(rcpath)
       IDL.log(3, "Loading #{RIDLRC} from #{rcpath}")
-      _cfg = JSON.parse(IO.read(rcpath))
+      _cfg = JSON.parse(File.read(rcpath))
       IDL.log(4, "Read from #{rcpath}: [#{_cfg}]")
       _rcdir = File.dirname(rcpath)
       # handle automatic env var expansion in ridl be_paths