ridl 2.8.2 → 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

@@ -18,23 +18,22 @@ require 'ridl/options'
 # -----------------------------------------------------------------------
 
 module IDL
-
   OPTIONS = Options.new({
-      :outputdir       => nil,
-      :includepaths    => [],
-      :xincludepaths   => [],
-      :verbose         => (ENV['RIDL_VERBOSE'] || 0).to_i,
-      :debug           => false,
-      :namespace       => nil,
-      :search_incpath  => false,
-      :backend         => nil,
-      :macros          => {
-      }
+      outputdir: nil,
+      includepaths: [],
+      xincludepaths: [],
+      verbose: (ENV['RIDL_VERBOSE'] || 0).to_i,
+      debug: false,
+      namespace: nil,
+      search_incpath: false,
+      backend: nil,
+      macros: {
+      },
+      idlversion: 3
   })
   CORE_OPTIONS = OPTIONS.keys
 
   class Engine
-
     class ProductionStack
       def initialize
         @stack = []
@@ -56,6 +55,7 @@ module IDL
 
       def pop
         return nil if empty?
+
         id, prod = @stack.shift
         @index.delete(id)
         prod
@@ -63,12 +63,14 @@ module IDL
 
       def peek
         return nil if empty?
+
         id, _ = @stack.first
         id
       end
 
       def remove(id)
         return nil unless has?(id)
+
         i = @index.delete(id.to_sym)
         _, producer = @productionstack.delete(i)
         producer
@@ -90,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
@@ -129,6 +132,7 @@ module IDL
 
     def push_production(id, producer)
       raise "Producer #{id} already queued" if @productionstack.has?(id)
+
       @productionstack.push(id, producer)
     end
 
@@ -183,9 +187,9 @@ module IDL
         # parse arguments
         begin
           @optparser.parse!(argv)
-        rescue ArgumentError => ex
-          IDL.error(ex.inspect)
-          IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level > 0
+        rescue ArgumentError => e
+          IDL.error(e.inspect)
+          IDL.error(e.backtrace.join("\n")) if IDL.verbose_level.positive?
           return false
         end
 
@@ -231,7 +235,7 @@ module IDL
             # process parse result -> code generation
             IDL.log(2, 'RIDL - processing input')
 
-            GenFile.transaction  do
+            GenFile.transaction do
               begin
 
                 backend.process_input(_parser, _opts)
@@ -250,9 +254,9 @@ module IDL
               rescue Backend::ProcessStop
                 IDL.log(2, "RIDL - processing #{IO === _idlfile ? 'from STDIN' : (StringIO === _idlfile ? 'from string' : _idlfile)} stopped with \"#{$!.message}\"")
 
-              rescue => ex
-                IDL.error(ex)
-                IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+              rescue => e
+                IDL.error(e)
+                IDL.error(e.backtrace.join("\n")) unless e.is_a? IDL::ParseError
                 return false
               end
             end
@@ -272,9 +276,9 @@ module IDL
 
       begin
         _parser.parse(io)
-      rescue => ex
-        IDL.error(ex.inspect)
-        IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+      rescue => e
+        IDL.error(e.inspect)
+        IDL.error(e.backtrace.join("\n")) unless e.is_a? IDL::ParseError
         return nil
       ensure
         io.close unless String === io || io == $stdin
@@ -328,7 +332,7 @@ module IDL
 
     def init_optparser
       script_name = File.basename($0, '.*')
-      if not script_name =~ /ridlc/
+      unless script_name =~ /ridlc/
         script_name = 'ruby ' + $0
       end
 
@@ -363,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') { |_|
@@ -398,11 +407,12 @@ module IDL
       opts.separator ""
 
       opts.on('-h', '--help',
-              'Show this help message.') { puts opts; puts; exit }
+              'Show this help message.') { puts opts
+ puts
+ exit }
 
       opts
     end
-
   end
 
   def IDL.engine?
@@ -419,11 +429,13 @@ module IDL
 
   def IDL.pop_input
     return nil unless engine?
+
     Thread.current[:ridl_engine].pop_input
   end
 
   def IDL.peek_input
     return nil unless engine?
+
     Thread.current[:ridl_engine].peek_input
   end
 
@@ -437,11 +449,13 @@ module IDL
 
   def IDL.pop_production
     return nil unless engine?
+
     Thread.current[:ridl_engine].pop_production
   end
 
   def IDL.remove_production(id)
     return nil unless engine?
+
     Thread.current[:ridl_engine].remove_production(id)
   end
 
@@ -455,6 +469,7 @@ module IDL
 
   def IDL.production(id)
     return nil unless engine?
+
     Thread.current[:ridl_engine].production(id)
   end
 
@@ -503,7 +518,7 @@ module IDL
     # add optional search paths for RIDL backends
     options[:be_path] ||= []
     options[:be_path].unshift(*ENV['RIDL_BE_PATH'].split(/#{File::PATH_SEPARATOR}/)) if ENV['RIDL_BE_PATH']
-    options[:be_path].collect! {|p| p.gsub('\\', '/') } # cleanup to prevent mixed path separators
+    options[:be_path].collect! { |p| p.gsub('\\', '/') } # cleanup to prevent mixed path separators
     $:.concat(options[:be_path]) unless options[:be_path].empty?
 
     # check for special bootstrapping switches
@@ -527,5 +542,4 @@ module IDL
       exit(1) unless Thread.current[:ridl_engine].run(argv)
     end
   end # IDL.run
-
 end