ridl 2.2.5 → 2.5.5

data/lib/ridl/genfile.rb

@@ -17,28 +17,52 @@ module IDL
 
   class GenFile
 
-    @@stack = []
-    @@cur_trans = nil
+    self.singleton_class.class_eval do
+      private
 
+      def _stack
+        @stack ||= []
+      end
+
+      def _start_transaction
+        _stack << (@transaction = [])
+      end
+
+      def _close_transaction
+        _stack.pop
+        @transaction = _stack.last
+      end
+
+      def _transaction
+        @transaction
+      end
+
+      def _commit
+        _transaction.reject! { |fgen| fgen.save; true }
+      end
+
+      def _rollback
+        _transaction.reject! { |fgen| fgen.remove; true } if _transaction
+      end
+
+      def _push(fgen)
+        _transaction << fgen if _transaction
+      end
+
+    end
     def self.transaction(&block)
-      @@cur_trans = []
-      @@stack << @@cur_trans
+      _start_transaction
       begin
         block.call if block_given?
-        @@cur_trans.each {|fgen| fgen.save }
-        @@cur_trans.clear
+        _commit
       ensure
-        self.rollback # after successful transaction should be nothing left
-        @@stack.pop
-        @@cur_trans = @@stack.last
+        _rollback # after successful transaction should be nothing left
+        _close_transaction
       end
     end
 
     def self.rollback
-      if @@cur_trans
-        @@cur_trans.each {|fgen| fgen.remove }
-        @@cur_trans.clear
-      end
+      _rollback
     end
 
     class Content
@@ -82,8 +106,9 @@ module IDL
         :regen_marker_prefix => '//',
         :regen_marker_postfix => nil,
         :regen_marker => REGEN_MARKER_DEFAULT,
-        :regen_keep_header => false,
-        :output_file => nil
+        :regen_keep_header => true,
+        :output_file => nil,
+        :create_missing_dir => false
       }.merge(opts)
       if @options[:regenerate] && File.exists?(@fullpath)
         parse_regeneration_content
@@ -91,7 +116,7 @@ module IDL
         @content = Content.new
       end
       @fout = @options[:output_file] || Tempfile.new(@name)
-      @@cur_trans << self
+      self.class.__send__(:_push, self)
     end
 
     def <<(txt)
@@ -111,11 +136,14 @@ module IDL
       "#{@options[:regen_marker_prefix]}#{@options[:regen_marker]} - HEADER_END : #{sectionid}#{@options[:regen_marker_postfix]}"
     end
 
-    def write_regen_section(sectionid, default_content, indent = '', options = {})
+    def write_regen_section(sectionid, options = {})
+      indent = options[:indent] || ''
       self << indent << regen_start_marker(sectionid) << "\n" unless options[:header]
       if content.has_section?(sectionid)
         self << content[sectionid].join unless content[sectionid].empty?
-      else
+      elsif block_given?
+        yield # block should yield default content
+      elsif default_content = options[:default_content]
         default_content = (Array === default_content) ? default_content : default_content.to_s.split("\n")
         self << (default_content.collect {|l| (s = indent.dup) << l << "\n"; s }.join) unless default_content.empty?
       end
@@ -141,22 +169,29 @@ module IDL
           # replace original
           begin
             # rename newly generated file
-            FileUtils::mv(fgen.path, @fullpath)
+            FileUtils.mv(fgen.path, @fullpath)
             # preserve file mode
-            FileUtils::chmod(File.lstat(ftmp_name).mode, @fullpath)
+            FileUtils.chmod(File.lstat(ftmp_name).mode, @fullpath)
           rescue
             IDL.log(0, %Q{ERROR: FAILED updating #{@path}: #{$!}})
             # restore backup
-            FileUtils::mv(ftmp_name, @fullpath)
+            FileUtils.mv(ftmp_name, @fullpath)
             raise
           end
           # remove backup
           File.unlink(ftmp_name)
         else
+          unless File.directory?(File.dirname(@fullpath))
+            unless @options[:create_missing_dir]
+              IDL.log(0, %Q{ERROR: Cannot access output folder #{File.dirname(@fullpath)}})
+              exit(1)
+            end
+            FileUtils.mkdir_p(File.dirname(@fullpath))
+          end
           # just rename newly generated file
-          FileUtils::mv(fgen.path, @fullpath)
+          FileUtils.mv(fgen.path, @fullpath)
           # set default mode for new files
-          FileUtils::chmod(0666 - File.umask, @fullpath)
+          FileUtils.chmod(0666 - File.umask, @fullpath)
         end
       end
     end

data/lib/ridl/node.rb

@@ -115,6 +115,10 @@ module IDL::AST
       @annotations = Annotations.new
     end
 
+    def unescaped_name
+      @name.unescaped_name
+    end
+
     def parsed_name_scope
       (@enclosure ? @enclosure.parsed_name_scope : '') + '::' + @name
     end
@@ -128,7 +132,7 @@ module IDL::AST
     end
 
     def scoped_lm_name
-      @scoped_lm_name ||= @scopes.collect{|s| s.lm_name_for_scope }.join("::").freeze
+      @scoped_lm_name ||= @scopes.collect{|s| s.lm_name_for_scope }.join('::').freeze
     end
 
     def marshal_dump
@@ -314,11 +318,15 @@ module IDL::AST
     end
 
     def walk_members(&block)
-      @children.each { |c| yield(c) }
+      @children.each(&block)
     end
 
     def match_members(&block)
-      !(@children.find { |c| yield(c) }).nil?
+      !(@children.find(&block)).nil?
+    end
+
+    def select_members(&block)
+      @children.select(&block)
     end
 
     def replace_prefix(pfx)
@@ -403,12 +411,14 @@ module IDL::AST
       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
     ]
-    attr_reader :anchor, :next
+    attr_reader :anchor, :next, :template, :template_params
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure)
       @anchor = params[:anchor]
       @prefix = params[:prefix] || @prefix
       @not_in_repo_id = params[:not_in_repo_id]
+      @template = params[:template]
+      @template_params = (params[:template_params] || []).dup
       @next = nil
     end
 
@@ -416,6 +426,23 @@ module IDL::AST
       !@anchor.nil?
     end
 
+    def is_templated?
+      @template ? true : false
+    end
+
+    def template_param(param)
+      return nil unless @template
+      param = param.to_s if ::Symbol === param
+      if ::String === param
+        @template.params.each_with_index do |tp, ix|
+          return @template_params[ix] if tp.name == param
+        end
+        nil
+      else
+        @template_params[param] rescue nil
+      end
+    end
+
     def annotations
       (has_anchor? ? self.anchor : self).get_annotations
     end
@@ -452,9 +479,9 @@ module IDL::AST
       when IDL::AST::Module
         # Module reopening
         _anchor = node.has_anchor? ? node.anchor : node
-        _anchor.annotations.concat(params[:annotations])
+        _anchor.annotations.concat(params.delete(:annotations))
         _last = _anchor.find_last
-        _params = { :anchor => _anchor, :prefix => node.prefix }
+        _params = params.merge({ :anchor => _anchor, :prefix => node.prefix })
         _next = IDL::AST::Module.new(node.name, self, _params)
         _last.set_next(_next)
         @children << _next
@@ -685,12 +712,16 @@ module IDL::AST
       true
     end
 
-    def instantiate(_module_instance, _concrete_params, _context = {})
+    def params
+      @template_params
+    end
+
+    def instantiate(_module_instance, _context = {})
       # process concrete parameters
       @template_params.each_with_index do |_tp, _ix|
         raise RuntimeError,
-              "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _concrete_params.size
-        _cp = _concrete_params[_ix]
+              "missing template parameter for #{typename} #{scoped_lm_name}: #{_tp.name}" unless _ix < _module_instance.template_params.size
+        _cp = _module_instance.template_params[_ix]
         if _cp.is_a?(IDL::Type)
           raise RuntimeError, "anonymous type definitions are not allowed!" if _cp.is_anonymous?
           # parameter should be a matching IDL::Type
@@ -772,13 +803,13 @@ module IDL::AST
     end
 
     def instantiate(_context, _enclosure)
-      mod_inst = IDL::AST::Module.new(self.name, _enclosure, {})
       inst_params = @params.collect do |tp|
         # concrete objects are either Expression or Node; latter needs to be repacked as IDL::Type::ScopedName
         # as that is what the TemplateModule#instantiate expects
         tp.concrete.is_a?(IDL::Expression) ? tp.concrete : IDL::Type::ScopedName.new(tp.concrete)
       end
-      @template.instantiate(mod_inst, inst_params, _context)
+      mod_inst = IDL::AST::Module.new(self.name, _enclosure, { :template => @template, :template_params => inst_params })
+      @template.instantiate(mod_inst, _context)
       mod_inst
     end
 
@@ -788,10 +819,11 @@ module IDL::AST
   end # TemplateModuleReference
 
   class Include < Module
-    attr_reader :filename
+    attr_reader :filename, :fullpath
     def initialize(_name, _enclosure, params)
       super(_name, _enclosure, params)
       @filename = params[:filename]
+      @fullpath = params[:fullpath]
       @defined = params[:defined] || false
       @preprocessed = params[:preprocessed] || false
       #overrule

data/lib/ridl/optparse_ext.rb

@@ -341,14 +341,14 @@ module IDL
       @options.delete(switch)
     end
 
-    def to_option_parser(optp, idl_options)
+    def to_option_parser(optp, option_holder)
       @options.each do |sw, op|
         (arg_list = [sw]) << op.type
         arg_list.concat(op.description(optp.summary_indent))
         optp.on(*arg_list) do |v|
-          op.run(v, idl_options)
+          op.run(v, option_holder.options)
         end
-        optp.separator "" if op.separator
+        optp.separator '' if op.separator
       end
     end
 

data/lib/ridl/parser.rb

@@ -499,7 +499,7 @@ def parse(src)
   rescue IDL::ParseError
     raise
   rescue
-    STDERR.puts "#{$!}\n#{$!.backtrace.join("\n")}" if $VERBOSE
+    STDERR.puts "#{$!}\n#{$!.backtrace.join("\n")}" if IDL.verbose_level>0
     raise IDL::ParseError.new($!.message, @scanner.positions)
   end
   @d.post_parse
@@ -529,8 +529,8 @@ def is_included?(s)
   @d.is_included?(s)
 end
 
-def enter_include(s)
-  @d.enter_include(s)
+def enter_include(s, fp)
+  @d.enter_include(s, fp)
 end
 
 def leave_include()
@@ -541,8 +541,8 @@ def declare_include(s)
   @d.declare_include(s)
 end
 
-def define_annotation(annid, annbody)
-  @d.define_annotation(annid, annbody)
+def define_annotation(*args)
+  @d.define_annotation(*args)
 end
 
 def next_token

data/lib/ridl/parser.ry

@@ -873,7 +873,7 @@ def parse(src)
   rescue IDL::ParseError
     raise
   rescue
-    STDERR.puts "#{$!}\n#{$!.backtrace.join("\n")}" if $VERBOSE
+    STDERR.puts "#{$!}\n#{$!.backtrace.join("\n")}" if IDL.verbose_level>0
     raise IDL::ParseError.new($!.message, @scanner.positions)
   end
   @d.post_parse
@@ -903,8 +903,8 @@ def is_included?(s)
   @d.is_included?(s)
 end
 
-def enter_include(s)
-  @d.enter_include(s)
+def enter_include(s, fp)
+  @d.enter_include(s, fp)
 end
 
 def leave_include()
@@ -915,8 +915,8 @@ def declare_include(s)
   @d.declare_include(s)
 end
 
-def define_annotation(annid, annbody)
-  @d.define_annotation(annid, annbody)
+def define_annotation(*args)
+  @d.define_annotation(*args)
 end
 
 def next_token

data/lib/ridl/runner.rb

@@ -17,219 +17,195 @@ require 'ridl/backend'
 
 # -----------------------------------------------------------------------
 
-$VERBOSE = $VERBOSE || ENV['RIDL_VERBOSE']
-
 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)
-  @@preprocessing = false
-  @@no_pidl = false
-  @@idlstack = []
-  @@backend = nil
-  @@verbose_level = 0
 
   OPTIONS = {
       :outputdir       => nil,
       :includepaths    => [],
-      :verbose         => 0,
+      :xincludepaths   => [],
+      :verbose         => (ENV['RIDL_VERBOSE'] || 0).to_i,
       :debug           => false,
       :namespace       => nil,
       :search_incpath  => false,
       :backend         => nil,
       :macros          => {
-        :__RIDL__  => "#{RIDL_VERSION}",
-        :__RIDLBE__ => nil,
-        :__RIDLBE_VER__ => nil
+          :__RIDL__  => "#{RIDL_VERSION}",
+          :__RIDLBE__ => nil,
+          :__RIDLBE_VER__ => nil
       }
   }
 
-  def IDL.preprocessing?
-    @@preprocessing
-  end
-
-  def IDL.no_pidl?
-    @@no_pidl
-  end
+  class Engine
+    def initialize(backend, options)
+      @backend = backend ? Backend.load(backend) : Backend.null_be
+      @initopts = options.merge({
+        backend: @backend.name,
+        macros: options[:macros].merge({
+           __RIDLBE__: @backend.name.to_s,
+           __RIDLBE_VER__: @backend.version
+        })
+      })
+      @optparser = init_optparser
+      @inputstack = []
+      @options = nil
+    end
 
-  def IDL.backend
-    @@backend
-  end
+    def backend
+      @backend
+    end
 
-  def IDL.init
-    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
+    def options
+      @options || @initopts
+    end
 
-      # add optional search paths for RIDL backends
-      $:.concat(ENV['RIDL_BE_PATH'].split(/:|;/)) if ENV['RIDL_BE_PATH']
+    def push_input(idlfile, opts)
+      @inputstack << [idlfile, opts]
+    end
 
-      # check for special bootstrapping switches
-      if ARGV.first == '--preprocess'
-        @@preprocessing = true
-        ARGV.shift
-      elsif ARGV.first == '--ignore-pidl'
-        @@no_pidl = true
-        ARGV.shift
-      end
+    def pop_input
+      @inputstack.shift
     end
-    # try to load the active laguage mapping backend
-    @@backend = @@be_name ? Backend.load(@@be_name) : Backend.null_be
-    # finalize base options
-    OPTIONS[:preprocess] = preprocessing?
-    OPTIONS[:ignore_pidl] = no_pidl?
-    OPTIONS[:backend] = @@backend
-    OPTIONS[:__RIDLBE__] = @@backend.name.to_s
-    OPTIONS[:__RIDLBE_VER__] = @@backend.version
-  end
 
-  # parse commandline arguments
-  #
-  def IDL.parse_args
-    script_name = File.basename($0, '.*')
-    if not script_name =~ /ridlc/
-      script_name = "ruby "+$0
+    def peek_input
+      @inputstack.first
     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"+
-                  "    Active language mapping = :#{IDL.backend.name}"
-    opts.separator ""
-    opts.on("-I PATH", "--include=PATH", String,
-            "Adds include searchpath.",
-            "Default: nil") { |v| OPTIONS[:includepaths] << v }
-    opts.on('-Dmacro=[value]', String, 'defines preprocessor macro') { |v|
-              name, value = v.split('=')
-              OPTIONS[:macros][name] = (value ? value : true)
-            }
-    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("--search-includepath",
-            "Use include paths to find main IDL source.",
-            "Default: off") { |v| OPTIONS[:search_incpath]=v }
-    if preprocessing?
-      opts.on("--output=FILE", String,
-              "Specifies filename to generate output in.",
-              "Default: File.basename(idlfile, '.idl')+<postfix>+<ext>") { |v| OPTIONS[:output]=v }
+    def has_input?
+      !@inputstack.empty?
     end
 
-    # setup language mapping specific options
-    be_options = OptionList.new
-    @@backend.setup_be(be_options, OPTIONS)
-    be_options.to_option_parser(opts, OPTIONS)
+    def verbose_level
+      options[:verbose]
+    end
 
-    opts.on('-V', "--version",
-            "Show version information and exit.") {
-                puts "RIDL compiler #{OPTIONS[:macros][:__RIDL__]}"
-                puts RIDL_COPYRIGHT
-                puts '---'
-                @@backend.print_version
-                exit
-            }
+    def verbose_level=(l)
+      options[:verbose] = l
+    end
 
-    opts.separator ""
+    def run(argv, runopts = {})
 
-    opts.on("-h", "--help",
-            "Show this help message.") { puts opts; puts; exit }
+      # initialize options
+      @options = @initopts.merge(runopts)
 
-    opts.parse!(ARGV)
-  end
+      # backup current engine (if any)
+      cur_engine = Thread.current[:ridl_engine]
+      # store currently running engine for current thread
+      Thread.current[:ridl_engine] = self
 
-  def IDL.push_input(idlfile, opts)
-    @@idlstack << [idlfile, opts]
-  end
+      begin
+        # parse arguments
+        begin
+          @optparser.parse!(argv)
+        rescue ArgumentError => ex
+          IDL.error(ex.inspect)
+          IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level>0
+          return false
+        end
 
-  def IDL.pop_input
-    @@idlstack.shift
-  end
+        if options[:preprocess]
 
-  def IDL.peek_input
-    @@idlstack.first
-  end
+          ## PREPROCESSING
+          o = if options[:output].nil?
+                $stdout
+              else
+                File.open(options[:output], 'w+')
+              end
+          options[:output] = o
 
-  def IDL.has_input?
-    !@@idlstack.empty?
-  end
+          input_base = File.basename(argv.first)
+          if (input_base != argv.first)
+            options[:xincludepaths] << File.dirname(argv.first)
+          end
 
-  # main run method
-  #
-  def IDL.run
-    # parse arguments
-    begin
-      parse_args
-    rescue ArgumentError => ex
-      IDL.error(ex.inspect)
-      IDL.error(ex.backtrace.join("\n")) if $VERBOSE
-      exit 1
-    end
+          return !parse("#include \"#{input_base}\"", options).nil?
+        else
+          ## collect input files from commandline
+          collect_input(argv)
+
+          ## CODE GENERATION
+          while has_input?
+            # get input from stack
+            _idlfile, _opts = pop_input
+
+            _fio = if IO === _idlfile || StringIO === _idlfile
+                     _idlfile
+                   else
+                     File.open(_idlfile, 'r')
+                   end
+            raise RuntimeError, 'cannot read from STDOUT' if $stdout == _fio
+
+            # parse IDL source
+            IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN': (StringIO === _idlfile ? 'from string' : _idlfile)}")
+
+            unless _parser = parse(_fio, _opts)
+              return false
+            end
 
-    verbose_level = OPTIONS[:verbose]
+            # process parse result -> code generation
+            IDL.log(2, 'RIDL - starting code generation')
 
-    if preprocessing?
-      ## PREPROCESSING
-      o = if OPTIONS[:output].nil?
-          $stdout
-        else
-          File.open(OPTIONS[:output], "w+")
+            GenFile.transaction  do
+              begin
+                backend.process_input(_parser, _opts)
+              rescue Backend::ProcessStop
+                IDL.log(2, "RIDL - processing #{IO === _idlfile ? 'from STDIN': (StringIO === _idlfile ? 'from string' : _idlfile)} stopped with \"#{$!.message}\"")
+              end
+            end
+          end
         end
-      OPTIONS[:output] = o
+      ensure
+        # restore previous state
+        Thread.current[:ridl_engine] = cur_engine
+      end
+      true
+    end
 
-      parser = ::IDL::Parser.new(OPTIONS)
-      parser.yydebug = OPTIONS[:debug]
+    def parse(io, opts)
+      # parse IDL source
+      _parser = ::IDL::Parser.new(opts)
+      _parser.yydebug = opts[:debug]
 
       begin
-        input_base = File.basename(ARGV.first)
-        if (input_base != ARGV.first)
-          OPTIONS[:includepaths] << File.dirname(ARGV.first)
-        end
-        parser.parse("#include \"#{input_base}\"")
+        _parser.parse(io)
       rescue => ex
         IDL.error(ex.inspect)
         IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+        return nil
       ensure
-        o.close
+        io.close unless String === io || io == $stdin
       end
-    else
+      _parser
+    end
+
+    private
+
+    def collect_input(argv)
       ## collect input files from commandline
-      ARGV.each do |_arg|
-        _opts = OPTIONS.dup
+      argv.each do |_arg|
+        _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)
-            end
-            _opts[:outputdir] = _fp unless _fp.nil? || !_opts[:outputdir].nil?
-            _fp += '/' + _fname unless _fp.nil?
-            _fp
-          end
+                     _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
           _arg = _fpath unless _fpath.nil?
         end
-        _opts[:includepaths] << File.dirname(_arg)
+        _opts[:xincludepaths] << File.dirname(_arg)
 
         _opts[:outputdir] ||= '.'
 
@@ -238,59 +214,109 @@ module IDL
 
       ## if no IDL input file specified read from STDIN
       unless has_input?
-        _opts = OPTIONS.dup
+        _opts = options.dup
         _opts[:outputdir] ||= '.'
         push_input($stdin, _opts)
       end
+    end
 
-      ## CODE GENERATION
-      while has_input?
-        # get input from stack
-        _idlfile, _opts = pop_input
-
-        _fio = if IO === _idlfile || StringIO === _idlfile
-            _idlfile
-          else
-            File.open(_idlfile, "r")
-          end
-        raise RuntimeError, 'cannot read from STDOUT' if $stdout == _fio
+    def init_optparser
+      script_name = File.basename($0, '.*')
+      if not script_name =~ /ridlc/
+        script_name = 'ruby '+$0
+      end
 
-        # parse IDL source
-        IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN': _idlfile}")
+      # 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"+
+          "    Active language mapping = :#{backend.name}"
+      opts.separator ""
+      opts.on("-I PATH", "--include=PATH", String,
+              "Adds include searchpath.",
+              "Default: nil") { |v| @options[:includepaths] << v }
+      opts.on('-Dmacro=[value]', String, 'defines preprocessor macro') { |v|
+        name, value = v.split('=')
+        @options[:macros][name] = (value ? value : true)
+      }
+      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("--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 }
+      end
 
-        _parser = ::IDL::Parser.new(_opts)
-        _parser.yydebug = _opts[:debug]
+      # setup language mapping specific options
+      be_options = OptionList.new
+      @backend.setup_be(be_options, @initopts)
+      be_options.to_option_parser(opts, self)
+
+      opts.on('-V', '--version',
+              'Show version information and exit.') {
+        puts "RIDL compiler #{@options[:macros][:__RIDL__]}"
+        puts RIDL_COPYRIGHT
+        puts '---'
+        @backend.print_version
+        exit
+      }
 
-        begin
-          _parser.parse(_fio)
-        rescue => ex
-          IDL.error(ex.inspect)
-          IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
-          exit 1
-        ensure
-          _fio.close unless _fio == $stdin
-        end
+      opts.separator ""
 
-        # process parse result -> code generation
-        IDL.log(2, 'RIDL - starting code generation')
+      opts.on('-h', '--help',
+              'Show this help message.') { puts opts; puts; exit }
 
-        GenFile.transaction  do
-          begin
-            @@backend.process_input(_parser, _opts)
-          rescue Backend::ProcessStop
-            IDL.log(2, "RIDL - processing #{IO === _idlfile ? 'from STDIN': _idlfile} stopped from #{$!.message}")
-          end
-        end
-      end
+      opts
     end
-  end # IDL.run
+
+  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]
+  end
+
+  def IDL.pop_input
+    Thread.current[:ridl_engine].pop_input if Thread.current[:ridl_engine]
+  end
+
+  def IDL.peek_input
+    Thread.current[:ridl_engine].peek_input if Thread.current[:ridl_engine]
+  end
+
+  def IDL.has_input?
+    Thread.current[:ridl_engine].has_input? if Thread.current[:ridl_engine]
+  end
 
   def IDL.verbose_level
-    @@verbose_level
+    Thread.current[:ridl_engine] ? Thread.current[:ridl_engine].verbose_level : OPTIONS[:verbose]
   end
 
   def IDL.verbose_level=(l)
-    @@verbose_level = l
+    if Thread.current[:ridl_engine]
+      Thread.current[:ridl_engine].verbose_level = l.to_i
+    else
+      OPTIONS[:verbose] = l.to_i
+    end
   end
 
   def IDL.log(level, message)
@@ -301,4 +327,41 @@ module IDL
     STDERR.puts(message)
   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
+
+      # add optional search paths for RIDL backends
+      $:.concat(ENV['RIDL_BE_PATH'].split(/:|;/)) if ENV['RIDL_BE_PATH']
+
+      # 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
+    end
+
+    # create RIDL engine
+    Thread.current[:ridl_engine] = Engine.new(@@be_name, options)
+  end
+
+  # main run method
+  #
+  def IDL.run(argv = ARGV)
+    # run default engine if available
+    if Thread.current[:ridl_engine]
+      exit(1) unless Thread.current[:ridl_engine].run(argv)
+    end
+  end # IDL.run
+
 end