ridl 2.2.4

data/lib/ridl/require.rb

@@ -0,0 +1,18 @@
+#--------------------------------------------------------------------
+# require.rb - Ruby IDL loader
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'ridl/version'
+require 'ridl/scanner'
+require 'ridl/type'
+require 'ridl/node'
+require 'ridl/expression'
+require 'ridl/parser'

data/lib/ridl/ridl.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+# Encoding.default_internal = 'UTF-8'
+
+# :main: README.rdoc
+
+#--------------------------------------------------------------------
+# ridl.rb - main file for Ruby IDL compiler
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'ridl/require'
+
+##
+# RIDL is a Ruby library implementing an OMG \IDL parser/compiler
+# frontend with support for pluggable (and stackable) backends.
+#
+# RIDL itself implements an \IDL parser (RACC based) in IDL::Parser in
+# combination with IDL::Scanner, syntax tree classes under IDL::AST,
+# type classes under IDL::Type and expression classes under
+# IDL::Expression.
+# Furthermore RIDL implements a number of support classes useful in
+# the implementation of backends for RIDL.
+#
+# RIDL does *not* implement any standard backend to handle things like
+# code generation and/or documentation generation but instead provides
+# a framework for user defined pluggable backends.
+# Known backends for RIDL are the R2CORBA RIDL backend and the IDL2C++11
+# backend.
+#
+module IDL
+end
+
+# load RIDL runner/initializer
+require 'ridl/runner'
+
+# initialize RIDL
+IDL.init

data/lib/ridl/runner.rb

@@ -0,0 +1,304 @@
+#--------------------------------------------------------------------
+# run.rb - Standalone Ruby IDL compiler runner
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# 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'
+
+# -----------------------------------------------------------------------
+
+$VERBOSE = $VERBOSE || ENV['RIDL_VERBOSE']
+
+module IDL
+
+  @@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,
+      :debug           => false,
+      :namespace       => nil,
+      :search_incpath  => false,
+      :backend         => nil,
+      :macros          => {
+        :__RIDL__  => "#{RIDL_VERSION}",
+        :__RIDLBE__ => nil,
+        :__RIDLBE_VER__ => nil
+      }
+  }
+
+  def IDL.preprocessing?
+    @@preprocessing
+  end
+
+  def IDL.no_pidl?
+    @@no_pidl
+  end
+
+  def IDL.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
+
+      # 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'
+        @@preprocessing = true
+        ARGV.shift
+      elsif ARGV.first == '--ignore-pidl'
+        @@no_pidl = true
+        ARGV.shift
+      end
+    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
+    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 }
+    end
+
+    # setup language mapping specific options
+    be_options = OptionList.new
+    @@backend.setup_be(be_options, OPTIONS)
+    be_options.to_option_parser(opts, OPTIONS)
+
+    opts.on('-V', "--version",
+            "Show version information and exit.") {
+                puts "RIDL compiler #{OPTIONS[:macros][:__RIDL__]}"
+                puts RIDL_COPYRIGHT
+                puts '---'
+                @@backend.print_version
+                exit
+            }
+
+    opts.separator ""
+
+    opts.on("-h", "--help",
+            "Show this help message.") { puts opts; puts; exit }
+
+    opts.parse!(ARGV)
+  end
+
+  def IDL.push_input(idlfile, opts)
+    @@idlstack << [idlfile, opts]
+  end
+
+  def IDL.pop_input
+    @@idlstack.shift
+  end
+
+  def IDL.peek_input
+    @@idlstack.first
+  end
+
+  def IDL.has_input?
+    !@@idlstack.empty?
+  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
+
+    verbose_level = OPTIONS[:verbose]
+
+    if preprocessing?
+      ## PREPROCESSING
+      o = if OPTIONS[:output].nil?
+          $stdout
+        else
+          File.open(OPTIONS[:output], "w+")
+        end
+      OPTIONS[:output] = o
+
+      parser = ::IDL::Parser.new(OPTIONS)
+      parser.yydebug = OPTIONS[: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}\"")
+      rescue => ex
+        IDL.error(ex.inspect)
+        IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+      ensure
+        o.close
+      end
+    else
+      ## collect input files from commandline
+      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
+          _arg = _fpath unless _fpath.nil?
+        end
+        _opts[:includepaths] << File.dirname(_arg)
+
+        _opts[:outputdir] ||= '.'
+
+        push_input(_arg, _opts)
+      end
+
+      ## if no IDL input file specified read from STDIN
+      unless has_input?
+        _opts = OPTIONS.dup
+        _opts[:outputdir] ||= '.'
+        push_input($stdin, _opts)
+      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
+
+        # parse IDL source
+        IDL.log(1, "RIDL - parsing #{IO === _idlfile ? 'from STDIN': _idlfile}")
+
+        _parser = ::IDL::Parser.new(_opts)
+        _parser.yydebug = _opts[:debug]
+
+        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
+
+        # process parse result -> code generation
+        IDL.log(2, 'RIDL - starting code generation')
+
+        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
+    end
+  end # IDL.run
+
+  def IDL.verbose_level
+    @@verbose_level
+  end
+
+  def IDL.verbose_level=(l)
+    @@verbose_level = l
+  end
+
+  def IDL.log(level, message)
+    STDERR.puts message if verbose_level >= level
+  end
+
+  def IDL.error(message)
+    STDERR.puts(message)
+  end
+
+end

data/lib/ridl/scanner.rb

@@ -0,0 +1,1238 @@
+#--------------------------------------------------------------------
+# scanner.rb - IDL scanner
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'racc/parser'
+
+module IDL
+  class ParseError < StandardError
+    attr_reader :positions
+    def initialize(msg, positions)
+      super(msg)
+      @positions = positions
+    end
+    def inspect
+      puts self.class.name+": "+message
+      @positions.each { |pos|
+        print "    "
+        puts pos
+      }
+      nil
+    end
+  end
+
+  class Scanner
+    Position = Struct.new(nil, :name, :line, :column)
+
+    class Position
+      def to_s
+        format("%s: line %d, column %d", name.to_s, line, column)
+      end
+      def inspect
+        to_s
+      end
+    end ## Position
+
+    class In
+      def initialize(src, name = '', line = 0, column = 1)
+        @src, @fwd, @bwd = src, src.getc, nil
+        @pos = Position.new(name, line, column)
+        @mark = nil
+      end
+      def position
+        @pos
+      end
+      def column
+        @pos.column
+      end
+      # cursor set at last gotten character.
+      # ex: after initialization, position is (0,0).
+      def to_s; @src.to_s; end
+
+      def lookc
+        @fwd
+      end
+
+      def getc
+        cur = @fwd
+        @fwd = @src.getc unless @src.nil?
+        @mark << cur unless @mark.nil?
+        if [nil, ?\n, ?\r].include? @bwd
+          if @bwd == ?\r and cur == ?\n
+          else
+            @pos.line += 1
+            @pos.column = 1
+          end
+              else
+          @pos.column += 1
+        end
+
+        if false
+          if not @bwd.nil? or cur.nil? or @fwd.nil?
+          printf("%c(%02x), %c(%02x), %c(%02x) @(l:%d,c:%d)\n",
+                @bwd,@bwd,cur,cur,@fwd,@fwd, @pos.line, @pos.column)
+          end
+        end
+        @bwd = cur
+      end
+
+      def gets
+        return nil if @fwd.nil?
+
+        s = ""
+        s << getc until [nil, ?\n, ?\r].include? lookc
+        s << getc while [?\n, ?\r].include? lookc
+
+        @mark << s unless @mark.nil?
+        s
+      end
+      alias skipc getc
+
+      def _include?(ch, *chars)
+        chars.each { |v|
+          return true if case v
+            when Array
+              _include?(ch, *v)
+            when Enumerable
+              v.include? ch
+            when Fixnum
+              v == ch
+            when String
+              v == ch
+            else
+              false
+            end
+        }
+        return false
+      end
+
+      def skipwhile(*chars, &block)
+        if block.nil?
+          block = Proc.new { |ch| _include?(ch, *chars) }
+        end
+
+        until (ch = lookc).nil?
+          break unless block.call(ch)
+          skipc
+        end
+        ch
+      end
+
+      def skipuntil(*chars, &block)
+        if block.nil?
+          block = Proc.new { |ch| _include?(ch, *chars) }
+        end
+
+        until (ch = lookc).nil?
+          break if block.call(ch)
+          skipc
+        end
+        ch
+      end
+
+      def mark(*ini)
+        @mark = ""
+        ini.each { |i|
+          case i
+          when nil
+          when String
+            @mark << i.dup
+          when Fixnum
+            @mark << i
+          when Array
+            i.each { |j| @mark << j } # array of array is not incoming.
+          end
+        }
+      end
+
+      def getregion
+        ret = @mark
+        @mark = nil
+        return ret
+      end
+    end ## of class In
+
+    class StrIStream
+      def initialize(src)
+        @src = src
+        @i = 0
+      end
+      def to_s
+        @src
+      end
+      def getc
+        ch = @src[@i]
+        @i += 1
+        ch
+      end
+      def close
+        @i = 0
+      end
+    end ## of class StrIStream
+
+    class TokenRegistry < ::Hash
+      def [](key)
+        super(::Symbol === key ? key : key.to_s.to_sym)
+      end
+      def []=(key, val)
+        super(::Symbol === key ? key : key.to_s.to_sym, val.to_s)
+      end
+      def has_key?(key)
+        super(::Symbol === key ? key : key.to_s.to_sym)
+      end
+      def delete(key)
+        super(::Symbol === key ? key : key.to_s.to_sym)
+      end
+      def assoc(key)
+        k_ = (::Symbol === key ? key : key.to_s.to_sym)
+        self.has_key?(k_) ? [k_, self[k_]] : nil
+      end
+    end
+
+    class CharRegistry
+      def initialize(table_)
+        @table = table_
+      end
+      def [](key)
+        key = (::Integer === key) ? key.chr.to_sym : key.to_sym
+        @table[key]
+      end
+    end
+
+    # string derivative for IDL parsed identifiers able
+    # to carry both 'raw' IDL name as well as language mapped
+    # name
+    class Identifier < ::String
+      attr_reader :checked_name
+      def initialize(idl_id, checked_id)
+        super(idl_id)
+        @checked_name = checked_id
+      end
+    end
+
+    # Scanner
+    def initialize(src, directiver, params = {})
+      @includepaths = params[:includepaths] || []
+      @stack = []
+      @expansions = []
+      @prefix = nil
+      @directiver = directiver
+      @defined = TokenRegistry.new
+      # initialize with predefined macros
+      if params[:macros]
+        params[:macros].each do |(name, value)|
+          @defined[name] = value
+        end
+      end
+      @ifdef = Array.new
+      @ifskip = false
+      @ifnest = 0
+      i = nil
+      nm = ''
+      case src
+      when String
+        i = StrIStream.new(src)
+        nm = '<string>'
+      when File
+        i = src
+        nm = src.path
+      when IO
+        i = src
+        nm = '<io>'
+      else
+        parse_error "illegal type for input source: #{src.class} "
+      end
+      @in = In.new(i, nm)
+      @scan_comment = false # true if parsing commented annotation
+      @in_annotation = false # true if parsing annotation
+    end
+    def find_include(fname)
+      path = if File.file?(fname) && File.readable?(fname)
+        fname
+      else
+        fp = @includepaths.find do |p|
+          f = p + "/" + fname
+          File.file?(f) && File.readable?(f)
+        end
+        fp += '/' + fname if !fp.nil?
+        fp
+      end
+    end
+    def enter_include(src)
+      if @directiver.is_included?(src)
+        @directiver.declare_include(src)
+      else
+        fpath = find_include(src)
+        if fpath.nil?
+          parse_error "Cannot open include file '#{src}'"
+        end
+        @stack << [:include, @prefix, @ifdef, @in, @ifskip]
+        @prefix = nil
+        @ifdef = Array.new
+        @in = In.new(File.open(fpath, 'r'), fpath)
+        @directiver.enter_include(src)
+        @directiver.pragma_prefix(nil)
+      end
+    end
+    def enter_expansion(src, define)
+      @stack << [:define, nil, nil, @in, nil]
+      @expansions << define
+      @in = In.new(StrIStream.new(src), @in.position.name, @in.position.line, @in.position.column)
+    end
+    def is_expanded?(define)
+      @expansions.include?(define)
+    end
+    def more_source?
+      @stack.size>0
+    end
+    def in_expansion?
+      more_source? and @stack.last[0] == :define
+    end
+    def leave_source()
+      if @stack.size>0
+        if @stack.last[0] == :include
+          @directiver.leave_include
+          type, @prefix, @ifdef, @in, @ifskip = @stack.pop
+          @directiver.pragma_prefix(@prefix)
+        else
+          type, prefix_, ifdef_, @in, elsif_ = @stack.pop
+          @expansions.pop
+        end
+      end
+    end
+    def do_parse?
+      @ifdef.empty? || @ifdef.last
+    end
+    def positions
+      @stack.reverse.inject(@in.nil? ? [] : [@in.position]) {|pos_arr,(type_,pfx_,ifdef_,in_,elsif_)| pos_arr << in_.position }
+    end
+    def parse_error(msg, ex = nil)
+      e = IDL::ParseError.new(msg, positions)
+      e.set_backtrace(ex.backtrace) unless ex.nil?
+      raise e
+    end
+
+    LFCR = [ (?\n), (?\r) ]
+    WHITESPACE = [ (?\ ), (?\t) ].concat(LFCR)
+
+    ANNOTATION = ?@
+    ANNOTATION_STR = '@'
+
+    BREAKCHARS = [
+      ?(, ?), ?[, ?], ?{, ?},
+      ?^, ?~,
+      ?*, ?%, ?&, ?|,
+      ?<, ?=, ?>,
+      ?,, ?; ]
+
+    SHIFTCHARS = [ ?<, ?> ]
+
+    HEXCHARS = [(?0..?9).to_a, (?a..?f).to_a, (?A..?F).to_a].flatten
+
+    IDCHARS = [?_ , (?a..?z).to_a, (?A..?Z).to_a].flatten
+
+    ESCTBL = CharRegistry.new({
+      :n => ?\n, :t => ?\t, :v => ?\v, :b => ?\b,
+      :r => ?\r, :f => ?\f, :a => ?\a
+    })
+
+    KEYWORDS = [ # see 7.2.4 "Keywords" of CORBA V3.2 specification (part1) and 7.3.6 (part3; IDL3+ keywords)
+      "abstract",
+      "alias",
+      "any",
+      "attribute",
+      "boolean",
+      "case",
+      "char",
+      "component",
+      "connector",
+      "const",
+      "consumes",
+      "context",
+      "custom",
+      "default",
+      "double",
+      "exception",
+      "emits",
+      "enum",
+      "eventtype",
+      "factory",
+      "FALSE",
+      "finder",
+      "fixed",
+      "float",
+      "getraises",
+      "home",
+      "import",
+      "in",
+      "inout",
+      "interface",
+      "local",
+      "long",
+      "manages",
+      "mirrorport",
+      "module",
+      "multiple",
+      "native",
+      "Object",
+      "octet",
+      "oneway",
+      "out",
+      "port",
+      "porttype",
+      "primarykey",
+      "private",
+      "provides",
+      "public",
+      "publishes",
+      "raises",
+      "readonly",
+      "setraises",
+      "sequence",
+      "short",
+      "string",
+      "struct",
+      "supports",
+      "switch",
+      "TRUE",
+      "truncatable",
+      "typedef",
+      "typeid",
+      "typename",
+      "typeprefix",
+      "unsigned",
+      "union",
+      "uses",
+      "ValueBase",
+      "valuetype",
+      "void",
+      "wchar",
+      "wstring",
+    ].inject(TokenRegistry.new) { |h,a| h[a.downcase.to_sym] = a; h }
+
+    LITERALS = [
+      :integer_literal,
+      :string_literal,
+      # :wide_string_literal,
+      :character_literal,
+      # :wide_character_literal,
+      :fixed_pt_literal,
+      :floating_pt_literal,
+      :boolean_literal ]
+
+    BOOL_LITERALS = {
+        'false' => false,
+        'true' => true
+      }
+
+    def is_literal?(o)
+      return LITERALS.include?(o)
+    end
+
+    def extract_annotation_value()
+      annotation_value = nil
+      token = next_token # needs '{' (array) or literal or identifier (which means nested annotation object or enum value)
+      if token.first == '{'
+        # extract array of values (literals or identifiers) separated by ','
+        annotation_value = []
+        begin
+          token, ann_value = extract_annotation_value()
+          parse_error 'invalid annotation value array' unless token.first == ',' || token.first == '}'
+          annotation_value << ann_value
+        end until token.first == '}'
+        token = next_token
+      elsif token.first == :identifier
+        member_annotation_id = token.last
+        # get nested body
+        token, member_annotation_body = extract_annotation()
+        # determin vaue type; if it has a body it is an annotation instance
+        if member_annotation_body
+          annotation_value = { member_annotation_id => member_annotation_body }
+        else  # otherwise it is a symbolic value
+          annotation_value = member_annotation_id.to_sym
+        end
+      else
+        parse_error 'invalid annotation member' unless is_literal?(token.first)
+        annotation_value = token.last
+        token = next_token
+      end
+      return [token, annotation_value]
+    end
+
+    def extract_annotation()
+      annotation_body = nil
+      # next token should be '(' in case of normal/single value annotation
+      # or anything else in case of marker annotation
+      token = next_token
+      if token.first == '('
+        begin
+          # identifier or value (in case of single value annotation) expected
+          token = next_token
+          if token.first == ')' # marker annotation; leave body empty
+            annotation_body = { }
+          else
+            parse_error 'annotation member expected!' unless token.first == :identifier || is_literal?(token.first)
+            s1 = token.last
+            token = next_token # ')'  (in case of single value annotation) or '='
+            if token.first == ')'
+              parse_error 'invalid annotation member' if annotation_body
+              annotation_body = { :value => s1 }
+            else
+              parse_error 'invalid annotation member' unless token.first == '='
+              token, annotation_value = extract_annotation_value()
+              parse_error 'invalid annotation body' unless token.first == ',' || token.first == ')'
+              (annotation_body ||= {})[s1] = annotation_value
+            end
+          end
+        end until token.first == ')'
+        token = next_token # need to get next token
+      else
+        # marker annotation or symbolic value; leave body nil
+      end
+      return [token, annotation_body]
+    end
+
+    def parse_annotation(in_comment = false)
+      @in_annotation = true
+      @scan_comment = in_comment
+      begin
+        # parse (possibly multiple) annotation(s)
+        begin
+          # next token should be identifier (must be on same line following '@')
+          token = next_token
+          parse_error 'annotation identifier expected!' unless token.first == :identifier
+          annotation_id = token.last
+          token, annotation_body = extract_annotation()
+          # pass annotation to directiver for processing
+          @directiver.define_annotation(annotation_id, annotation_body || {})
+        end until token.first != ANNOTATION_STR
+      ensure
+        @in_annotation = false
+        @scan_comment = false
+      end
+      # check identifier for keywords
+      if token.first == :identifier
+        # keyword check
+        if (a = KEYWORDS.assoc(token.last)).nil?
+          token = [ :identifier, Identifier.new(token.last, chk_identifier(token.last)) ]
+        elsif token.last == a[1]
+          token = [ a[1], nil ]
+        else
+          parse_error "`#{token.last}' collides with a keyword `#{a[1]}'"
+        end
+      end
+      return token
+    end
+
+    def next_identifier(first = nil)
+      @in.mark(first)
+      while TRUE
+        case @in.lookc
+        when nil
+          break
+        when ?0..?9, ?a..?z, ?A..?Z, ?_
+          @in.skipc
+        else
+          break
+        end
+      end
+      s0 = @in.getregion
+      s1 = s0.downcase
+
+      # simple check
+      if (s0.length == 0)
+        parse_error "identifier expected!"
+      else
+        case s0[0]
+        when ?a..?z, ?A..?Z
+        when ?_   ## if starts with CORBA IDL escape => remove
+          s0.slice!(0)
+        else
+          parse_error "identifier must begin with alphabet character: #{s0}"
+        end
+      end
+
+      # preprocessor check
+      if @defined.has_key?(s0) and !is_expanded?(s0)
+        # enter expansion as new source
+        enter_expansion(@defined[s0], s0)
+        # call next_token to parse expanded source
+        next_token
+      # keyword check
+      elsif @in_annotation
+        if BOOL_LITERALS.has_key?(s1)
+          [ :boolean_literal, BOOL_LITERALS[s1] ]
+        else
+          [ :identifier, s0 ]
+        end
+      elsif (a = KEYWORDS.assoc(s1)).nil?
+        # check for language mapping keyword except when
+        # - this is an IDL escaped ('_' prefix) identifier
+        [ :identifier, Identifier.new(s0, s1[0] == ?_ ? s0 : chk_identifier(s0)) ]
+      elsif s0 == a[1]
+        [ a[1], nil ]
+      else
+        parse_error "`#{s0}' collides with a keyword `#{a[1]}'"
+      end
+    end
+
+    def next_escape
+      ret = 0
+      case (ch = @in.getc)
+      when nil
+        parse_error 'illegal escape sequence'
+      when ?0..?7
+        ret = ""
+        ret << ch
+        1.upto(2) {
+          ch = @in.lookc
+          if (?0..?7).include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = ret.oct
+      when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
+        ret = ""
+        1.upto(2) {
+          ch = @in.lookc
+          if HEXCHARS.include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = ret.hex
+      when ?u
+        ret = ""
+        1.upto(4) {
+          ch = @in.lookc
+          if HEXCHARS.include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = ret.hex
+      when ?n, ?t, ?v, ?b, ?r, ?f, ?a
+        ret = ESCTBL[ch]
+      else
+        ret = ('' << ch).unpack('C').first
+      end
+      return ret
+    end
+
+    def next_escape_str(keep_type_ch = false)
+      ret = 0
+      case (ch = @in.getc)
+      when nil
+        parse_error 'illegal escape sequence'
+      when ?0..?7
+        ret = ""
+        ret << ch
+        1.upto(2) {
+          ch = @in.lookc
+          if (?0..?7).include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = [ :oct, ret ]
+      when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
+        ret = ""
+        ret << ch if keep_type_ch
+        1.upto(2) {
+          ch = @in.lookc
+          if HEXCHARS.include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = [ :hex2, ret ]
+      when ?u
+        ret = ""
+        ret << ch if keep_type_ch
+        1.upto(4) {
+          ch = @in.lookc
+          if HEXCHARS.include? ch
+            ret << ch
+          else
+            break
+          end
+          @in.skipc
+        }
+        ret = [ :hex4, ret ]
+      when ?n, ?t, ?v, ?b, ?r, ?f, ?a
+        ret = ''
+        ret << ch
+        ret = [ :esc, ret ]
+      else
+        ret = ''
+        ret << ch
+        ret = [ :esc_ch, ch ]
+      end
+      return ret
+    end
+
+    def skipfloat_or_fixed
+      if (@in.lookc == ?.)
+        @in.skipc
+        @in.skipwhile(?0..?9)
+      end
+      if [?e, ?E].include? @in.lookc
+        @in.skipc
+        @in.skipc if [?+, ?-].include? @in.lookc
+        @in.skipwhile(?0..?9)
+        return :floating_pt_literal
+      elsif [?d, ?D].include? @in.lookc
+        @in.skipc
+        @in.skipc if [?+, ?-].include? @in.lookc
+        @in.skipwhile(?0..?9)
+        return :fixed_pt_literal
+      end
+      return :floating_pt_literal
+    end
+
+    def skipline
+      while TRUE
+        s = @in.gets
+        until s.chomp!.nil?; end
+        break unless s[s.length - 1] == ?\\
+      end
+    end
+
+    def getline
+      s = ""
+      while TRUE
+        ch = @in.lookc
+        break if ch.nil?
+        case
+        when (ch == ?\") #"
+          s << @in.getc # opening quote
+          while TRUE
+            if @in.lookc == ?\\
+              # escape sequence
+              s << @in.getc
+              esctyp, escstr = next_escape_str(true)
+              s << escstr
+            elsif @in.lookc == ?\" #"
+              break
+            elsif @in.lookc
+              # normal character
+              s << @in.getc
+            else
+              parse_error "unterminated string literal"
+            end
+          end
+          s << @in.getc # closing quote
+        when (ch == ?\') #' # quoted character
+          s << @in.getc # opening quote
+          if @in.lookc == ?\\
+            # escape sequence
+            s << @in.getc
+            esctyp, escstr = next_escape_str(true)
+            s << escstr
+          elsif @in.lookc && @in.lookc != ?\' #'
+            # normal character
+            s << @in.getc
+          end
+          if @in.lookc != ?\' #'
+            parse_error "character literal must be single character enclosed in \"'\""
+          end
+          s << @in.getc # closing quote
+        when LFCR.include?(ch)
+          @in.skipwhile() { |ch_| LFCR.include? ch_ }
+          break
+        when ch == ?/
+          @in.skipc
+          if @in.lookc == ?/
+            # //-style comment; skip till eol
+            @in.gets
+            break
+          elsif @in.lookc == ?*
+            # /*...*/ style comment; skip comment
+            ch1 = nil
+            @in.skipuntil { |ch_|
+              ch0 = ch1; ch1 = ch_
+              ch0 == ?* and ch1 == ?/ #
+            }
+            if @in.lookc.nil?
+              parse_error "cannot find comment closing brace (\'*/\'). "
+            end
+            @in.skipc
+          else
+            s << ch
+          end
+        when ch == ?\\
+          @in.skipc
+          if LFCR.include?(@in.lookc)
+            # line continuation
+            @in.skipwhile() { |ch_| LFCR.include? ch_ }
+            if @in.lookc.nil?
+              parse_error "line continuation character ('\\') not allowed as last character in file."
+            end
+          else
+            s << ch
+          end
+        else
+          @in.skipc
+          s << ch
+        end
+      end
+      s
+    end
+
+    def resolve_define(id, stack = [])
+      return id if ['true', 'false'].include?(id)
+      IDL.log(3,"*** RIDL - resolve_define(#{id})")
+      if @defined.has_key?(id)
+        define_ = @defined[id]
+        stack << id
+        parse_error("circular macro reference detected for [#{define_}]") if stack.include?(define_)
+        # resolve any nested macro definitions
+        define_.gsub(/(^|[\W])([A-Za-z_][\w]*)/) do |m_| "#{$1}#{resolve_define($2, stack)}" end
+      else
+        '0' # unknown id
+      end
+    end
+
+    def eval_directive(s)
+      IDL.log(2,"** RIDL - eval_directive(#{s})")
+      rc = eval(s)
+      case rc
+      when FalseClass, TrueClass
+        rc
+      when Numeric
+        rc != 0
+      else
+        parse_error "invalid preprocessor expression."
+      end
+    end
+
+    def parse_directive
+      @in.skipwhile(?\ , ?\t)
+      s = getline
+      /^(\w*)\s*/ === s
+      s1,s2 = $1, $' #'
+
+      if /(else|endif|elif)/ === s1
+
+        if @ifdef.empty?
+          parse_error "#else/#elif/#endif must not appear without preceding #if"
+        end
+        case s1
+        when 'else'
+          if @ifnest == 0
+            if @ifskip # true branch has already been parsed
+              @ifdef[@ifdef.size - 1] = false
+            else
+              @ifdef[@ifdef.size - 1] ^= true;
+              @ifskip = @ifdef.last
+            end
+          end
+        when 'endif'
+          if @ifnest == 0
+            @ifdef.pop
+            @ifskip = @ifdef.last
+          else
+            @ifnest -= 1
+          end
+        else
+          if @ifnest == 0
+            if @ifskip || @ifdef[@ifdef.size - 1]
+              # true branch has already been parsed so skip from now on
+              @ifdef[@ifdef.size - 1] = false
+              @ifskip = true
+            else
+              while s2 =~ /(^|[\W])defined\s*\(\s*(\w+)\s*\)/
+                 def_id = $2
+                 s2.gsub!(/(^|[\W])(defined\s*\(\s*\w+\s*\))/, '\1'+"#{@defined.has_key?(def_id).to_s}")
+              end
+              s2.gsub!(/(^|[\W])([A-Za-z_][\w]*)/) do |m_| "#{$1}#{resolve_define($2)}" end
+              begin
+                @ifdef[@ifdef.size - 1] = eval_directive(s2)
+                @ifskip = @ifdef[@ifdef.size - 1]
+              rescue IDL::ParseError
+                raise
+              rescue => ex
+                p ex
+                puts ex.backtrace.join("\n")
+                parse_error "error evaluating #elif"
+              end
+            end
+          end
+        end
+
+      elsif /(if|ifn?def)/ === s1
+
+        case s1
+        when /ifn?def/
+          if do_parse?
+            if not (/^(\w+)/ === s2)
+              parse_error "no #if(n)def target."
+            end
+            @ifdef.push(@defined[$1].nil? ^ (s1 == "ifdef"))
+            @ifskip = @ifdef.last
+          else
+            @ifnest += 1
+          end
+
+        when 'if'
+          if do_parse?
+            while s2 =~ /(^|[\W])defined\s*\(\s*(\w+)\s*\)/
+               def_id = $2
+               s2.gsub!(/(^|[\W])(defined\s*\(\s*\w+\s*\))/, '\1'+"#{@defined.has_key?(def_id).to_s}")
+            end
+            s2.gsub!(/(^|[\W])([A-Za-z_][\w]*)/) do |m_| "#{$1}#{resolve_define($2)}" end
+            begin
+              @ifdef.push(eval_directive(s2))
+              @ifskip = @ifdef.last
+            rescue IDL::ParseError
+              raise
+            rescue => ex
+              p ex
+              puts ex.backtrace.join("\n")
+              parse_error "error evaluating #if"
+            end
+          else
+            @ifnest += 1
+          end
+        end
+
+      elsif do_parse?
+
+        case s1
+        when 'pragma'
+          parse_pragma(s2)
+
+        when 'error'
+          parse_error(s2)
+
+        when 'define'
+          a = s2.split
+          a[1] = true if a[1].nil?
+          if a[0].nil?
+            parse_error "no #define target."
+          elsif not @defined[a[0]].nil?
+            parse_error "#{a[0]} is already #define-d."
+          end
+          @defined[a[0]] = a[1]
+
+        when 'undef'
+          @defined.delete(s2)
+
+        when 'include'
+          if s2[0,1] == '"' || s2[0,1] == '<'
+            if s2.size>2
+              s2.strip!
+              s2 = s2.slice(1..(s2.size-2))
+            else
+              s2 = ""
+            end
+          end
+          enter_include(s2)
+
+        when /[0-9]+/
+          # ignore line directive
+        else
+          parse_error "unknown directive: #{s}."
+        end
+      end
+    end
+
+    def parse_pragma(s)
+      case s
+      when /^ID\s+(.*)\s+"(.*)"\s*$/
+        @directiver.pragma_id($1.strip, $2)
+      when /^version\s+(.*)\s+([0-9]+)\.([0-9]+)\s*$/
+        @directiver.pragma_version($1.strip, $2, $3)
+      when /^prefix\s+"(.*)"\s*$/
+        @prefix = $1
+        @directiver.pragma_prefix(@prefix)
+      else
+        @directiver.handle_pragma(s)
+      end
+    end
+
+    def next_token
+      sign = nil
+      str = "" #initialize empty string
+      while TRUE
+        ch = @in.getc
+        if ch.nil?
+          if @ifdef.size>0 and !in_expansion?
+            parse_error "mismatched #if/#endif"
+          end
+          if more_source?
+            leave_source
+            next
+          else
+            return [FALSE, nil]
+          end
+        end
+
+        if WHITESPACE.include? ch
+          @in.skipwhile( WHITESPACE )
+          next
+        end
+
+        if str.empty? && ch == ?\#
+          parse_directive
+          next
+        end
+        unless do_parse?
+          skipline
+          next
+        end
+
+        str << ch
+        case
+        when BREAKCHARS.include?(ch)
+          if SHIFTCHARS.include?(ch) && @in.lookc == ch
+            # '<<' or '>>'
+            str << @in.getc
+          end
+          return [str, str]
+
+        when ch == ANNOTATION
+          if @in_annotation
+            return [str, str]
+          else
+            return parse_annotation()
+          end
+
+        when ch == ?: #
+          if @in.lookc == ?: #
+            @in.skipc
+            return ["::", "::"]
+          else
+            return [":", ":"]
+          end
+
+        when ch == ?L
+          _nxtc = @in.lookc
+          if _nxtc == ?\'  #' #single quote, for a character literal.
+            ret = 0
+            @in.skipc # skip 'L'
+            _nxtc = @in.lookc
+            if _nxtc == ?\\
+              @in.skipc
+              ret = next_escape_str
+            elsif _nxtc == ?\' #'
+              ret = [ nil, nil ]
+            else
+              ret = ''
+              ret << @in.getc
+              ret = [ :char, ret ]
+            end
+
+            if @in.lookc != ?\' #'
+              parse_error "wide character literal must be single wide character enclosed in \"'\""
+            end
+
+            @in.skipc
+            return [ :wide_character_literal, ret ]
+
+          elsif _nxtc == ?\" #" #double quote, for a string literal.
+            ret = []
+            chs = ''
+            @in.skipc # skip 'L'
+            while TRUE
+              _nxtc = @in.lookc
+              if _nxtc == ?\\
+                @in.skipc
+                ret << [:char, chs] unless chs.empty?
+                chs = ''
+                ret << next_escape_str
+              elsif _nxtc == ?\" #"
+                @in.skipc
+                ret << [:char, chs] unless chs.empty?
+                return [ :wide_string_literal, ret ]
+              else
+                chs << @in.getc
+              end
+            end
+
+          else
+            return next_identifier(ch)
+          end
+
+        when IDCHARS.include?(ch)
+          return next_identifier(ch)
+
+        when ch == ?/ #
+          _nxtc = @in.lookc
+          if _nxtc == ?*
+            # skip comment like a `/* ... */'
+            @in.skipc # forward stream beyond `/*'
+            ch1 = nil
+            @in.skipuntil { |ch_|
+              ch0 = ch1; ch1 = ch_
+              ch0 == ?* and ch1 == ?/ #
+            }
+            if @in.lookc.nil?
+              parse_error "cannot find comment closing brace (\'*/\'). "
+            end
+            @in.skipc
+            str = "" # reset
+            next
+
+          elsif _nxtc == ?/
+            # skip comment like a `// ...\n'
+            @in.skipc
+            unless @scan_comment  # scan_comment will be true when parsing commented annotations
+              _nxtc = @in.lookc
+              if _nxtc == ANNOTATION
+                @in.skipc
+                return parse_annotation(true)
+              else
+                @in.skipuntil(?\n, ?\r)
+              end
+            end
+            str = "" # reset
+            next
+
+          else
+            return [ "/", "/" ]
+          end
+
+        when ch == ?+ || ch == ?-
+          _nxtc = @in.lookc
+          if (?0..?9).include? _nxtc
+            sign = ch
+            str = "" # reset
+            next
+          else
+            return [str, str]
+          end
+
+        when (?1..?9).include?(ch)
+          @in.mark(sign, ch)
+          sign = nil
+          @in.skipwhile(?0..?9)
+          num_type = ([?., ?e, ?E, ?d, ?D].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
+
+          r = @in.getregion
+
+          if num_type == :floating_pt_literal
+            return [:floating_pt_literal, r.to_f]
+          elsif num_type == :fixed_pt_literal
+            return [:fixed_pt_literal, r]
+          else
+            return [:integer_literal, r.to_i]
+          end
+
+        when ch == ?. #
+          @in.mark(ch)
+          @in.skipwhile(?0..?9)
+          num_type = (?. != @in.lookc) ? skipfloat_or_fixed : nil
+          s = @in.getregion
+          if s == "."
+            parse_error "token consisting of single dot (.) is invalid."
+          end
+          if num_type == :floating_pt_literal
+            return [:floating_pt_literal, s.to_f]
+          elsif num_type == :fixed_pt_literal
+            return [:fixed_pt_literal, s]
+          else
+            parse_error "invalid floating point constant."
+          end
+
+        when ch == ?0
+          @in.mark(sign, ch)
+          sign = nil
+
+          _nxtc = @in.lookc
+          if _nxtc == ?x || _nxtc == ?X
+            @in.skipc
+            @in.skipwhile() { |ch_| HEXCHARS.include? ch_ }
+            s = @in.getregion
+            return [:integer_literal, s.hex]
+
+          else
+            dec = FALSE
+            @in.skipwhile(?0..?7)
+            if (?8..?9).include? @in.lookc
+              dec = TRUE
+              @in.skipwhile(?0..?9)
+            end
+
+            num_type = ([?., ?e, ?E, ?d, ?D].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
+
+            ret = nil
+            s = @in.getregion
+            if num_type == :floating_pt_literal
+              ret = [:floating_pt_literal, s.to_f]
+            elsif num_type == :fixed_pt_literal
+              ret = [:fixed_pt_literal, s]
+            elsif dec
+              parse_error "decimal literal starting with '0' should be octal ('0'..'7' only): #{s}"
+            else
+              ret = [:integer_literal, s.oct]
+            end
+            return ret
+          end
+
+        when ch == ?\'  #' #single quote, for a character literal.
+          ret = 0
+          _nxtc = @in.lookc
+          if _nxtc == ?\\
+            @in.skipc
+            ret = next_escape
+          elsif _nxtc == ?\' #'
+            ret = 0
+          elsif _nxtc
+            ret = ('' << @in.getc).unpack('C').first
+          end
+
+          if @in.lookc != ?\' #'
+            parse_error "character literal must be single character enclosed in \"'\""
+          end
+
+          @in.skipc
+          return [ :character_literal, ret ]
+
+        when ch == ?\" #" #double quote, for a string literal.
+          ret = ""
+          while TRUE
+            _nxtc = @in.lookc
+            if _nxtc == ?\\
+              @in.skipc
+              ret << next_escape
+            elsif _nxtc == ?\" #"
+              @in.skipc
+              return [ :string_literal, ret ]
+            elsif _nxtc
+              ret << @in.getc
+            else
+              parse_error "unterminated string literal"
+            end
+          end
+
+        else
+          parse_error 'illegal character [' << ch << ']'
+
+        end #of case
+
+      end #of while
+      parse_error "unexcepted error"
+    end #of method next_token
+  end
+
+end