ridl 2.5.6 → 2.8.1

data/lib/ridl/parser.ry

@@ -8,7 +8,6 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 
 class Parser
@@ -52,7 +51,7 @@ rule
                            { @d.register_template_module_name(val[1]) }
 
   template_module_parameters : template_module_parameter
-                             | template_module_parameters "," template_module_parameter 
+                             | template_module_parameters "," template_module_parameter
 
   template_module_parameter : "typename" identifier
                               { @d.define_template_parameter(val[1], IDL::Type::Any.new) }
@@ -78,7 +77,7 @@ rule
                               { @d.define_template_parameter(val[1], val[0]) }
 
   template_module_body : template_module_definition
-                       | template_module_body template_module_definition  
+                       | template_module_body template_module_definition
 
   template_module_definition : type_dcl ";"
                              | const_dcl ";"
@@ -117,22 +116,20 @@ rule
 
   template_module_inst : template_module_header "<" template_module_inst_parameters ">" identifier
                          { @d.instantiate_template_module(val[4], val[2]) }
-  
+
   template_module_inst_parameters : template_module_inst_parameter
                                     { [val[0]] }
                                   | template_module_inst_parameters "," template_module_inst_parameter
-                                    { val[0] << val[2]; val[0] }                                 
+                                    { val[0] << val[2]; val[0] }
 
-  template_module_inst_parameter : base_type_spec
-                                   { val[0] }
-                                 | template_type_spec
+  template_module_inst_parameter : simple_type_spec
                                    { val[0] }
                                  | const_exp
                                    { val[0] }
 
   template_module_reference : "alias" scoped_name "<" _scoped_name_list ">" identifier
                               { @d.declare_template_reference(val[5], val[1], val[3]) }
-                              
+
   interface     : interface_dcl
                 | forward_dcl
 
@@ -194,7 +191,7 @@ rule
 
   home : home_header "{" home_body "}"
          { @d.end_home(val[0]) }
-  
+
   home_header : "home" identifier ":" home_inheritance_spec "supports" home_supports_spec "manages" scoped_name "primarykey" home_primarykey_spec
                 { @d.define_home(val[1], val[3], val[7], val[9], val[5]) }
               | "home" identifier ":" home_inheritance_spec "supports" home_supports_spec "manages" scoped_name
@@ -211,11 +208,11 @@ rule
                 { @d.define_home(val[1], nil, val[3], val[5], nil) }
               | "home" identifier "manages" scoped_name
                 { @d.define_home(val[1], nil, val[3], nil, nil) }
-  
-  home_inheritance_spec : scoped_name 
-                        
+
+  home_inheritance_spec : scoped_name
+
   home_supports_spec : _interface_name_list
-                     
+
   home_primarykey_spec : scoped_name
 
   home_body : home_export
@@ -227,26 +224,26 @@ rule
 
   porttype : porttype_header "{" porttype_body "}"
              { @d.end_porttype(val[0]) }
-  
+
   porttype_header : "porttype" identifier
                     { @d.define_porttype(val[1]) }
-  
+
   porttype_body : porttype_export
                 | porttype_body porttype_export
 
   porttype_export : provides_dcl ";"
                   | uses_dcl ";"
                   | attr_dcl ";"
-  
+
   component : component_dcl
             | component_forward_dcl
-            
+
   component_forward_dcl : "component" identifier
                           { @d.declare_component(val[1]) }
-            
+
   component_dcl : component_header "{" component_body "}"
                 { @d.end_component(val[0]) }
-  
+
   component_header : "component" identifier ":" component_inheritance_spec "supports" component_supports_spec
                      { @d.define_component(val[1], val[3], val[5]) }
                    | "component" identifier ":" component_inheritance_spec
@@ -255,11 +252,11 @@ rule
                      { @d.define_component(val[1], nil, val[3]) }
                    | "component" identifier
                      { @d.define_component(val[1], nil, nil) }
-  
+
   component_inheritance_spec : scoped_name
-                        
+
   component_supports_spec : _interface_name_list
-                     
+
   component_body : component_export
                  | component_body component_export
 
@@ -274,7 +271,7 @@ rule
 
   connector : connector_header "{" connector_body "}"
               { @d.end_connector(val[0]) }
-  
+
   connector_header : "connector" identifier ":" scoped_name
                      { @d.define_connector(val[1], val[3]) }
                    | "connector" identifier
@@ -291,33 +288,33 @@ rule
 
   provides_dcl : "provides" interface_type identifier
                  { @d.declare_port(val[2], :facet, val[1]) }
-  
+
   uses_dcl : "uses" "multiple" interface_type identifier
              { @d.declare_port(val[3], :receptacle, val[2], true) }
            | "uses" interface_type identifier
              { @d.declare_port(val[2], :receptacle, val[1], false) }
-  
+
   publishes_dcl : "publishes" scoped_name identifier
                   { @d.declare_port(val[2], :publisher, val[1]) }
-  
+
   emits_dcl : "emits" scoped_name identifier
               { @d.declare_port(val[2], :emitter, val[1]) }
-  
+
   consumes_dcl : "consumes" scoped_name identifier
                  { @d.declare_port(val[2], :consumer, val[1]) }
-  
+
   port_dcl : "port" scoped_name identifier
              { @d.declare_port(val[2], :port, val[1]) }
            | "mirrorport" scoped_name identifier
              { @d.declare_port(val[2], :mirrorport, val[1]) }
-  
+
   interface_type : scoped_name
-                 | object_type 
+                 | object_type
 
   scoped_name    : scoped_name_0               { @d.parse_scopedname(*val[0]) }
 
-  scoped_name_0  : identifier                  { [FALSE, [val[0]]] }
-                 | "::"  identifier            { [TRUE,  [val[1]]] }
+  scoped_name_0  : identifier                  { [false, [val[0]]] }
+                 | "::"  identifier            { [true,  [val[1]]] }
                  | scoped_name_0 "::" identifier
                      { val[0][1] << val[2]; val[0] }
 
@@ -396,8 +393,8 @@ rule
 
   value_name : scoped_name
 
-  value_element : export 
-                | state_member ";" 
+  value_element : export
+                | state_member ";"
                 | init_dcl ";"
 
   state_member : "public"  type_spec declarators
@@ -460,7 +457,7 @@ rule
   const_exp : or_expr
 
   or_expr : xor_expr
-	  | or_expr "|" xor_expr
+    | or_expr "|" xor_expr
               { Expression::Operation::Or.new(val[0], val[2]) }
 
   xor_expr : and_expr
@@ -512,8 +509,8 @@ rule
           | floating_pt_literal    { @d.parse_literal(:float,   val[0]) }
           | boolean_literal        { @d.parse_literal(:boolean, val[0]) }
 
-  boolean_literal : "TRUE"  { TRUE }
-                  | "FALSE" { FALSE }
+  boolean_literal : "TRUE"  { true }
+                  | "FALSE" { false }
 
   positive_int_const : const_exp { @d.parse_positive_int(val[0]) }
 
@@ -525,7 +522,7 @@ rule
            | enum_type
            | "native" native_declarator
 
-  type_declarator : type_spec declarators 
+  type_declarator : type_spec declarators
                     {
                       dcls = parse_type_declarator(val[0], val[1])
                       dcls.each do |d|
@@ -624,7 +621,7 @@ rule
   member_list : member
               | member_list member
 
-  member : type_spec declarators ";" 
+  member : type_spec declarators ";"
            {
              dcls = parse_type_declarator(val[0], val[1])
              dcls.each do |d|
@@ -659,10 +656,10 @@ rule
              | union_body union_case
 
   union_case : _case_label_1 element_spec ";"
-               { 
+               {
                  dcls = parse_type_declarator(val[1][0], [val[1][1]])
                  dcls.each do |d|
-                   @d.define_case(val[0], d[0], d[1]) 
+                   @d.define_case(val[0], d[0], d[1])
                  end
                }
 
@@ -684,7 +681,7 @@ rule
   _enumerator_list : enumerator
                    | _enumerator_list ","  enumerator
 
-  enumerator : identifier 
+  enumerator : identifier
                {
                  @d.declare_enumerator(val[0])
                }
@@ -746,7 +743,7 @@ rule
   attr_no_raises_expr : { [[], []] }
 
   attr_declarator_list : simple_declarator "," _simple_declarator_list
-                         { [val[0]].concat(val[2]) } 
+                         { [val[0]].concat(val[2]) }
 
   readonly_attr_declarator : simple_declarator raises_expr
                              {  [[val[0]], val[1]] }

data/lib/ridl/require.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/version'
 require 'ridl/scanner'

data/lib/ridl/ridl.rb

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

data/lib/ridl/runner.rb

@@ -8,23 +8,18 @@
 # included with this program.
 #
 # Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
 #--------------------------------------------------------------------
 require 'stringio'
 require 'ridl/optparse_ext'
 require 'ridl/genfile'
 require 'ridl/backend'
+require 'ridl/options'
 
 # -----------------------------------------------------------------------
 
 module IDL
 
-  # TODO : LEGACY solution for R2CORBA; to be removed when R2CORBA has been updated
-  #        See also IDL#init
-  @@embedded = false unless class_variable_defined?(:@@embedded)
-  @@be_name = nil unless class_variable_defined?(:@@be_name)
-
-  OPTIONS = {
+  OPTIONS = Options.new({
       :outputdir       => nil,
       :includepaths    => [],
       :xincludepaths   => [],
@@ -34,24 +29,73 @@ module IDL
       :search_incpath  => false,
       :backend         => nil,
       :macros          => {
-          :__RIDL__  => "#{RIDL_VERSION}",
-          :__RIDLBE__ => nil,
-          :__RIDLBE_VER__ => nil
       }
-  }
+  })
+  CORE_OPTIONS = OPTIONS.keys
 
   class Engine
+
+    class ProductionStack
+      def initialize
+        @stack = []
+        @index = {}
+      end
+
+      def size
+        @stack.size
+      end
+
+      def empty?
+        @stack.empty?
+      end
+
+      def push(id, prod)
+        @index[id.to_sym] = @stack.size
+        @stack << [id.to_sym, prod]
+      end
+
+      def pop
+        return nil if empty?
+        id, prod = @stack.shift
+        @index.delete(id)
+        prod
+      end
+
+      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
+      end
+
+      def has?(id)
+        @index.has_key?(id.to_sym)
+      end
+
+      def [](id)
+        @stack[@index[id.to_sym]].last
+      end
+    end
+
     def initialize(backend, options)
       @backend = backend ? Backend.load(backend) : Backend.null_be
       @initopts = options.merge({
         backend: @backend.name,
         macros: options[:macros].merge({
+           __RIDL__: "#{RIDL_VERSION}",
            __RIDLBE__: @backend.name.to_s,
            __RIDLBE_VER__: @backend.version
         })
       })
       @optparser = init_optparser
       @inputstack = []
+      @productionstack = ProductionStack.new
       @options = nil
     end
 
@@ -63,6 +107,8 @@ module IDL
       @options || @initopts
     end
 
+    # Input management
+
     def push_input(idlfile, opts)
       @inputstack << [idlfile, opts]
     end
@@ -79,6 +125,39 @@ module IDL
       !@inputstack.empty?
     end
 
+    # Production management
+
+    def push_production(id, producer)
+      raise "Producer #{id} already queued" if @productionstack.has?(id)
+      @productionstack.push(id, producer)
+    end
+
+    def pop_production
+      @productionstack.pop
+    end
+
+    def peek_production
+      @productionstack.peek
+    end
+
+    def remove_production(id)
+      @productionstack.remove(id)
+    end
+
+    def has_productions?
+      !@productionstack.empty?
+    end
+
+    def has_production?(id)
+      @productionstack.has?(id)
+    end
+
+    def production(id)
+      @productionstack[id]
+    end
+
+    # Verbosity control
+
     def verbose_level
       options[:verbose]
     end
@@ -92,6 +171,9 @@ module IDL
       # initialize options
       @options = @initopts.merge(runopts)
 
+      # mark current (clean) state
+      @options.mark
+
       # backup current engine (if any)
       cur_engine = Thread.current[:ridl_engine]
       # store currently running engine for current thread
@@ -103,7 +185,7 @@ module IDL
           @optparser.parse!(argv)
         rescue ArgumentError => ex
           IDL.error(ex.inspect)
-          IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level>0
+          IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level > 0
           return false
         end
 
@@ -118,8 +200,8 @@ module IDL
           options[:output] = o
 
           input_base = File.basename(argv.first)
-          if (input_base != argv.first)
-            options[:xincludepaths] << (File.dirname(argv.first)+'/')
+          if input_base != argv.first
+            options[:xincludepaths] << (File.dirname(argv.first) + '/')
           end
 
           return !parse("#include \"#{input_base}\"", options).nil?
@@ -137,23 +219,41 @@ module IDL
                    else
                      File.open(_idlfile, 'r')
                    end
-            raise RuntimeError, 'cannot read from STDOUT' if $stdout == _fio
+            raise 'cannot read from STDOUT' if $stdout == _fio
 
             # parse IDL source
-            IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN': (StringIO === _idlfile ? 'from string' : _idlfile)}")
+            IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN' : (StringIO === _idlfile ? 'from string' : _idlfile)}")
 
             unless _parser = parse(_fio, _opts)
               return false
             end
 
             # process parse result -> code generation
-            IDL.log(2, 'RIDL - starting code generation')
+            IDL.log(2, 'RIDL - processing input')
 
             GenFile.transaction  do
               begin
+
                 backend.process_input(_parser, _opts)
+
+                # handle productions
+                while has_productions?
+                  IDL.log(2, "RIDL - running production #{peek_production}")
+
+                  # get next-in-line producer
+                  producer = pop_production
+
+                  # execute the producer
+                  producer.run(_parser)
+                end
+
               rescue Backend::ProcessStop
-                IDL.log(2, "RIDL - processing #{IO === _idlfile ? 'from STDIN': (StringIO === _idlfile ? 'from string' : _idlfile)} stopped with \"#{$!.message}\"")
+                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
+                return false
               end
             end
           end
@@ -190,22 +290,28 @@ module IDL
         _opts = options.dup
 
         _opts[:idlfile] = _arg
-        if _opts[:search_incpath]
-          _fname = _arg
-          _fpath = if File.file?(_fname) && File.readable?(_fname)
-                     _fname
-                   else
-                     _fp = _opts[:includepaths].find do |_p|
-                       _f = _p + _fname
-                       File.file?(_f) && File.readable?(_f)
+        if _opts[:no_input]
+          # do not parse specified file (only used as template for output names)
+          # instead push an empty StringIO object
+          _arg = StringIO.new('')
+        else
+          if _opts[:search_incpath]
+            _fname = _arg
+            _fpath = if File.file?(_fname) && File.readable?(_fname)
+                       _fname
+                     else
+                       _fp = _opts[:includepaths].find do |_p|
+                         _f = _p + _fname
+                         File.file?(_f) && File.readable?(_f)
+                       end
+                       _opts[:outputdir] = _fp unless _fp.nil? || !_opts[:outputdir].nil?
+                       _fp += '/' + _fname unless _fp.nil?
+                       _fp
                      end
-                     _opts[:outputdir] = _fp unless _fp.nil? || !_opts[:outputdir].nil?
-                     _fp += '/' + _fname unless _fp.nil?
-                     _fp
-                   end
-          _arg = _fpath unless _fpath.nil?
+            _arg = _fpath unless _fpath.nil?
+          end
+          _opts[:xincludepaths] << (File.dirname(_arg) + '/')
         end
-        _opts[:xincludepaths] << (File.dirname(_arg)+'/')
 
         _opts[:outputdir] ||= '.'
 
@@ -223,44 +329,56 @@ module IDL
     def init_optparser
       script_name = File.basename($0, '.*')
       if not script_name =~ /ridlc/
-        script_name = 'ruby '+$0
+        script_name = 'ruby ' + $0
       end
 
       # set up option parser with common options
       opts = OptionParser.new
       opts.banner = "Usage: #{script_name} [:backend] [options] [<idlfile> [<idlfile> ...]]\n\n" +
-          "    backend\t\tSpecifies the IDL language mapping backend to use.\n"+
-          "           \t\tDefault = :null\n\n"+
+          "    backend\t\tSpecifies the IDL language mapping backend to use.\n" +
+          "           \t\tDefault = :null\n\n" +
           "    Active language mapping = :#{backend.name}"
-      opts.separator ""
-      opts.on("-I PATH", "--include=PATH", String,
-              "Adds include searchpath.",
-              "Default: none") { |v| @options[:includepaths] << (v.end_with?('\\','/') ? v : v+'/') }
+      opts.separator ''
+      opts.on('-I PATH', '--include=PATH', String,
+              'Adds include searchpath.',
+              'Default: none') { |v|
+        self.options[:includepaths] << (v.end_with?('\\', '/') ? v : v + '/')
+      }
       opts.on('-Dmacro=[value]', String, 'defines preprocessor macro') { |v|
         name, value = v.split('=')
-        @options[:macros][name] = (value ? value : true)
+        self.options[:macros][name] = (value ? value : true)
+      }
+      opts.on('-n NAMESPACE', '--namespace=NAMESPACE', String,
+              'Defines rootlevel enclosing namespace.',
+              'Default: nil') { |v|
+        self.options[:namespace] = v
+      }
+      opts.on('-v', '--verbose',
+              'Set verbosity level. Repeat to increment.',
+              'Default: 0') { |_|
+        self.options[:verbose] += 1
       }
-      opts.on("-n NAMESPACE", "--namespace=NAMESPACE", String,
-              "Defines rootlevel enclosing namespace.",
-              "Default: nil") { |v| @options[:namespace]=v }
-      opts.on("-v", "--verbose",
-              "Set verbosity level. Repeat to increment.",
-              "Default: 0") { |v| @options[:verbose] += 1 }
-      opts.on("--debug",
-              "Set parser debug mode. Don't do this at home!",
-              "Default: off") { |v| @options[:debug] = true }
-      opts.on('--stdidl',
-              'Adds include path to standard IDL files provided with RIDL.',
-              'Default: not set') { |v|
-        @options[:includepaths] << (File.expand_path(File.join(File.dirname(__FILE__), '..', 'idl'))+'/')
+      opts.on('--debug',
+              'Set parser debug mode. Do NOT do this at home!',
+              'Default: off') { |_|
+        self.options[:debug] = true
+      }
+      opts.on('--search-includepath',
+              'Use include paths to find main IDL source.',
+              'Default: off') { |_|
+        self.options[:search_incpath] = true
+      }
+      opts.on('--no-input',
+               'Do not parse specified file(s) as input IDL.',
+               'Default: off') { |_|
+        self.options[:no_input] = true
       }
-      opts.on("--search-includepath",
-              "Use include paths to find main IDL source.",
-              "Default: off") { |v| @options[:search_incpath]=v }
       if @initopts[:preprocess]
-        opts.on("--output=FILE", String,
-                "Specifies filename to generate output in.",
-                "Default: basename(idlfile)-'.idl'+<postfix>+<ext>") { |v| @options[:output]=v }
+        opts.on('--output=FILE', String,
+                'Specifies filename to generate output in.',
+                'Default: basename(idlfile)-\'.idl\'+<postfix>+<ext>') { |v|
+          self.options[:output] = v
+        }
       end
 
       # setup language mapping specific options
@@ -270,7 +388,7 @@ module IDL
 
       opts.on('-V', '--version',
               'Show version information and exit.') {
-        puts "RIDL compiler #{@options[:macros][:__RIDL__]}"
+        puts "RIDL compiler #{RIDL_VERSION}"
         puts RIDL_COPYRIGHT
         puts '---'
         @backend.print_version
@@ -287,24 +405,57 @@ module IDL
 
   end
 
+  def IDL.engine?
+    !Thread.current[:ridl_engine].nil?
+  end
+
   def IDL.backend
     Thread.current[:ridl_engine] ? Thread.current[:ridl_engine].backend : nil
   end
 
   def IDL.push_input(idlfile, opts)
-    Thread.current[:ridl_engine].push_input(idlfile, opts) if Thread.current[:ridl_engine]
+    Thread.current[:ridl_engine].push_input(idlfile, opts) if engine?
   end
 
   def IDL.pop_input
-    Thread.current[:ridl_engine].pop_input if Thread.current[:ridl_engine]
+    return nil unless engine?
+    Thread.current[:ridl_engine].pop_input
   end
 
   def IDL.peek_input
-    Thread.current[:ridl_engine].peek_input if Thread.current[:ridl_engine]
+    return nil unless engine?
+    Thread.current[:ridl_engine].peek_input
   end
 
   def IDL.has_input?
-    Thread.current[:ridl_engine].has_input? if Thread.current[:ridl_engine]
+    engine? && Thread.current[:ridl_engine].has_input?
+  end
+
+  def IDL.push_production(id, producer)
+    Thread.current[:ridl_engine].push_production(id, producer) if engine?
+  end
+
+  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
+
+  def IDL.has_productions?
+    engine? && Thread.current[:ridl_engine].has_productions?
+  end
+
+  def IDL.has_production?(id)
+    engine? && Thread.current[:ridl_engine].has_production?(id)
+  end
+
+  def IDL.production(id)
+    return nil unless engine?
+    Thread.current[:ridl_engine].production(id)
   end
 
   def IDL.verbose_level
@@ -327,32 +478,45 @@ module IDL
     STDERR.puts(message)
   end
 
+  def IDL.fatal(message)
+    STDERR.puts(message, 'Exiting.')
+    exit 1
+  end
+
   def IDL.init(argv = ARGV)
     options = OPTIONS.dup
 
-    unless @@embedded
-      # check commandline args for explicit language mapping backend
-      if argv.first =~ /^:\S+/
-        @@be_name = argv.shift.reverse.chop.reverse.to_sym
-      elsif ENV['RIDL_BE_SELECT']   # or from environment
-        @@be_name = ENV['RIDL_BE_SELECT'].to_sym
-      end
+    # load config file(s) if any
+    Options.load_config(options)
 
-      # add optional search paths for RIDL backends
-      $:.concat(ENV['RIDL_BE_PATH'].split(/:|;/)) if ENV['RIDL_BE_PATH']
+    IDL.log(2, "Configuration [#{options}]")
 
-      # check for special bootstrapping switches
-      if argv.first == '--preprocess'
-        options[:preprocess] = true
-        argv.shift
-      elsif argv.first == '--ignore-pidl'
-        options[:ignore_pidl] = true
-        argv.shift
-      end
+    # check commandline args for explicit language mapping backend
+    if argv.first =~ /^:\S+/
+      be_name = argv.shift.reverse.chop.reverse.to_sym
+    elsif ENV['RIDL_BE_SELECT']   # or from environment
+      be_name = ENV['RIDL_BE_SELECT'].to_sym
+    elsif options[:backend]       # or from configuration
+      be_name = options[:backend].to_sym
+    end
+
+    # 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
+    $:.concat(options[:be_path]) unless options[:be_path].empty?
+
+    # check for special bootstrapping switches
+    if argv.first == '--preprocess'
+      options[:preprocess] = true
+      argv.shift
+    elsif argv.first == '--ignore-pidl'
+      options[:ignore_pidl] = true
+      argv.shift
     end
 
     # create RIDL engine
-    Thread.current[:ridl_engine] = Engine.new(@@be_name, options)
+    Thread.current[:ridl_engine] = Engine.new(be_name, options)
   end
 
   # main run method