ridl 2.9.0 → 2.10.0

data/lib/ridl/parser.ry

@@ -521,6 +521,8 @@ rule
            | union_forward_dcl
            | enum_type
            | "native" native_declarator
+           | bitmask_type
+           | bitset_type
 
   type_declarator : type_spec declarators
                     {
@@ -551,10 +553,13 @@ rule
                      | string_type
                      | wide_string_type
                      | fixed_pt_type
+                     | map_type
 
   constr_type_spec : struct_type
                    | union_type
                    | enum_type
+                   | bitmask_type
+                   | bitset_type
 
   declarators : declarator { [val[0]] }
               | declarators "," declarator { val[0] << val[2] }
@@ -578,23 +583,34 @@ rule
   signed_int : signed_short_int
              | signed_long_int
              | signed_longlong_int
+             | tiny_short_int
+
+  tiny_short_int : "int8" { if @idlversion < 4 then raise "int8 is only supported with IDL4 or newer" else ::IDL::Type::TinyShort.new end }
 
   signed_short_int : "short" { ::IDL::Type::Short.new }
+                   | "int16" { if @idlversion < 4 then raise "int16 is only supported with IDL4 or newer" else ::IDL::Type::Short.new end }
 
-  signed_long_int : "long"   { ::IDL::Type::Long.new }
+  signed_long_int : "long" { ::IDL::Type::Long.new }
+                  | "int32" { if @idlversion < 4 then raise "int32 is only supported with IDL4 or newer" else ::IDL::Type::Long.new end }
 
   signed_longlong_int : "long" "long" { ::IDL::Type::LongLong.new }
+                      | "int64" { if @idlversion < 4 then raise "int64 is only supported with IDL4 or newer" else ::IDL::Type::LongLong.new end }
 
   unsigned_int : unsigned_short_int
                | unsigned_long_int
                | unsigned_longlong_int
+               | unsigned_tiny_short_int
+
+  unsigned_tiny_short_int : "uint8" { if @idlversion < 4 then raise "uint8 is only supported with IDL4 or newer" else ::IDL::Type::UTinyShort.new end }
 
   unsigned_short_int : "unsigned" "short" { ::IDL::Type::UShort.new }
+                     | "uint16" { if @idlversion < 4 then raise "uint16 is only supported with IDL4 or newer" else ::IDL::Type::UShort.new end }
 
   unsigned_long_int : "unsigned" "long" { ::IDL::Type::ULong.new }
+                    | "uint32" { if @idlversion < 4 then raise "uint32 is only supported with IDL4 or newer" else ::IDL::Type::ULong.new end }
 
-  unsigned_longlong_int : "unsigned" "long" "long"
-                             { ::IDL::Type::ULongLong.new }
+  unsigned_longlong_int : "unsigned" "long" "long" { ::IDL::Type::ULongLong.new }
+                        | "uint64" { if @idlversion < 4 then raise "uint64 is only supported with IDL4 or newer" else ::IDL::Type::ULongLong.new end }
 
   char_type : "char" { ::IDL::Type::Char.new }
 
@@ -610,13 +626,15 @@ rule
 
   struct_forward_dcl : struct_def identifier { @d.declare_struct(val[1]) }
 
-  struct_type : struct_header "{" member_list "}"
-                { @d.end_struct(val[0]) }
+  struct_type : struct_header "{" member_list "}" { @d.end_struct(val[0]) }
+              | struct_header "{" "}" { if @idlversion < 4 then raise "empty struct is only supported with IDL4 or newer" else @d.end_struct(val[0]) end }
 
-  struct_header : struct_def identifier  { @d.define_struct(val[1]) }
+  struct_header : struct_def identifier { @d.define_struct(val[1]) }
+                | struct_def identifier ":" struct_inheritance_spec { if @idlversion < 4 then raise "struct inheritance is only supported with IDL4 or newer" else @d.define_struct(val[1], val[3]) end }
 
   struct_def : "struct" { nil }
 
+  struct_inheritance_spec : scoped_name
 
   member_list : member
               | member_list member
@@ -651,6 +669,8 @@ rule
                    | boolean_type
                    | enum_type
                    | scoped_name
+                   | octet_type { if @idlversion < 4 then raise "union with octect discriminator type is only supported with IDL4 or newer" else ::IDL::Type::Octet.new end }
+                   | wide_char_type { if @idlversion < 4 then raise "union with octect discriminator type is only supported with IDL4 or newer" else ::IDL::Type::WChar.new end }
 
   union_body : union_case
              | union_body union_case
@@ -672,14 +692,45 @@ rule
   element_spec : type_spec declarator
                  { val }
 
-  enum_type : _enum_header _enum_body
-                  { @d.end_enum(val[0]) }
+  bitmask_type : bitmask_header bitmask_body { @d.end_bitmask(val[0]) }
+
+  bitmask_header : "bitmask" identifier { @d.define_bitmask(val[1]) }
+
+  bitmask_body : "{" bitmask_list "}"
+
+  bitmask_list : bit_value
+               | bitmask_list "," bit_value
+
+  bit_value : identifier { @d.declare_bitvalue (val[0]) }
+
+  bitset_type : bitset_header bitset_body { @d.end_bitset(val[0]) }
+
+  bitset_header : "bitset" identifier ":" bitset_inheritance_spec { @d.define_bitset(val[1], val[3]) }
+                | "bitset" identifier { @d.define_bitset(val[1]) }
+
+  bitset_inheritance_spec : scoped_name
+
+  bitset_body : "{" bitfield_list "}"
+
+  bitfield_list : bitset_field ";"
+                | bitfield_list bitset_field ";"
+
+  bitset_field : "bitfield" "<" positive_int_const ">" identifier { @d.declare_bitfield(val[4], val[2], nil) }
+               | "bitfield" "<" positive_int_const "," bitfield_destination_type ">" identifier { @d.declare_bitfield(val[6], val[2], val[4]) }
+               | "bitfield" "<" positive_int_const ">" { @d.declare_bitfield(nil, val[2], nil) }
+               | "bitfield" "<" positive_int_const "," bitfield_destination_type ">" { @d.declare_bitfield(nil, val[2], val[4]) }
+
+  bitfield_destination_type : boolean_type
+                            | octet_type
+                            | integer_type
+
+  enum_type : _enum_header _enum_body { @d.end_enum(val[0]) }
 
   _enum_header : "enum" identifier { @d.define_enum(val[1]) }
   _enum_body   : "{" _enumerator_list "}"
 
   _enumerator_list : enumerator
-                   | _enumerator_list ","  enumerator
+                   | _enumerator_list "," enumerator
 
   enumerator : identifier
                {
@@ -691,6 +742,11 @@ rule
                 | "sequence" "<" simple_type_spec ">"
                     { ::IDL::Type::Sequence.new(val[2], nil) }
 
+  map_type : "map" "<" simple_type_spec "," simple_type_spec "," positive_int_const ">"
+                { if @idlversion < 4 then raise "int8 is only supported with IDL4 or newer" else ::IDL::Type::Map.new(val[2], val[4], val[6]) end }
+           | "map" "<" simple_type_spec "," simple_type_spec ">"
+                { if @idlversion < 4 then raise "int8 is only supported with IDL4 or newer" else ::IDL::Type::Map.new(val[2], val[4], nil) end }
+
   string_type   : "string" "<" positive_int_const ">"
                     { ::IDL::Type::String.new(val[2]) }
                 | "string"
@@ -849,6 +905,7 @@ attr_accessor :yydebug
 def initialize(params = {})
   @d = ::IDL::Delegator.new(params)
   @params = params
+  @idlversion = params[:idlversion]
 end
 
 alias on_error0 on_error

data/lib/ridl/runner.rb

@@ -28,7 +28,8 @@ module IDL
       search_incpath: false,
       backend: nil,
       macros: {
-      }
+      },
+      idlversion: 3
   })
   CORE_OPTIONS = OPTIONS.keys
 
@@ -91,7 +92,8 @@ module IDL
         macros: options[:macros].merge({
            __RIDL__: "#{RIDL_VERSION}",
            __RIDLBE__: @backend.name.to_s,
-           __RIDLBE_VER__: @backend.version
+           __RIDLBE_VER__: @backend.version,
+           __RIDL_IDL_VERSION__: options[:idlversion].to_s
         })
       })
       @optparser = init_optparser
@@ -365,6 +367,11 @@ module IDL
               'Default: off') { |_|
         self.options[:debug] = true
       }
+      opts.on('--idl-version=VERSION', Integer,
+              'Set IDL version (3|4)',
+              'Default: 3') { |v|
+        self.options[:idlversion] = v
+      }
       opts.on('--search-includepath',
               'Use include paths to find main IDL source.',
               'Default: off') { |_|

data/lib/ridl/scanner.rb

@@ -83,13 +83,6 @@ module IDL
         else
           @pos.column += 1
         end
-
-        if false
-          if not @bwd.nil? or cur.nil? or @fwd.nil?
-          printf("%c(%02x), %c(%02x), %c(%02x) @(l:%d,c:%d)\n",
-                @bwd, @bwd, cur, cur, @fwd, @fwd, @pos.line, @pos.column)
-          end
-        end
         @bwd = cur
       end
 
@@ -221,10 +214,67 @@ module IDL
       end
     end
 
+    LFCR = [ ("\n"), ("\r") ]
+    SPACES = [ ("\ "), ("\t") ]
+    WHITESPACE = SPACES + LFCR
+
+    ANNOTATION = '@'
+    ANNOTATION_STR = '@'
+
+    BREAKCHARS = [
+      '(', ')', '[', ']', '{', '}',
+      '^', '~',
+      '*', '%', '&', '|',
+      '<', '=', '>',
+      ',', ';' ]
+
+    SHIFTCHARS = [ '<', '>' ]
+
+    DIGITS = ('0'..'9').to_a
+    ALPHA_LC = ('a'..'z').to_a
+    ALPHA_UC = ('A'..'Z').to_a
+    OCTALS = ('0'..'7').to_a
+    HEXCHARS = DIGITS + ('a'..'f').to_a + ('A'..'F').to_a
+    SIGNS = ['-', '+']
+    DOT = '.'
+
+    IDCHARS = ['_' ] + ALPHA_LC + ALPHA_UC
+    FULL_IDCHARS = IDCHARS + DIGITS
+
+    ESCTBL = CharRegistry.new({
+      n: "\n", t: "\t", v: "\v", b: "\b",
+      r: "\r", f: "\f", a: "\a"
+    })
+
+    KEYWORDS = %w(
+      abstract alias any attribute boolean case char component connector const consumes context custom default double
+      exception emits enum eventtype factory FALSE finder fixed float getraises home import in inout interface local
+      long manages mirrorport module multiple native Object octet oneway out port porttype primarykey private provides
+      public publishes raises readonly setraises sequence short string struct supports switch TRUE truncatable typedef
+      typeid typename typeprefix unsigned union uses ValueBase valuetype void wchar wstring
+    ).inject(TokenRegistry.new) { |h, a| h[a.downcase.to_sym] = a
+ h }
+
+    LITERALS = [
+      :integer_literal,
+      :string_literal,
+      # :wide_string_literal,
+      :character_literal,
+      # :wide_character_literal,
+      :fixed_pt_literal,
+      :floating_pt_literal,
+      :boolean_literal]
+
+    BOOL_LITERALS = {
+        false: false,
+        true: true
+      }
+
     # Scanner
     def initialize(src, directiver, params = {})
       @includepaths = params[:includepaths] || []
       @xincludepaths = params[:xincludepaths] || []
+      @idlversion = params[:idlversion]
       @stack = []
       @expansions = []
       @prefix = nil
@@ -258,6 +308,13 @@ module IDL
       @in = In.new(i, nm)
       @scan_comment = false # true if parsing commented annotation
       @in_annotation = false # true if parsing annotation
+
+      # Extend the IDL keywords with IDL4 when enabled
+      if @idlversion >= 4
+        %w(bitfield bitmask bitset map int8 int16 int32 int64 uint8 uint16 uint32 uint64
+    ).inject(KEYWORDS) { |h, a| h[a.downcase.to_sym] = a
+h }
+      end
     end
 
     def find_include(fname, all = true)
@@ -359,62 +416,6 @@ module IDL
       raise e
     end
 
-    LFCR = [ ("\n"), ("\r") ]
-    SPACES = [ ("\ "), ("\t") ]
-    WHITESPACE = SPACES + LFCR
-
-    ANNOTATION = '@'
-    ANNOTATION_STR = '@'
-
-    BREAKCHARS = [
-      '(', ')', '[', ']', '{', '}',
-      '^', '~',
-      '*', '%', '&', '|',
-      '<', '=', '>',
-      ',', ';' ]
-
-    SHIFTCHARS = [ '<', '>' ]
-
-    DIGITS = ('0'..'9').to_a
-    ALPHA_LC = ('a'..'z').to_a
-    ALPHA_UC = ('A'..'Z').to_a
-    OCTALS = ('0'..'7').to_a
-    HEXCHARS = DIGITS + ('a'..'f').to_a + ('A'..'F').to_a
-    SIGNS = ['-', '+']
-    DOT = '.'
-
-    IDCHARS = ['_' ] + ALPHA_LC + ALPHA_UC
-    FULL_IDCHARS = IDCHARS + DIGITS
-
-    ESCTBL = CharRegistry.new({
-      n: "\n", t: "\t", v: "\v", b: "\b",
-      r: "\r", f: "\f", a: "\a"
-    })
-
-    KEYWORDS = %w(
-      abstract alias any attribute boolean case char component connector const consumes context custom default double
-      exception emits enum eventtype factory FALSE finder fixed float getraises home import in inout interface local
-      long manages mirrorport module multiple native Object octet oneway out port porttype primarykey private provides
-      public publishes raises readonly setraises sequence short string struct supports switch TRUE truncatable typedef
-      typeid typename typeprefix unsigned union uses ValueBase valuetype void wchar wstring
-    ).inject(TokenRegistry.new) { |h, a| h[a.downcase.to_sym] = a
- h }
-
-    LITERALS = [
-      :integer_literal,
-      :string_literal,
-      # :wide_string_literal,
-      :character_literal,
-      # :wide_character_literal,
-      :fixed_pt_literal,
-      :floating_pt_literal,
-      :boolean_literal]
-
-    BOOL_LITERALS = {
-        false: false,
-        true: true
-      }
-
     def is_literal?(o)
       LITERALS.include?(o)
     end

data/lib/ridl/type.rb

@@ -176,6 +176,10 @@ module IDL
         val < self.max ? val + 1 : self.min
       end
 
+      def default
+        0
+      end
+
       def Integer.newclass(range, bits)
         k = Class.new(self)
         k.const_set('Range', range)
@@ -184,9 +188,11 @@ module IDL
       end
     end
     Octet     = Integer.newclass(0..0xFF, 8)
+    UTinyShort = Integer.newclass(0..0xFF, 8)
     UShort    = Integer.newclass(0..0xFFFF, 16)
     ULong     = Integer.newclass(0..0xFFFFFFFF, 32)
     ULongLong = Integer.newclass(0..0xFFFFFFFFFFFFFFFF, 64)
+    TinyShort = Integer.newclass(-0x80...0x800, 8)
     Short     = Integer.newclass(-0x8000...0x8000, 16)
     Long      = Integer.newclass(-0x80000000...0x80000000, 32)
     LongLong  = Integer.newclass(-0x8000000000000000...0x8000000000000000, 64)
@@ -214,6 +220,10 @@ module IDL
         Range.include?(val)
       end
 
+      def default
+        false
+      end
+
       def next(val)
         !val
       end
@@ -261,10 +271,11 @@ module IDL
       attr_reader :digits, :scale
 
       def initialize(digits = nil, scale = nil)
+        raise "anonymous fixed definitions are not allowed!" if digits.nil? || scale.nil?
         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
+        @digits = digits.to_i
+        @scale = scale.to_i
       end
 
       def narrow(obj)
@@ -387,6 +398,70 @@ module IDL
       end
     end
 
+    class Map < Type
+      attr_reader :size, :keytype, :valuetype
+      attr_accessor :recursive
+
+      def length
+        @size
+      end
+
+      def initialize(key, value, size)
+        raise "Anonymous type definitions are not allowed!" if key.is_anonymous? || value.is_anonymous?
+
+        @keytype = key
+        @valuetype = value
+        @size = size
+        @typename = format("map<%s,%s%s>", key.typename, value.typename,
+                           if @size.nil? then
+                              ""
+                           else
+                              ", #{IDL::Expression::ScopedName === size ? size.node.name : size.to_s}"
+                           end)
+        @recursive = false
+      end
+
+      def typename
+        @typename
+      end
+
+      def narrow(obj)
+        typeerror(obj)
+      end
+
+      def is_complete?
+        @keytype.resolved_type.is_complete? && @valuetype.resolved_type.is_complete?
+      end
+
+      def is_local?(recurstk = [])
+        @keytype.resolved_type.is_local?(recurstk) && @valuetype.resolved_type.is_local?(recurstk)
+      end
+
+      def is_recursive?
+        @recursive
+      end
+
+      def is_anonymous?
+        true
+      end
+
+      def is_template?
+        (@size && @size.is_a?(IDL::Expression::ScopedName) && @size.node.is_a?(IDL::AST::TemplateParam)) || @basetype.is_template?
+      end
+
+      def matches?(idltype)
+        super && self.size == idltype.size && self.keytype.resolved_type.matches?(idltype.keytype.resolved_type) && self.valuetype.resolved_type.matches?(idltype.valuetype.resolved_type)
+      end
+
+      def instantiate(instantiation_context)
+        if self.is_template?
+          Type::Map.new(@keytype.instantiate(instantiation_context), @valuetype.instantiate(instantiation_context), @size ? @size.instantiate(instantiation_context).value : nil)
+        else
+          self
+        end
+      end
+    end
+
     class Array < Type
       attr_reader :basetype, :sizes
 
@@ -580,6 +655,62 @@ module IDL
       end
     end
 
+    class BitMask < NodeType
+      def narrow(obj)
+        typeerror(obj) unless ::Integer === obj
+        typeerror(obj) unless (0...@node.bitvalues.length) === obj
+        obj
+      end
+
+      def range_length
+        @node.bitvalues.length
+      end
+
+      def min
+        0
+      end
+
+      def max
+        @node.bitvalues.length - 1
+      end
+
+      def in_range?(val)
+        val >= self.min && val <= self.max
+      end
+
+      def next(val)
+        val < self.max ? val + 1 : self.min
+      end
+    end
+
+    class BitSet < NodeType
+      def narrow(obj)
+        typeerror(obj) unless ::Integer === obj
+        typeerror(obj) unless (0...@node.bitfields.length) === obj
+        obj
+      end
+
+      def range_length
+        @node.bitfields.length
+      end
+
+      def min
+        0
+      end
+
+      def max
+        @node.bitfields.length - 1
+      end
+
+      def in_range?(val)
+        val >= self.min && val <= self.max
+      end
+
+      def next(val)
+        val < self.max ? val + 1 : self.min
+      end
+    end
+
     class Const < Type
       attr_reader :type
 

data/lib/ridl/version.rb

@@ -12,7 +12,7 @@
 
 module IDL
   RIDL_VERSION_MAJOR = 2
-  RIDL_VERSION_MINOR = 9
+  RIDL_VERSION_MINOR = 10
   RIDL_VERSION_RELEASE = 0
   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,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ridl
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Martin Corino
 - Johnny Willemsen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2025-09-11 00:00:00.000000000 Z
 dependencies: []
 description: OMG v3.3 compliant native Ruby IDL compiler frontend with support for
   pluggable (and stackable) backends.
@@ -29,7 +29,6 @@ files:
 - lib/ridl/node.rb
 - lib/ridl/options.rb
 - lib/ridl/optparse_ext.rb
-- lib/ridl/parser.diff
 - lib/ridl/parser.rb
 - lib/ridl/parser.ry
 - lib/ridl/require.rb
@@ -44,7 +43,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/RemedyIT/ridl/issues
   source_code_uri: https://github.com/RemedyIT/ridl
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -64,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Ruby OMG IDL compiler
 test_files: []

data/lib/ridl/parser.diff

@@ -1,42 +0,0 @@
-diff --git a/lib/ridl/parser.rb b/lib/ridl/parser.rb
-index 0cc4f7f..a1a44ec 100644
---- a/lib/ridl/parser.rb
-+++ b/lib/ridl/parser.rb
-@@ -40,15 +40,15 @@ module Racc
- 
-   class Parser
- 
--    Racc_Runtime_Version = '1.4.6'
--    Racc_Runtime_Revision = '$Id$'
-+    Racc_Runtime_Version = '1.4.6' unless defined?(Racc_Runtime_Version)
-+    Racc_Runtime_Revision = '$Id$' unless defined?(Racc_Runtime_Revision)
- 
--    Racc_Runtime_Core_Version_R = '1.4.6'
--    Racc_Runtime_Core_Revision_R = '$Id$'.split[1]
-+    Racc_Runtime_Core_Version_R = '1.4.6' unless defined?(Racc_Runtime_Core_Version_R)
-+    Racc_Runtime_Core_Revision_R = '$Id$'.split[1] unless defined?(Racc_Runtime_Core_Revision_R)
-     begin
-       require 'racc/cparse'
-     # Racc_Runtime_Core_Version_C  = (defined in extention)
--      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2]
-+      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2] unless defined?(Racc_Runtime_Core_Revision_C)
-       unless new.respond_to?(:_racc_do_parse_c, true)
-         raise LoadError, 'old cparse.so'
-       end
-@@ -56,11 +56,11 @@ module Racc
-         raise LoadError, 'selecting ruby version of racc runtime core'
-       end
- 
--      Racc_Main_Parsing_Routine    = :_racc_do_parse_c
--      Racc_YY_Parse_Method         = :_racc_yyparse_c
--      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
--      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
--      Racc_Runtime_Type            = 'c'
-+      Racc_Main_Parsing_Routine    = :_racc_do_parse_c unless defined?(Racc_Main_Parsing_Routine)
-+      Racc_YY_Parse_Method         = :_racc_yyparse_c unless defined?(Racc_YY_Parse_Method)
-+      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C unless defined?(Racc_Runtime_Core_Version)
-+      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C unless defined?(Racc_Runtime_Core_Revision)
-+      Racc_Runtime_Type            = 'c' unless defined?(Racc_Runtime_Type)
-     rescue LoadError
-       Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
-       Racc_YY_Parse_Method         = :_racc_yyparse_rb