ridl 2.2.5 → 2.5.5

data/lib/ridl/scanner.rb

@@ -21,9 +21,9 @@ module IDL
       @positions = positions
     end
     def inspect
-      puts self.class.name+": "+message
+      puts "#{self.class.name}: #{message}"
       @positions.each { |pos|
-        print "    "
+        print '    '
         puts pos
       }
       nil
@@ -35,7 +35,7 @@ module IDL
 
     class Position
       def to_s
-        format("%s: line %d, column %d", name.to_s, line, column)
+        format('%s: line %d, column %d', name.to_s, line, column)
       end
       def inspect
         to_s
@@ -88,7 +88,7 @@ module IDL
       def gets
         return nil if @fwd.nil?
 
-        s = ""
+        s = ''
         s << getc until [nil, ?\n, ?\r].include? lookc
         s << getc while [?\n, ?\r].include? lookc
 
@@ -112,7 +112,7 @@ module IDL
               false
             end
         }
-        return false
+        false
       end
 
       def skipwhile(*chars, &block)
@@ -140,7 +140,7 @@ module IDL
       end
 
       def mark(*ini)
-        @mark = ""
+        @mark = ''
         ini.each { |i|
           case i
           when nil
@@ -157,25 +157,25 @@ module IDL
       def getregion
         ret = @mark
         @mark = nil
-        return ret
+        ret
       end
     end ## of class In
 
     class StrIStream
       def initialize(src)
         @src = src
-        @i = 0
+        @ix = 0
       end
       def to_s
         @src
       end
       def getc
-        ch = @src[@i]
-        @i += 1
+        ch = @src[@ix]
+        @ix += 1
         ch
       end
       def close
-        @i = 0
+        @ix = 0
       end
     end ## of class StrIStream
 
@@ -213,19 +213,23 @@ module IDL
     # name
     class Identifier < DelegateClass(::String)
       attr_reader :checked_name
-      def initialize(idl_id, checked_id)
+      attr_reader :unescaped_name
+      def initialize(idl_id, checked_id, unescaped_idl_id = nil)
         super(idl_id)
         @checked_name = checked_id
+        @unescaped_name = unescaped_idl_id || idl_id
       end
     end
 
     # Scanner
     def initialize(src, directiver, params = {})
       @includepaths = params[:includepaths] || []
+      @xincludepaths = params[:xincludepaths] || []
       @stack = []
       @expansions = []
       @prefix = nil
       @directiver = directiver
+      @directiver.instance_variable_get('@d').instance_variable_set('@scanner', self)
       @defined = TokenRegistry.new
       # initialize with predefined macros
       if params[:macros]
@@ -255,35 +259,53 @@ module IDL
       @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)
+    def find_include(fname, all = true)
+      if File.file?(fname) && File.readable?(fname)
         fname
       else
+        # search transient include paths if allowed (quoted includes)
+        fp = if all then
+               @xincludepaths.find do |p|
+                 f = p + '/' + fname
+                 File.file?(f) && File.readable?(f)
+               end
+             else
+               nil
+             end
+        # search system include paths if still needed
         fp = @includepaths.find do |p|
-          f = p + "/" + fname
+          f = p + '/' + fname
           File.file?(f) && File.readable?(f)
-        end
-        fp += '/' + fname if !fp.nil?
+        end unless fp
+        fp += '/' + fname if fp
         fp
       end
     end
-    def enter_include(src)
+
+    def position
+      @in.position
+    end
+
+    def enter_include(src, all = true)
       if @directiver.is_included?(src)
         @directiver.declare_include(src)
       else
-        fpath = find_include(src)
+        fpath = find_include(src, all)
         if fpath.nil?
           parse_error "Cannot open include file '#{src}'"
         end
         @stack << [:include, @prefix, @ifdef, @in, @ifskip]
+        # record file dir as new searchpath
+        @xincludepaths << File.dirname(fpath)
         @prefix = nil
         @ifdef = Array.new
         @in = In.new(File.open(fpath, 'r'), fpath)
-        @directiver.enter_include(src)
+        @directiver.enter_include(src, fpath)
         @directiver.pragma_prefix(nil)
       end
     end
     def enter_expansion(src, define)
+      IDL.log(2, "** RIDL - enter_expansion > #{define} = #{src}")
       @stack << [:define, nil, nil, @in, nil]
       @expansions << define
       @in = In.new(StrIStream.new(src), @in.position.name, @in.position.line, @in.position.column)
@@ -297,14 +319,15 @@ module IDL
     def in_expansion?
       more_source? and @stack.last[0] == :define
     end
-    def leave_source()
+    def leave_source
       if @stack.size>0
         if @stack.last[0] == :include
+          @xincludepaths.pop # remove directory of finished include
           @directiver.leave_include
-          type, @prefix, @ifdef, @in, @ifskip = @stack.pop
+          _, @prefix, @ifdef, @in, @ifskip = @stack.pop
           @directiver.pragma_prefix(@prefix)
         else
-          type, prefix_, ifdef_, @in, elsif_ = @stack.pop
+          _, _, _, @in, _ = @stack.pop
           @expansions.pop
         end
       end
@@ -313,7 +336,7 @@ module IDL
       @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 }
+      @stack.reverse.inject(@in.nil? ? [] : [@in.position]) {|pos_arr,(_, _, _,in_, _)| pos_arr << in_.position }
     end
     def parse_error(msg, ex = nil)
       e = IDL::ParseError.new(msg, positions)
@@ -364,45 +387,46 @@ module IDL
       :boolean_literal ]
 
     BOOL_LITERALS = {
-        'false' => false,
-        'true' => true
+        :false => false,
+        :true => true
       }
 
     def is_literal?(o)
-      return LITERALS.include?(o)
+      LITERALS.include?(o)
     end
 
-    def extract_annotation_value()
-      annotation_value = nil
+    def extract_annotation_value
       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()
+          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
+        member_annotation_id = token.last.to_s
         # get nested body
-        token, member_annotation_body = extract_annotation()
+        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 }
+        annotation_value = if member_annotation_body
+          { member_annotation_id => member_annotation_body }
         else  # otherwise it is a symbolic value
-          annotation_value = member_annotation_id.to_sym
+          member_annotation_id.to_sym
         end
+        # get next token if needed
+        token = next_token unless token
       else
         parse_error 'invalid annotation member' unless is_literal?(token.first)
         annotation_value = token.last
         token = next_token
       end
-      return [token, annotation_value]
+      [token, annotation_value]
     end
 
-    def extract_annotation()
+    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
@@ -422,17 +446,18 @@ module IDL
               annotation_body = { :value => s1 }
             else
               parse_error 'invalid annotation member' unless token.first == '='
-              token, annotation_value = extract_annotation_value()
+              token, annotation_value = extract_annotation_value
               parse_error 'invalid annotation body' unless token.first == ',' || token.first == ')'
-              (annotation_body ||= {})[s1] = annotation_value
+              (annotation_body ||= {})[s1.to_s] = annotation_value
             end
           end
         end until token.first == ')'
-        token = next_token # need to get next token
+#        token = next_token # need to get next token
+        token = nil
       else
         # marker annotation or symbolic value; leave body nil
       end
-      return [token, annotation_body]
+      [token, annotation_body]
     end
 
     def parse_annotation(in_comment = false)
@@ -441,30 +466,31 @@ module IDL
       begin
         # parse (possibly multiple) annotation(s)
         begin
+          annotation_position = self.position.dup
           # 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()
+          annotation_id = token.last.to_s
+          token, annotation_body = extract_annotation
           # pass annotation to directiver for processing
-          @directiver.define_annotation(annotation_id, annotation_body || {})
-        end until token.first != ANNOTATION_STR
+          @directiver.define_annotation(annotation_id, annotation_position, in_comment, annotation_body || {})
+        end until token.nil? || token.first != ANNOTATION_STR
       ensure
         @in_annotation = false
         @scan_comment = false
       end
       # check identifier for keywords
-      if token.first == :identifier
+      if token && token.first == :identifier
         # keyword check
-        if (a = KEYWORDS.assoc(token.last)).nil?
-          token = [ :identifier, Identifier.new(token.last, chk_identifier(token.last)) ]
+        if (a = KEYWORDS.assoc(token.last.to_s)).nil?
+          token = [ :identifier, Identifier.new(token.last.to_s, chk_identifier(token.last.to_s), token.last.unescaped_name) ]
         elsif token.last == a[1]
           token = [ a[1], nil ]
         else
-          parse_error "`#{token.last}' collides with a keyword `#{a[1]}'"
+          parse_error "'#{token.last}' collides with a keyword '#{a[1]}'"
         end
       end
-      return token
+      token
     end
 
     def next_identifier(first = nil)
@@ -479,26 +505,29 @@ module IDL
           break
         end
       end
-      s0 = @in.getregion
-      s1 = s0.downcase
+      s0 = @in.getregion        # raw IDL id
+      s1 = s0.downcase.to_sym   # downcased symbolized
+      s2 = s0.dup               # (to be) unescaped id
 
       # simple check
-      if (s0.length == 0)
-        parse_error "identifier expected!"
+      escape = false
+      if s2.length == 0
+        parse_error 'identifier expected!'
       else
-        case s0[0]
+        case s2[0]
         when ?a..?z, ?A..?Z
         when ?_   ## if starts with CORBA IDL escape => remove
-          s0.slice!(0)
+          escape = true
+          s2.slice!(0)
         else
-          parse_error "identifier must begin with alphabet character: #{s0}"
+          parse_error "identifier must begin with alphabet character: #{s2}"
         end
       end
 
       # preprocessor check
-      if @defined.has_key?(s0) and !is_expanded?(s0)
+      if @defined.has_key?(s2) and !is_expanded?(s2)
         # enter expansion as new source
-        enter_expansion(@defined[s0], s0)
+        enter_expansion(@defined[s2], s2)
         # call next_token to parse expanded source
         next_token
       # keyword check
@@ -506,16 +535,16 @@ module IDL
         if BOOL_LITERALS.has_key?(s1)
           [ :boolean_literal, BOOL_LITERALS[s1] ]
         else
-          [ :identifier, s0 ]
+          [ :identifier, Identifier.new(s2, s2, 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)) ]
+        [ :identifier, Identifier.new(s2, escape ? s2 : chk_identifier(s2), s0) ]
       elsif s0 == a[1]
         [ a[1], nil ]
       else
-        parse_error "`#{s0}' collides with a keyword `#{a[1]}'"
+        parse_error "'#{s0}' collides with IDL keyword '#{a[1]}'"
       end
     end
 
@@ -525,7 +554,7 @@ module IDL
       when nil
         parse_error 'illegal escape sequence'
       when ?0..?7
-        ret = ""
+        ret = ''
         ret << ch
         1.upto(2) {
           ch = @in.lookc
@@ -538,7 +567,7 @@ module IDL
         }
         ret = ret.oct
       when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
-        ret = ""
+        ret = ''
         1.upto(2) {
           ch = @in.lookc
           if HEXCHARS.include? ch
@@ -550,7 +579,7 @@ module IDL
         }
         ret = ret.hex
       when ?u
-        ret = ""
+        ret = ''
         1.upto(4) {
           ch = @in.lookc
           if HEXCHARS.include? ch
@@ -566,7 +595,7 @@ module IDL
       else
         ret = ('' << ch).unpack('C').first
       end
-      return ret
+      ret
     end
 
     def next_escape_str(keep_type_ch = false)
@@ -575,7 +604,7 @@ module IDL
       when nil
         parse_error 'illegal escape sequence'
       when ?0..?7
-        ret = ""
+        ret = ''
         ret << ch
         1.upto(2) {
           ch = @in.lookc
@@ -588,7 +617,7 @@ module IDL
         }
         ret = [ :oct, ret ]
       when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
-        ret = ""
+        ret = ''
         ret << ch if keep_type_ch
         1.upto(2) {
           ch = @in.lookc
@@ -601,7 +630,7 @@ module IDL
         }
         ret = [ :hex2, ret ]
       when ?u
-        ret = ""
+        ret = ''
         ret << ch if keep_type_ch
         1.upto(4) {
           ch = @in.lookc
@@ -622,11 +651,11 @@ module IDL
         ret << ch
         ret = [ :esc_ch, ch ]
       end
-      return ret
+      ret
     end
 
     def skipfloat_or_fixed
-      if (@in.lookc == ?.)
+      if @in.lookc == ?.
         @in.skipc
         @in.skipwhile(?0..?9)
       end
@@ -641,7 +670,7 @@ module IDL
         @in.skipwhile(?0..?9)
         return :fixed_pt_literal
       end
-      return :floating_pt_literal
+      :floating_pt_literal
     end
 
     def skipline
@@ -653,7 +682,7 @@ module IDL
     end
 
     def getline
-      s = ""
+      s = ''
       while TRUE
         ch = @in.lookc
         break if ch.nil?
@@ -664,7 +693,7 @@ module IDL
             if @in.lookc == ?\\
               # escape sequence
               s << @in.getc
-              esctyp, escstr = next_escape_str(true)
+              _, escstr = next_escape_str(true)
               s << escstr
             elsif @in.lookc == ?\" #"
               break
@@ -672,7 +701,7 @@ module IDL
               # normal character
               s << @in.getc
             else
-              parse_error "unterminated string literal"
+              parse_error 'unterminated string literal'
             end
           end
           s << @in.getc # closing quote
@@ -681,7 +710,7 @@ module IDL
           if @in.lookc == ?\\
             # escape sequence
             s << @in.getc
-            esctyp, escstr = next_escape_str(true)
+            _, escstr = next_escape_str(true)
             s << escstr
           elsif @in.lookc && @in.lookc != ?\' #'
             # normal character
@@ -692,7 +721,7 @@ module IDL
           end
           s << @in.getc # closing quote
         when LFCR.include?(ch)
-          @in.skipwhile() { |ch_| LFCR.include? ch_ }
+          @in.skipwhile { |ch_| LFCR.include? ch_ }
           break
         when ch == ?/
           @in.skipc
@@ -718,7 +747,7 @@ module IDL
           @in.skipc
           if LFCR.include?(@in.lookc)
             # line continuation
-            @in.skipwhile() { |ch_| LFCR.include? ch_ }
+            @in.skipwhile { |ch_| LFCR.include? ch_ }
             if @in.lookc.nil?
               parse_error "line continuation character ('\\') not allowed as last character in file."
             end
@@ -734,14 +763,14 @@ module IDL
     end
 
     def resolve_define(id, stack = [])
-      return id if ['true', 'false'].include?(id)
+      return id if %w(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
+        define_.gsub(/(^|[\W])([A-Za-z_][\w]*)/) do |_| "#{$1}#{resolve_define($2, stack)}" end
       else
         '0' # unknown id
       end
@@ -756,7 +785,7 @@ module IDL
       when Numeric
         rc != 0
       else
-        parse_error "invalid preprocessor expression."
+        parse_error 'invalid preprocessor expression.'
       end
     end
 
@@ -769,7 +798,7 @@ module IDL
       if /(else|endif|elif)/ === s1
 
         if @ifdef.empty?
-          parse_error "#else/#elif/#endif must not appear without preceding #if"
+          parse_error '#else/#elif/#endif must not appear without preceding #if'
         end
         case s1
         when 'else'
@@ -777,7 +806,7 @@ module IDL
             if @ifskip # true branch has already been parsed
               @ifdef[@ifdef.size - 1] = false
             else
-              @ifdef[@ifdef.size - 1] ^= true;
+              @ifdef[@ifdef.size - 1] ^= true
               @ifskip = @ifdef.last
             end
           end
@@ -799,7 +828,7 @@ module IDL
                  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
+              s2.gsub!(/(^|[\W])([A-Za-z_][\w]*)/) do |_| "#{$1}#{resolve_define($2)}" end
               begin
                 @ifdef[@ifdef.size - 1] = eval_directive(s2)
                 @ifskip = @ifdef[@ifdef.size - 1]
@@ -808,7 +837,7 @@ module IDL
               rescue => ex
                 p ex
                 puts ex.backtrace.join("\n")
-                parse_error "error evaluating #elif"
+                parse_error 'error evaluating #elif'
               end
             end
           end
@@ -816,25 +845,26 @@ module IDL
 
       elsif /(if|ifn?def)/ === s1
 
-        case s1
-        when /ifn?def/
+        if /ifn?def/ === s1
           if do_parse?
-            if not (/^(\w+)/ === s2)
-              parse_error "no #if(n)def target."
-            end
-            @ifdef.push(@defined[$1].nil? ^ (s1 == "ifdef"))
+            parse_error 'no #if(n)def target.' unless /^(\w+)/ === s2
+            @ifdef.push(@defined[$1].nil? ^ (s1 == 'ifdef'))
             @ifskip = @ifdef.last
           else
             @ifnest += 1
           end
 
-        when 'if'
+        else # 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}")
+            # match 'defined(Foo)' or 'defined Foo'
+            while s2 =~ /(^|[\W])defined(\s*\(\s*(\w+)\s*\)|\s+(\w+))/
+              IDL.log(2,"** RIDL - parse_directive : resolving 'defined(#{$3 || $4})'")
+              def_id = $3 || $4
+              # resolve 'defined' expression to 'true' or 'false' according to actual macro definition
+              s2.gsub!(/(^|[\W])(defined\s*[\s\(]\s*#{def_id}(\s*\))?)/, '\1'+"#{@defined.has_key?(def_id).to_s}")
             end
-            s2.gsub!(/(^|[\W])([A-Za-z_][\w]*)/) do |m_| "#{$1}#{resolve_define($2)}" end
+            # match and resolve any macro variables listed in conditional expression
+            s2.gsub!(/(^|[\W])([A-Za-z_][\w]*)/) do |_| "#{$1}#{resolve_define($2)}" end
             begin
               @ifdef.push(eval_directive(s2))
               @ifskip = @ifdef.last
@@ -843,7 +873,7 @@ module IDL
             rescue => ex
               p ex
               puts ex.backtrace.join("\n")
-              parse_error "error evaluating #if"
+              parse_error 'error evaluating #if'
             end
           else
             @ifnest += 1
@@ -860,28 +890,27 @@ module IDL
           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]
+          defid = s2.split.first
+          parse_error 'no #define target.' unless defid
+          parse_error "#{defid} is already #define-d." if @defined[defid]
+          defval = s2.sub(/^\s*#{defid}/, '').strip
+          defval = true if defval.empty?
+          @defined[defid] = defval
 
         when 'undef'
           @defined.delete(s2)
 
         when 'include'
           if s2[0,1] == '"' || s2[0,1] == '<'
+            quoted_inc = (s2[0,1] == '"')
             if s2.size>2
               s2.strip!
               s2 = s2.slice(1..(s2.size-2))
             else
-              s2 = ""
+              s2 = ''
             end
           end
-          enter_include(s2)
+          enter_include(s2, quoted_inc)
 
         when /[0-9]+/
           # ignore line directive
@@ -907,12 +936,12 @@ module IDL
 
     def next_token
       sign = nil
-      str = "" #initialize empty string
+      str = '' #initialize empty string
       while TRUE
         ch = @in.getc
         if ch.nil?
           if @ifdef.size>0 and !in_expansion?
-            parse_error "mismatched #if/#endif"
+            parse_error 'mismatched #if/#endif'
           end
           if more_source?
             leave_source
@@ -949,32 +978,30 @@ module IDL
           if @in_annotation
             return [str, str]
           else
-            return parse_annotation()
+            # return token returned by parse_annotation or parse next token recursively
+            return parse_annotation || next_token
           end
 
         when ch == ?: #
           if @in.lookc == ?: #
             @in.skipc
-            return ["::", "::"]
+            return %w(:: ::)
           else
-            return [":", ":"]
+            return %w(: :)
           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 == ?\\
+            ret = if _nxtc == ?\\
               @in.skipc
-              ret = next_escape_str
+              next_escape_str
             elsif _nxtc == ?\' #'
-              ret = [ nil, nil ]
+              [ nil, nil ]
             else
-              ret = ''
-              ret << @in.getc
-              ret = [ :char, ret ]
+              [ :char, '' << @in.getc ]
             end
 
             if @in.lookc != ?\' #'
@@ -1025,7 +1052,7 @@ module IDL
               parse_error "cannot find comment closing brace (\'*/\'). "
             end
             @in.skipc
-            str = "" # reset
+            str = '' # reset
             next
 
           elsif _nxtc == ?/
@@ -1035,23 +1062,24 @@ module IDL
               _nxtc = @in.lookc
               if _nxtc == ANNOTATION
                 @in.skipc
-                return parse_annotation(true)
+                # return token returned by parse_annotation or parse next token recursively
+                return parse_annotation(true) || next_token
               else
                 @in.skipuntil(?\n, ?\r)
               end
             end
-            str = "" # reset
+            str = '' # reset
             next
 
           else
-            return [ "/", "/" ]
+            return %w(/ /)
           end
 
         when ch == ?+ || ch == ?-
           _nxtc = @in.lookc
           if (?0..?9).include? _nxtc
             sign = ch
-            str = "" # reset
+            str = '' # reset
             next
           else
             return [str, str]
@@ -1059,7 +1087,6 @@ module IDL
 
         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
 
@@ -1078,28 +1105,26 @@ module IDL
           @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."
+          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."
+            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_ }
+            @in.skipwhile { |ch_| HEXCHARS.include? ch_ }
             s = @in.getregion
             return [:integer_literal, s.hex]
-
           else
             dec = FALSE
             @in.skipwhile(?0..?7)
@@ -1110,30 +1135,28 @@ module IDL
 
             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]
+            ret = if num_type == :floating_pt_literal
+              [:floating_pt_literal, s.to_f]
             elsif num_type == :fixed_pt_literal
-              ret = [:fixed_pt_literal, s]
+              [: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]
+              [:integer_literal, s.oct]
             end
             return ret
           end
 
         when ch == ?\'  #' #single quote, for a character literal.
-          ret = 0
           _nxtc = @in.lookc
-          if _nxtc == ?\\
+          ret = if _nxtc == ?\\
             @in.skipc
-            ret = next_escape
+            next_escape
           elsif _nxtc == ?\' #'
-            ret = 0
+            0
           elsif _nxtc
-            ret = ('' << @in.getc).unpack('C').first
+            ('' << @in.getc).unpack('C').first
           end
 
           if @in.lookc != ?\' #'
@@ -1144,7 +1167,7 @@ module IDL
           return [ :character_literal, ret ]
 
         when ch == ?\" #" #double quote, for a string literal.
-          ret = ""
+          ret = ''
           while TRUE
             _nxtc = @in.lookc
             if _nxtc == ?\\
@@ -1156,7 +1179,7 @@ module IDL
             elsif _nxtc
               ret << @in.getc
             else
-              parse_error "unterminated string literal"
+              parse_error 'unterminated string literal'
             end
           end
 
@@ -1166,7 +1189,7 @@ module IDL
         end #of case
 
       end #of while
-      parse_error "unexcepted error"
+      parse_error 'unexcepted error'
     end #of method next_token
   end