r2corba 1.4.1-x86-mingw32 → 1.5.1-x86-mingw32

data/lib/corba/svcs/ins/naming_service.rb

@@ -1,119 +1,119 @@
-#--------------------------------------------------------------------
-# naming_service.rb - Implementation of Naming Service
-#
-# Author: Martin Corino
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the R2CORBA LICENSE which is
-# included with this program.
-#
-# Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
-#--------------------------------------------------------------------
-
-require 'corba'
-require 'corba/svcs/ins/cos_naming'
-
-module R2CORBA
-  module INS
-    class Service
-      # default options
-      OPTIONS = {
-        :iorfile => 'ins.ior',
-        :debug => 0,
-        :threads => 5,
-        :orbprop => {},
-        :port => 0
-      }
-
-      def initialize(options = {})
-        @options = OPTIONS.merge(options)
-        raise RuntimeError, 'nr. of threads must >= 1' if @options[:threads] < 1
-      end
-
-      def setup
-        # process options
-        #
-        if defined?(JRUBY_VERSION)
-          @options[:orbprop]['jacorb.poa.thread_pool_min'] = @options[:threads]
-          @options[:orbprop]['jacorb.poa.thread_pool_max'] = @options[:threads]*4
-          if @options[:debug] > 0
-            @options[:orbprop]['jacorb.log.default.verbosity'] = case
-            when @options[:debug] < 2
-              1
-            when (2...4) === @options[:debug]
-              2
-            when (5...7) === @options[:debug]
-              3
-            when @options[:debug] > 7
-              4
-            end
-          end
-          if @options[:port] > 0
-            @options[:orbprop]['OAPort'] = @options[:port]
-          end
-        else
-          if @options[:debug] > 0
-            @options[:orbprop]['-ORBDebugLevel'] = @options[:debug]
-          end
-          if @options[:port] > 0
-            @options[:orbprop]['-ORBListenEndpoints'] = "iiop://:#{@options[:port]}"
-          end
-        end
-
-        # initialize ORB and POA.
-        #
-        @orb = CORBA.ORB_init('INS_ORB', @options[:orbprop])
-
-        obj = @orb.resolve_initial_references('RootPOA')
-
-        root_poa = PortableServer::POA._narrow(obj)
-
-        poa_man = root_poa.the_POAManager
-
-        poa_man.activate
-
-        # create and activate root Naming context
-        #
-        @naming_srv = INS::NamingContext.new(@orb)
-
-        naming_obj = @naming_srv._this()
-
-        naming_ior = @orb.object_to_string(naming_obj)
-
-        # simplify Corbaloc urls (corbaloc:iiop:[host][:port]/NamingService)
-        #
-        @orb.ior_map.map_ior('NamingService', naming_ior)
-
-        # save INS IOR to file
-        #
-        open(@options[:iorfile], 'w') { |io|
-          io.write naming_ior
-        }
-      end
-
-      def run
-        STDERR.puts "INS - starting service run" if @options[:verbose]
-        if (defined?(JRUBY_VERSION) or !R2CORBA::TAO::RUBY_THREAD_SUPPORT)
-          STDERR.puts "INS - running ORB" if @options[:verbose]
-          @orb.run
-        else
-          STDERR.puts "INS - starting #{@options[:threads]} ORB threads" if @options[:verbose]
-          @threads = []
-          @options[:threads].times do
-            @threads << Thread.new(@orb) { |orb| orb.run }
-          end
-          STDERR.puts "INS - joining ORB threads" if @options[:verbose]
-          @threads.each { |t| t.join }
-        end
-        STDERR.puts "INS - service run ended" if @options[:verbose]
-      end
-
-      def shutdown
-        STDERR.puts "INS - shutting down ORB" if @options[:verbose]
-        @orb.shutdown if @orb
-        STDERR.puts "INS - shutdown finished" if @options[:verbose]
-      end
-    end
-  end
-end
+#--------------------------------------------------------------------
+# naming_service.rb - Implementation of Naming Service
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+require 'corba'
+require 'corba/svcs/ins/cos_naming'
+
+module R2CORBA
+  module INS
+    class Service
+      # default options
+      OPTIONS = {
+        :iorfile => 'ins.ior',
+        :debug => 0,
+        :threads => 5,
+        :orbprop => {},
+        :port => 0
+      }
+
+      def initialize(options = {})
+        @options = OPTIONS.merge(options)
+        raise RuntimeError, 'nr. of threads must >= 1' if @options[:threads] < 1
+      end
+
+      def setup
+        # process options
+        #
+        if defined?(JRUBY_VERSION)
+          @options[:orbprop]['jacorb.poa.thread_pool_min'] = @options[:threads]
+          @options[:orbprop]['jacorb.poa.thread_pool_max'] = @options[:threads]*4
+          if @options[:debug] > 0
+            @options[:orbprop]['jacorb.log.default.verbosity'] = case
+            when @options[:debug] < 2
+              1
+            when (2...4) === @options[:debug]
+              2
+            when (5...7) === @options[:debug]
+              3
+            when @options[:debug] > 7
+              4
+            end
+          end
+          if @options[:port] > 0
+            @options[:orbprop]['OAPort'] = @options[:port]
+          end
+        else
+          if @options[:debug] > 0
+            @options[:orbprop]['-ORBDebugLevel'] = @options[:debug]
+          end
+          if @options[:port] > 0
+            @options[:orbprop]['-ORBListenEndpoints'] = "iiop://:#{@options[:port]}"
+          end
+        end
+
+        # initialize ORB and POA.
+        #
+        @orb = CORBA.ORB_init('INS_ORB', @options[:orbprop])
+
+        obj = @orb.resolve_initial_references('RootPOA')
+
+        root_poa = PortableServer::POA._narrow(obj)
+
+        poa_man = root_poa.the_POAManager
+
+        poa_man.activate
+
+        # create and activate root Naming context
+        #
+        @naming_srv = INS::NamingContext.new(@orb)
+
+        naming_obj = @naming_srv._this()
+
+        naming_ior = @orb.object_to_string(naming_obj)
+
+        # simplify Corbaloc urls (corbaloc:iiop:[host][:port]/NamingService)
+        #
+        @orb.ior_map.map_ior('NamingService', naming_ior)
+
+        # save INS IOR to file
+        #
+        open(@options[:iorfile], 'w') { |io|
+          io.write naming_ior
+        }
+      end
+
+      def run
+        STDERR.puts "INS - starting service run" if @options[:verbose]
+        if (defined?(JRUBY_VERSION) or !R2CORBA::TAO::RUBY_THREAD_SUPPORT)
+          STDERR.puts "INS - running ORB" if @options[:verbose]
+          @orb.run
+        else
+          STDERR.puts "INS - starting #{@options[:threads]} ORB threads" if @options[:verbose]
+          @threads = []
+          @options[:threads].times do
+            @threads << Thread.new(@orb) { |orb| orb.run }
+          end
+          STDERR.puts "INS - joining ORB threads" if @options[:verbose]
+          @threads.each { |t| t.join }
+        end
+        STDERR.puts "INS - service run ended" if @options[:verbose]
+      end
+
+      def shutdown
+        STDERR.puts "INS - shutting down ORB" if @options[:verbose]
+        @orb.shutdown if @orb
+        STDERR.puts "INS - shutdown finished" if @options[:verbose]
+      end
+    end
+  end
+end

data/lib/ridlbe/ruby/config.rb

@@ -1,336 +1,336 @@
-#--------------------------------------------------------------------
-# config.rb - IDL language mapping configuration for Ruby
-#
-# Author: Martin Corino
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the R2CORBA LICENSE which is
-# included with this program.
-#
-# Copyright (c) Remedy IT Expertise BV
-# Chamber of commerce Rotterdam nr.276339, The Netherlands
-#--------------------------------------------------------------------
-
-module IDL
-
-  class StrOStream
-    def initialize()
-      @str = ""
-    end
-    def clear
-      @str = ""
-    end
-    def to_s
-      @str
-    end
-    def <<(s)
-      @str << s
-    end
-  end # class StrOStream
-
-  class RIDL
-    private
-    def RIDL.merge_params(params)
-      opts = IDL::OPTIONS.dup
-      params.each do |k,v|
-        case opts[k]
-        when Array
-          opts[k] = opts[k] + (Array === v ? v : [v])
-        when Hash
-          opts[k] = opts[k].merge(v) if Hash === v
-        else
-          opts[k] = v
-        end
-      end
-      opts
-    end
-    def RIDL.parse0(src, params)
-      params = merge_params(params)
-      IDL.verbose_level = params[:verbose]
-      parser = ::IDL::Parser.new(params)
-      parser.parse(src)
-      s = ::IDL::StrOStream.new
-      s.clear
-      IDL::Ruby.process_input(parser,params,s)
-      s
-    end
-    def RIDL.parse(src, params)
-      s = parse0(src, params)
-      s.to_s
-    end
-    public
-    def RIDL.eval(src, params={})
-      params[:idl_eval] = true
-      params[:expand_includes] = true
-      params[:client_stubs] = true if params[:client_stubs].nil?
-      params[:stubs_only] ||= false
-      s = parse0(src, params)
-      Kernel.eval(s.to_s, ::TOPLEVEL_BINDING)
-      s = nil
-    end
-    def RIDL.fparse(fname, params = {})
-      params[:client_stubs] = true if params[:client_stubs].nil?
-      params[:stubs_only] ||= false
-      f = File.open(fname, "r")
-      self.parse(f, params)
-    ensure
-      f.close
-    end
-    def RIDL.feval(fname, params = {})
-      File.open(fname, "r") { |io| self.eval(io, params) }
-    end
-  end # module RIDL
-
-  module Ruby
-    COPYRIGHT = 'Copyright (c) 2007-2013 Remedy IT Expertise BV, The Netherlands'.freeze
-    TITLE = 'RIDL Ruby backend'.freeze
-    VERSION = {
-      :major => 1,
-      :minor => 9,
-      :release => 2
-    }
-
-    ## Configure Ruby backend
-    #
-    Backend.configure('ruby', File.dirname(__FILE__), TITLE, COPYRIGHT, VERSION) do |becfg|
-
-      # setup backend option handling
-      #
-      becfg.on_setup do |optlist, ridl_params|
-        # defaults
-        ridl_params[:stub_pfx] = 'C'
-        ridl_params[:srv_pfx] = 'S'
-        ridl_params[:stubs_only] = false
-        ridl_params[:client_stubs] = true
-        ridl_params[:expand_includes] = false
-        ridl_params[:libinit] = true
-        ridl_params[:class_interfaces] = []
-
-        # ruby specific option switches
-
-        unless IDL.preprocessing?   # same switch defined for IDL preprocessing mode
-          optlist.for_switch "--output=FILE", :type => String,
-              :description => ['Specifies filename to generate output in.',
-                               'Default: File.basename(idlfile, \'.idl\')+<postfix>+<ext>'] do |swcfg|
-            swcfg.on_exec do |arg, params|
-              params[:output] = arg
-            end
-
-          end
-        end
-
-        optlist.for_switch '-o PATH', :type => String,
-            :description => ["Specifies output directory.",
-                             "Default: ./"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:outputdir] = arg
-          end
-        end
-        optlist.for_switch '--stubs-only',
-            :description => ["Only generate client stubs, no servant code.",
-                             "Default: off"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:client_stubs] = true
-            params[:stubs_only] = true
-          end
-        end
-        optlist.for_switch '--no-stubs',
-            :description => ["Do not generate client stubs, only servant code.",
-                             "Default: off"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:client_stubs] = false
-            params[:stubs_only] = false
-          end
-        end
-        optlist.for_switch '--stub-pfx=POSTFIX', :type => String,
-            :description => ['Specifies postfix for generated client stub source filename.',
-                             'Filenames are formed like: <idl basename><postfix>.<language extension>',
-                             "Default: #{ridl_params[:stub_pfx]}"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:stub_pfx] = arg
-          end
-        end
-        optlist.for_switch '--skel-pfx=POSTFIX', :type => String,
-            :description => ['Specifies postfix for generated servant skeleton source filename.',
-                             'Filenames are formed like: <idl basename><postfix>.<language extension>',
-                             "Default: #{ridl_params[:srv_pfx]}"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:srv_pfx] = arg
-          end
-        end
-
-        optlist.for_switch '--skel-directory=PATH', :type => String,
-            :description => ["Specifies output directory for servant files.",
-                             "Default: outputdir or ./"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:skel_outputdir] = arg
-          end
-        end
-        optlist.for_switch '--expand-includes',
-            :description => ["Generate code for included IDL inline.",
-                             "Default: off"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:expand_includes] = true
-          end
-        end
-        optlist.for_switch '--no-libinit',
-            :description => ["Do not generate library initialization code as preamble.",
-                             "Default: on"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:libinit] = false
-          end
-        end
-        optlist.for_switch '--interface-as-class=INTF', :type => String,
-            :description => ["Generate a Ruby class for interface INTF instead of a module in client stubs.",
-                             "Default: module"] do |swcfg|
-          swcfg.on_exec do |arg, params|
-            params[:class_interfaces] << arg
-          end
-        end
-      end
-
-      # process input / generate code
-      # arguments:
-      #   in parser - parser object with full AST from parsed source
-      #   in options - initialized option hash
-      #
-      becfg.on_process_input do |parser, options|
-        IDL::Ruby.process_input(parser,options)
-      end # becfg.on_process_input
-
-    end # Backend.configure
-
-    def self.process_input(parser, options, outstream = nil)
-      # has a user defined output filename been set
-      fixed_output = !options[:output].nil?
-
-      # determine output file path for client stub code
-      unless fixed_output || options[:idlfile].nil?
-        options[:output] = options[:outputdir]+'/'+File.basename(options[:idlfile], '.idl')+options[:stub_pfx]+'.rb'
-      end
-      # generate client stubs if requested
-      if options[:client_stubs]
-        # open output file
-        co = outstream || (if options[:output].nil?
-           GenFile.new(nil, :output_file => $stdout)
-          else
-            GenFile.new(options[:output])
-          end)
-        begin
-          # process StubWriter
-          parser.visit_nodes(::IDL::RubyStubWriter.new(co, options))
-        rescue => ex
-          IDL.log(0, ex)
-          IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
-          exit 1
-        end
-      end
-
-      # determin output file path for servant code and open file
-      unless options[:stubs_only]
-        so = outstream || (unless fixed_output || options[:idlfile].nil?
-            options[:srv_output] = if fixed_output
-                options[:output]
-              else
-                options[:outputdir]+'/'+File.basename(options[:idlfile], '.idl')+options[:srv_pfx]+'.rb'
-              end
-            if fixed_output && options[:client_stubs]
-              co
-            else
-              GenFile.new(options[:srv_output])
-            end
-          else
-            GenFile.new(nil, :output_file => $stdout)
-          end)
-        begin
-          # process ServantWriter
-          parser.visit_nodes(::IDL::RubyServantWriter.new(so, options))
-        rescue => ex
-          IDL.log(0, ex)
-          IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
-          exit 1
-        end
-      end
-    end
-
-    module LeafMixin
-
-      RESERVED_RUBY_CONST = [
-        'Array', 'Bignum', 'Binding', 'Class', 'Continuation', 'Dir', 'Exception',
-        'FalseClass', 'File', 'Fixnum', 'Float', 'Hash', 'Integer', 'IO', 'MatchData',
-        'Method', 'Module', 'NilClass', 'Numeric', 'Object', 'Proc', 'Process', 'Range',
-        'Regexp', 'String', 'Struct', 'Symbol', 'Thread', 'ThreadGroup', 'Time', 'TrueClass',
-        'UnboundMethod', 'Comparable', 'Enumerable', 'Errno', 'FileTest', 'GC', 'Kernel',
-        'Marshal', 'Math', 'ObjectSpace', 'Signal'
-      ]
-
-      RESERVED_RUBY_MEMBER = [
-        "untaint", "id", "instance_variable_get", "inspect", "taint", "public_methods", "__send__", "to_a", "display", "instance_eval",
-        "extend", "clone", "protected_methods", "hash", "freeze", "type", "instance_variable_set", "methods", "instance_variables", "to_s", "method", "dup",
-        "private_methods", "object_id", "send", "__id__", "singleton_methods",
-        "proc", "readline", "global_variables", "singleton_method_removed", "callcc", "syscall", "fail", "untrace_var", "load", "srand", "puts", "catch", "chomp",
-        "initialize_copy", "format", "scan", "print", "abort", "fork", "gsub", "trap", "test", "select", "initialize", "method_missing", "lambda", "readlines",
-        "local_variables", "singleton_method_undefined", "system", "open", "caller", "eval", "set_trace_func", "require", "rand", "singleton_method_added",
-        "throw", "gets", "binding", "raise", "warn", "getc", "exec", "trace_var", "irb_binding", "at_exit", "split", "putc", "loop", "chop", "sprintf", "p",
-        "remove_instance_variable", "exit", "printf", "sleep", "sub", "autoload"
-      ]
-
-      def self.included(klass)
-        klass.extend ClassMethods
-      end
-
-      def rubyname
-        lm_name
-      end
-
-      def scoped_rubyname
-        scoped_lm_name
-      end
-
-      module ClassMethods
-        def mk_name(nm, is_scoped)
-          ret = nm.dup
-          case self::NAMETYPE
-          when :class
-            ret = ret[0,1].upcase + ret[1,ret.size].to_s
-            ret = 'R_'+ret if !is_scoped && IDL::Ruby::LeafMixin::RESERVED_RUBY_CONST.include?(ret)
-          when :member
-            ret = ret[0,1].downcase + ret[1,ret.size].to_s
-            ret = 'r_'+ret if IDL::Ruby::LeafMixin::RESERVED_RUBY_MEMBER.include?(ret)
-          else
-            raise RuntimeError,
-              "invalid nametype for #{self.class}: #{self::NAMETYPE}"
-          end
-          ret
-        end
-      end
-    end # module LeafMixin
-
-    IDL::AST::Leaf.class_eval do
-      include LeafMixin
-    end
-
-    module ScannerMixin
-
-      RUBYKW = [
-        '__FILE__', 'and',    'def',      'end',    'in',     'or',     'self',   'unless',
-        '__LINE__', 'begin',  'defined?', 'ensure', 'module', 'redo',   'super',  'until',
-        'BEGIN',    'break',  'do',       'false',  'next',   'rescue', 'then',   'when',
-        'END',      'case',   'else',     'for',    'nil',    'retry',  'true',   'while',
-        'alias',    'class',  'elsif',    'if',     'not',    'return', 'undef',  'yield',
-      ].collect! { |w| w.to_sym }
-
-      def chk_identifier(ident)
-        # prefix Ruby keywords with 'r_'
-        RUBYKW.include?(ident.to_sym) ? 'r_'+ident : ident
-      end
-
-    end # module ScannerMixin
-
-    IDL::Scanner.class_eval do
-      include ScannerMixin
-    end
-
-  end # module Ruby
-
-end # module IDL
+#--------------------------------------------------------------------
+# config.rb - IDL language mapping configuration for Ruby
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+module IDL
+
+  class StrOStream
+    def initialize()
+      @str = ""
+    end
+    def clear
+      @str = ""
+    end
+    def to_s
+      @str
+    end
+    def <<(s)
+      @str << s
+    end
+  end # class StrOStream
+
+  class RIDL
+    private
+    def RIDL.merge_params(params)
+      opts = IDL::OPTIONS.dup
+      params.each do |k,v|
+        case opts[k]
+        when Array
+          opts[k] = opts[k] + (Array === v ? v : [v])
+        when Hash
+          opts[k] = opts[k].merge(v) if Hash === v
+        else
+          opts[k] = v
+        end
+      end
+      opts
+    end
+    def RIDL.parse0(src, params)
+      params = merge_params(params)
+      IDL.verbose_level = params[:verbose]
+      parser = ::IDL::Parser.new(params)
+      parser.parse(src)
+      s = ::IDL::StrOStream.new
+      s.clear
+      IDL::Ruby.process_input(parser,params,s)
+      s
+    end
+    def RIDL.parse(src, params)
+      s = parse0(src, params)
+      s.to_s
+    end
+    public
+    def RIDL.eval(src, params={})
+      params[:idl_eval] = true
+      params[:expand_includes] = true
+      params[:client_stubs] = true if params[:client_stubs].nil?
+      params[:stubs_only] ||= false
+      s = parse0(src, params)
+      Kernel.eval(s.to_s, ::TOPLEVEL_BINDING)
+      s = nil
+    end
+    def RIDL.fparse(fname, params = {})
+      params[:client_stubs] = true if params[:client_stubs].nil?
+      params[:stubs_only] ||= false
+      f = File.open(fname, "r")
+      self.parse(f, params)
+    ensure
+      f.close
+    end
+    def RIDL.feval(fname, params = {})
+      File.open(fname, "r") { |io| self.eval(io, params) }
+    end
+  end # module RIDL
+
+  module Ruby
+    COPYRIGHT = "Copyright (c) 2007-#{Time.now.year} Remedy IT Expertise BV, The Netherlands".freeze
+    TITLE = 'RIDL Ruby backend'.freeze
+    VERSION = {
+      :major => 2,
+      :minor => 0,
+      :release => 1
+    }
+
+    ## Configure Ruby backend
+    #
+    Backend.configure('ruby', File.dirname(__FILE__), TITLE, COPYRIGHT, VERSION) do |becfg|
+
+      # setup backend option handling
+      #
+      becfg.on_setup do |optlist, ridl_params|
+        # defaults
+        ridl_params[:stub_pfx] = 'C'
+        ridl_params[:srv_pfx] = 'S'
+        ridl_params[:stubs_only] = false
+        ridl_params[:client_stubs] = true
+        ridl_params[:expand_includes] = false
+        ridl_params[:libinit] = true
+        ridl_params[:class_interfaces] = []
+
+        # ruby specific option switches
+
+        unless ridl_params[:preprocess]   # same switch defined for IDL preprocessing mode
+          optlist.for_switch "--output=FILE", :type => String,
+              :description => ['Specifies filename to generate output in.',
+                               'Default: File.basename(idlfile, \'.idl\')+<postfix>+<ext>'] do |swcfg|
+            swcfg.on_exec do |arg, params|
+              params[:output] = arg
+            end
+
+          end
+        end
+
+        optlist.for_switch '-o PATH', :type => String,
+            :description => ["Specifies output directory.",
+                             "Default: ./"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:outputdir] = arg
+          end
+        end
+        optlist.for_switch '--stubs-only',
+            :description => ["Only generate client stubs, no servant code.",
+                             "Default: off"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:client_stubs] = true
+            params[:stubs_only] = true
+          end
+        end
+        optlist.for_switch '--no-stubs',
+            :description => ["Do not generate client stubs, only servant code.",
+                             "Default: off"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:client_stubs] = false
+            params[:stubs_only] = false
+          end
+        end
+        optlist.for_switch '--stub-pfx=POSTFIX', :type => String,
+            :description => ['Specifies postfix for generated client stub source filename.',
+                             'Filenames are formed like: <idl basename><postfix>.<language extension>',
+                             "Default: #{ridl_params[:stub_pfx]}"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:stub_pfx] = arg
+          end
+        end
+        optlist.for_switch '--skel-pfx=POSTFIX', :type => String,
+            :description => ['Specifies postfix for generated servant skeleton source filename.',
+                             'Filenames are formed like: <idl basename><postfix>.<language extension>',
+                             "Default: #{ridl_params[:srv_pfx]}"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:srv_pfx] = arg
+          end
+        end
+
+        optlist.for_switch '--skel-directory=PATH', :type => String,
+            :description => ["Specifies output directory for servant files.",
+                             "Default: outputdir or ./"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:skel_outputdir] = arg
+          end
+        end
+        optlist.for_switch '--expand-includes',
+            :description => ["Generate code for included IDL inline.",
+                             "Default: off"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:expand_includes] = true
+          end
+        end
+        optlist.for_switch '--no-libinit',
+            :description => ["Do not generate library initialization code as preamble.",
+                             "Default: on"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:libinit] = false
+          end
+        end
+        optlist.for_switch '--interface-as-class=INTF', :type => String,
+            :description => ["Generate a Ruby class for interface INTF instead of a module in client stubs.",
+                             "Default: module"] do |swcfg|
+          swcfg.on_exec do |arg, params|
+            params[:class_interfaces] << arg
+          end
+        end
+      end
+
+      # process input / generate code
+      # arguments:
+      #   in parser - parser object with full AST from parsed source
+      #   in options - initialized option hash
+      #
+      becfg.on_process_input do |parser, options|
+        IDL::Ruby.process_input(parser,options)
+      end # becfg.on_process_input
+
+    end # Backend.configure
+
+    def self.process_input(parser, options, outstream = nil)
+      # has a user defined output filename been set
+      fixed_output = !options[:output].nil?
+
+      # determine output file path for client stub code
+      unless fixed_output || options[:idlfile].nil?
+        options[:output] = options[:outputdir]+'/'+File.basename(options[:idlfile], '.idl')+options[:stub_pfx]+'.rb'
+      end
+      # generate client stubs if requested
+      if options[:client_stubs]
+        # open output file
+        co = outstream || (if options[:output].nil?
+           GenFile.new(nil, :output_file => $stdout)
+          else
+            GenFile.new(options[:output])
+          end)
+        begin
+          # process StubWriter
+          parser.visit_nodes(::IDL::RubyStubWriter.new(co, options))
+        rescue => ex
+          IDL.log(0, ex)
+          IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+          exit 1
+        end
+      end
+
+      # determin output file path for servant code and open file
+      unless options[:stubs_only]
+        so = outstream || (unless fixed_output || options[:idlfile].nil?
+            options[:srv_output] = if fixed_output
+                options[:output]
+              else
+                options[:outputdir]+'/'+File.basename(options[:idlfile], '.idl')+options[:srv_pfx]+'.rb'
+              end
+            if fixed_output && options[:client_stubs]
+              co
+            else
+              GenFile.new(options[:srv_output])
+            end
+          else
+            GenFile.new(nil, :output_file => $stdout)
+          end)
+        begin
+          # process ServantWriter
+          parser.visit_nodes(::IDL::RubyServantWriter.new(so, options))
+        rescue => ex
+          IDL.log(0, ex)
+          IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+          exit 1
+        end
+      end
+    end
+
+    module LeafMixin
+
+      RESERVED_RUBY_CONST = [
+        'Array', 'Bignum', 'Binding', 'Class', 'Continuation', 'Dir', 'Exception',
+        'FalseClass', 'File', 'Fixnum', 'Float', 'Hash', 'Integer', 'IO', 'MatchData',
+        'Method', 'Module', 'NilClass', 'Numeric', 'Object', 'Proc', 'Process', 'Range',
+        'Regexp', 'String', 'Struct', 'Symbol', 'Thread', 'ThreadGroup', 'Time', 'TrueClass',
+        'UnboundMethod', 'Comparable', 'Enumerable', 'Errno', 'FileTest', 'GC', 'Kernel',
+        'Marshal', 'Math', 'ObjectSpace', 'Signal'
+      ]
+
+      RESERVED_RUBY_MEMBER = [
+        "untaint", "id", "instance_variable_get", "inspect", "taint", "public_methods", "__send__", "to_a", "display", "instance_eval",
+        "extend", "clone", "protected_methods", "hash", "freeze", "type", "instance_variable_set", "methods", "instance_variables", "to_s", "method", "dup",
+        "private_methods", "object_id", "send", "__id__", "singleton_methods",
+        "proc", "readline", "global_variables", "singleton_method_removed", "callcc", "syscall", "fail", "untrace_var", "load", "srand", "puts", "catch", "chomp",
+        "initialize_copy", "format", "scan", "print", "abort", "fork", "gsub", "trap", "test", "select", "initialize", "method_missing", "lambda", "readlines",
+        "local_variables", "singleton_method_undefined", "system", "open", "caller", "eval", "set_trace_func", "require", "rand", "singleton_method_added",
+        "throw", "gets", "binding", "raise", "warn", "getc", "exec", "trace_var", "irb_binding", "at_exit", "split", "putc", "loop", "chop", "sprintf", "p",
+        "remove_instance_variable", "exit", "printf", "sleep", "sub", "autoload"
+      ]
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      def rubyname
+        lm_name
+      end
+
+      def scoped_rubyname
+        scoped_lm_name
+      end
+
+      module ClassMethods
+        def mk_name(nm, is_scoped)
+          ret = nm.dup
+          case self::NAMETYPE
+          when :class
+            ret = ret[0,1].upcase + ret[1,ret.size].to_s
+            ret = 'R_'+ret if !is_scoped && IDL::Ruby::LeafMixin::RESERVED_RUBY_CONST.include?(ret)
+          when :member
+            ret = ret[0,1].downcase + ret[1,ret.size].to_s
+            ret = 'r_'+ret if IDL::Ruby::LeafMixin::RESERVED_RUBY_MEMBER.include?(ret)
+          else
+            raise RuntimeError,
+              "invalid nametype for #{self.class}: #{self::NAMETYPE}"
+          end
+          ret
+        end
+      end
+    end # module LeafMixin
+
+    IDL::AST::Leaf.class_eval do
+      include LeafMixin
+    end
+
+    module ScannerMixin
+
+      RUBYKW = [
+        '__FILE__', 'and',    'def',      'end',    'in',     'or',     'self',   'unless',
+        '__LINE__', 'begin',  'defined?', 'ensure', 'module', 'redo',   'super',  'until',
+        'BEGIN',    'break',  'do',       'false',  'next',   'rescue', 'then',   'when',
+        'END',      'case',   'else',     'for',    'nil',    'retry',  'true',   'while',
+        'alias',    'class',  'elsif',    'if',     'not',    'return', 'undef',  'yield',
+      ].collect! { |w| w.to_sym }
+
+      def chk_identifier(ident)
+        # prefix Ruby keywords with 'r_'
+        RUBYKW.include?(ident.to_sym) ? 'r_'+ident : ident
+      end
+
+    end # module ScannerMixin
+
+    IDL::Scanner.class_eval do
+      include ScannerMixin
+    end
+
+  end # module Ruby
+
+end # module IDL