r2corba 1.4.1-x64-mingw32

data/lib/ridlbe/ruby/config.rb

@@ -0,0 +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

data/lib/ridlbe/ruby/require.rb

@@ -0,0 +1,16 @@
+#--------------------------------------------------------------------
+# require.rb - IDL language mapping loader
+#
+# 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
+#--------------------------------------------------------------------
+
+(Dir.glob(File.join(File.dirname(__FILE__), '*.rb')) - [__FILE__]).each do |f|
+  require f
+end