ridl 2.8.2 → 2.10.0

data/lib/ridl/scanner.rb

@@ -14,10 +14,12 @@ require 'delegate'
 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|
@@ -35,6 +37,7 @@ module IDL
       def to_s
         format('%s: line %d, column %d', name.to_s, line, column)
       end
+
       def inspect
         to_s
       end
@@ -48,15 +51,20 @@ module IDL
         @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 to_s
+        @src.to_s
+      end
 
       def lookc
         @fwd
@@ -66,8 +74,8 @@ module IDL
         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
+        if [nil, "\n", "\r"].include? @bwd
+          if @bwd == "\r" and cur == "\n"
           else
             @pos.line += 1
             @pos.column = 1
@@ -75,13 +83,6 @@ module IDL
         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
 
@@ -89,28 +90,30 @@ module IDL
         return nil if @fwd.nil?
 
         s = ''
-        s << getc until [nil, ?\n, ?\r].include? lookc
-        s << getc while [?\n, ?\r].include? lookc
+        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 skipwhile(*chars, &block)
+      def skipwhile(*_chars, &block)
         if block
           until (ch = lookc).nil?
             return ch unless block.call(ch)
+
             skipc
           end
         end
         nil
       end
 
-      def skipuntil(*chars, &block)
+      def skipuntil(*_chars, &block)
         if block
           until (ch = lookc).nil?
             return ch if block.call(ch)
+
             skipc
           end
         end
@@ -148,14 +151,17 @@ module IDL
         @src = src
         @ix = 0
       end
+
       def to_s
         @src
       end
+
       def getc
         ch = @src[@ix]
         @ix += 1
         ch
       end
+
       def close
         @ix = 0
       end
@@ -165,15 +171,19 @@ module IDL
       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
@@ -184,6 +194,7 @@ module IDL
       def initialize(table_)
         @table = table_
       end
+
       def [](key)
         key = (::Integer === key) ? key.chr.to_sym : key.to_sym
         @table[key]
@@ -194,8 +205,8 @@ module IDL
     # to carry both 'raw' IDL name as well as language mapped
     # name
     class Identifier < DelegateClass(::String)
-      attr_reader :checked_name
-      attr_reader :unescaped_name
+      attr_reader :checked_name, :unescaped_name
+
       def initialize(idl_id, checked_id, unescaped_idl_id = nil)
         super(idl_id)
         @checked_name = checked_id
@@ -203,10 +214,67 @@ module IDL
       end
     end
 
+    LFCR = [ ("\n"), ("\r") ]
+    SPACES = [ ("\ "), ("\t") ]
+    WHITESPACE = SPACES + LFCR
+
+    ANNOTATION = '@'
+    ANNOTATION_STR = '@'
+
+    BREAKCHARS = [
+      '(', ')', '[', ']', '{', '}',
+      '^', '~',
+      '*', '%', '&', '|',
+      '<', '=', '>',
+      ',', ';' ]
+
+    SHIFTCHARS = [ '<', '>' ]
+
+    DIGITS = ('0'..'9').to_a
+    ALPHA_LC = ('a'..'z').to_a
+    ALPHA_UC = ('A'..'Z').to_a
+    OCTALS = ('0'..'7').to_a
+    HEXCHARS = DIGITS + ('a'..'f').to_a + ('A'..'F').to_a
+    SIGNS = ['-', '+']
+    DOT = '.'
+
+    IDCHARS = ['_' ] + ALPHA_LC + ALPHA_UC
+    FULL_IDCHARS = IDCHARS + DIGITS
+
+    ESCTBL = CharRegistry.new({
+      n: "\n", t: "\t", v: "\v", b: "\b",
+      r: "\r", f: "\f", a: "\a"
+    })
+
+    KEYWORDS = %w(
+      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
+      }
+
     # Scanner
     def initialize(src, directiver, params = {})
       @includepaths = params[:includepaths] || []
       @xincludepaths = params[:xincludepaths] || []
+      @idlversion = params[:idlversion]
       @stack = []
       @expansions = []
       @prefix = nil
@@ -219,7 +287,7 @@ module IDL
           @defined[name] = value
         end
       end
-      @ifdef = Array.new
+      @ifdef = []
       @ifskip = false
       @ifnest = 0
       i = nil
@@ -240,7 +308,15 @@ module IDL
       @in = In.new(i, nm)
       @scan_comment = false # true if parsing commented annotation
       @in_annotation = false # true if parsing annotation
+
+      # Extend the IDL keywords with IDL4 when enabled
+      if @idlversion >= 4
+        %w(bitfield bitmask bitset map int8 int16 int32 int64 uint8 uint16 uint32 uint64
+    ).inject(KEYWORDS) { |h, a| h[a.downcase.to_sym] = a
+h }
+      end
     end
+
     def find_include(fname, all = true)
       if File.file?(fname) && File.readable?(fname)
         File.expand_path(fname)
@@ -261,6 +337,7 @@ module IDL
         fp
       end
     end
+
     def check_include(path, fname)
       fp = path + fname
       File.file?(fp) && File.readable?(fp)
@@ -282,32 +359,37 @@ module IDL
         # record file dir as new searchpath
         @xincludepaths << (File.dirname(fpath) + '/')
         @prefix = nil
-        @ifdef = Array.new
+        @ifdef = []
         @in = In.new(File.open(fpath, 'r'), fpath)
         @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)
     end
+
     def is_expanded?(define)
       @expansions.include?(define)
     end
+
     def more_source?
-      @stack.size > 0
+      !@stack.empty?
     end
+
     def in_expansion?
       more_source? and @stack.last[0] == :define
     end
+
     def leave_source
       # make sure to close the input source
       @in.close
       # check if we have any previous source still stacked up
-      if @stack.size > 0
+      unless @stack.empty?
         if @stack.last[0] == :include
           @xincludepaths.pop # remove directory of finished include
           @directiver.leave_include
@@ -319,73 +401,21 @@ module IDL
         end
       end
     end
+
     def do_parse?
       @ifdef.empty? || @ifdef.last
     end
+
     def positions
-      @stack.reverse.inject(@in.nil? ? [] : [@in.position]) {|pos_arr, (_, _, _, in_, _)| 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)
       e.set_backtrace(ex.backtrace) unless ex.nil?
       raise e
     end
 
-    LFCR = [ (?\n), (?\r) ]
-    SPACES = [ (?\ ), (?\t) ]
-    WHITESPACE = SPACES + LFCR
-
-    ANNOTATION = ?@
-    ANNOTATION_STR = '@'
-
-    BREAKCHARS = [
-      ?(, ?), ?[, ?], ?{, ?},
-      ?^, ?~,
-      ?*, ?%, ?&, ?|,
-      ?<, ?=, ?>,
-      ?,, ?; ]
-
-    SHIFTCHARS = [ ?<, ?> ]
-
-    DIGITS = (?0..?9).to_a
-    ALPHA_LC = (?a..?z).to_a
-    ALPHA_UC = (?A..?Z).to_a
-    OCTALS = (?0..?7).to_a
-    HEXCHARS = DIGITS + (?a..?f).to_a + (?A..?F).to_a
-    SIGNS = [?-, ?+]
-    DOT = ?.
-
-    IDCHARS = [?_ ] + ALPHA_LC + ALPHA_UC
-    FULL_IDCHARS = IDCHARS + DIGITS
-
-    ESCTBL = CharRegistry.new({
-      :n => ?\n, :t => ?\t, :v => ?\v, :b => ?\b,
-      :r => ?\r, :f => ?\f, :a => ?\a
-    })
-
-    KEYWORDS = %w(
-      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)
       LITERALS.include?(o)
     end
@@ -408,7 +438,7 @@ module IDL
         # determin vaue type; if it has a body it is an annotation instance
         annotation_value = if member_annotation_body
           { member_annotation_id => member_annotation_body }
-        else  # otherwise it is a symbolic value
+        else # otherwise it is a symbolic value
           member_annotation_id.to_sym
         end
         # get next token if needed
@@ -439,7 +469,7 @@ module IDL
             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 }
+              annotation_body = { value: s1 }
             else
               parse_error 'invalid annotation member' unless token.first == '='
               token, annotation_value = extract_annotation_value
@@ -479,9 +509,9 @@ module IDL
       if token&.first == :identifier
         # keyword check
         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) ]
+          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 ]
+          token = [a[1], nil]
         else
           parse_error "'#{token.last}' collides with a keyword '#{a[1]}'"
         end
@@ -494,7 +524,7 @@ module IDL
     end
 
     def skip_spaces
-      @in.skipwhile {|c| SPACES.include?(c) }
+      @in.skipwhile { |c| SPACES.include?(c) }
     end
 
     def next_identifier(first = nil)
@@ -511,10 +541,10 @@ module IDL
       s2 = s0.dup               # (to be) unescaped id
 
       # simple check
-      if s2.length == 0
+      if s2.empty?
         parse_error 'identifier expected!'
       else
-        if s2[0] == ?_
+        if s2[0] == '_'
           s2.slice!(0) ## if starts with CORBA IDL escape => remove
         end
         parse_error "identifier must begin with alphabet character: #{s2}" unless ALPHA_LC.include?(s2[0]) || ALPHA_UC.include?(s2[0])
@@ -529,15 +559,15 @@ module IDL
       # keyword check
       elsif @in_annotation
         if BOOL_LITERALS.has_key?(s1)
-          [ :boolean_literal, BOOL_LITERALS[s1] ]
+          [:boolean_literal, BOOL_LITERALS[s1]]
         else
-          [ :identifier, Identifier.new(s2, s2, s0) ]
+          [:identifier, Identifier.new(s2, s2, s0)]
         end
       elsif (a = KEYWORDS.assoc(s1)).nil?
         # check for language mapping keyword
-        [ :identifier, Identifier.new(s2, chk_identifier(s2), s0) ]
+        [:identifier, Identifier.new(s2, chk_identifier(s2), s0)]
       elsif s0 == a[1]
-        [ a[1], nil ]
+        [a[1], nil]
       else
         parse_error "'#{s0}' collides with IDL keyword '#{a[1]}'"
       end
@@ -548,12 +578,12 @@ module IDL
       case (ch = @in.getc)
       when nil
         parse_error 'illegal escape sequence'
-      when ?0..?7
+      when '0'..'7'
         ret = ''
         ret << ch
         1.upto(2) {
           ch = @in.lookc
-          if (?0..?7).include? ch
+          if ('0'..'7').include? ch
             ret << ch
           else
             break
@@ -561,7 +591,7 @@ module IDL
           @in.skipc
         }
         ret = ret.oct
-      when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
+      when 'x' # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
         ret = ''
         1.upto(2) {
           ch = @in.lookc
@@ -573,7 +603,7 @@ module IDL
           @in.skipc
         }
         ret = ret.hex
-      when ?u
+      when 'u'
         ret = ''
         1.upto(4) {
           ch = @in.lookc
@@ -585,7 +615,7 @@ module IDL
           @in.skipc
         }
         ret = ret.hex
-      when ?n, ?t, ?v, ?b, ?r, ?f, ?a
+      when 'n', 't', 'v', 'b', 'r', 'f', 'a'
         ret = ESCTBL[ch]
       else
         ret = ('' << ch).unpack('C').first
@@ -598,12 +628,12 @@ module IDL
       case (ch = @in.getc)
       when nil
         parse_error 'illegal escape sequence'
-      when ?0..?7
+      when '0'..'7'
         ret = ''
         ret << ch
         1.upto(2) {
           ch = @in.lookc
-          if (?0..?7).include? ch
+          if ('0'..'7').include? ch
             ret << ch
           else
             break
@@ -611,7 +641,7 @@ module IDL
           @in.skipc
         }
         ret = [ :oct, ret ]
-      when ?x # i'm not sure '\x' should be 0 or 'x'. currently returns 0.
+      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) {
@@ -624,7 +654,7 @@ module IDL
           @in.skipc
         }
         ret = [ :hex2, ret ]
-      when ?u
+      when 'u'
         ret = ''
         ret << ch if keep_type_ch
         1.upto(4) {
@@ -637,14 +667,14 @@ module IDL
           @in.skipc
         }
         ret = [ :hex4, ret ]
-      when ?n, ?t, ?v, ?b, ?r, ?f, ?a
+      when 'n', 't', 'v', 'b', 'r', 'f', 'a'
         ret = ''
         ret << ch
-        ret = [ :esc, ret ]
+        ret = [:esc, ret]
       else
         ret = ''
         ret << ch
-        ret = [ :esc_ch, ch ]
+        ret = [:esc_ch, ch]
       end
       ret
     end
@@ -652,17 +682,17 @@ module IDL
     def skipfloat_or_fixed
       if @in.lookc == DOT
         @in.skipc
-        @in.skipwhile {|c| DIGITS.include?(c) }
+        @in.skipwhile { |c| DIGITS.include?(c) }
       end
-      if [?e, ?E].include? @in.lookc
+      if ['e', 'E'].include? @in.lookc
         @in.skipc
         @in.skipc if SIGNS.include? @in.lookc
-        @in.skipwhile {|c| DIGITS.include?(c) }
+        @in.skipwhile { |c| DIGITS.include?(c) }
         return :floating_pt_literal
-      elsif [?d, ?D].include? @in.lookc
+      elsif ['d', 'D'].include? @in.lookc
         @in.skipc
         @in.skipc if SIGNS.include? @in.lookc
-        @in.skipwhile {|c| DIGITS.include?(c) }
+        @in.skipwhile { |c| DIGITS.include?(c) }
         return :fixed_pt_literal
       end
       :floating_pt_literal
@@ -672,7 +702,7 @@ module IDL
       while true
         s = @in.gets
         until s.chomp!.nil?; end
-        break unless s[s.length - 1] == ?\\
+        break unless s[s.length - 1] == "\\"
       end
     end
 
@@ -681,16 +711,17 @@ module IDL
       while true
         ch = @in.lookc
         break if ch.nil?
+
         case
-        when (ch == ?\") #"
+        when (ch == "\"") # "
           s << @in.getc # opening quote
           while true
-            if @in.lookc == ?\\
+            if @in.lookc == "\\"
               # escape sequence
               s << @in.getc
               _, escstr = next_escape_str(true)
               s << escstr
-            elsif @in.lookc == ?\" #"
+            elsif @in.lookc == "\"" # "
               break
             elsif @in.lookc
               # normal character
@@ -700,36 +731,36 @@ module IDL
             end
           end
           s << @in.getc # closing quote
-        when (ch == ?\') #' # quoted character
+        when (ch == "\'") # ' # quoted character
           s << @in.getc # opening quote
-          if @in.lookc == ?\\
+          if @in.lookc == "\\"
             # escape sequence
             s << @in.getc
             _, escstr = next_escape_str(true)
             s << escstr
-          elsif @in.lookc && @in.lookc != ?\' #'
+          elsif @in.lookc && @in.lookc != "\'" # '
             # normal character
             s << @in.getc
           end
-          if @in.lookc != ?\' #'
+          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 == ?/
+        when ch == '/'
           @in.skipc
-          if @in.lookc == ?/
+          if @in.lookc == '/'
             # //-style comment; skip till eol
             @in.gets
             break
-          elsif @in.lookc == ?*
+          elsif @in.lookc == '*'
             # /*...*/ style comment; skip comment
             ch1 = nil
             @in.skipuntil { |ch_|
               ch0 = ch1; ch1 = ch_
-              ch0 == ?* and ch1 == ?/ #
+              ch0 == '*' and ch1 == '/' #
             }
             if @in.lookc.nil?
               parse_error "cannot find comment closing brace (\'*/\'). "
@@ -738,7 +769,7 @@ module IDL
           else
             s << ch
           end
-        when ch == ?\\
+        when ch == "\\"
           @in.skipc
           if LFCR.include?(@in.lookc)
             # line continuation
@@ -759,6 +790,7 @@ module IDL
 
     def resolve_define(id, stack = [])
       return id if %w(true false).include?(id)
+
       IDL.log(3, "*** RIDL - resolve_define(#{id})")
       if @defined.has_key?(id)
         define_ = @defined[id]
@@ -785,10 +817,11 @@ module IDL
     end
 
     def parse_directive
-      @in.skipwhile {|c| SPACES.include?(c) }
+      @in.skipwhile { |c| SPACES.include?(c) }
       s = getline
       /^(\w*)\s*/ === s
-      s1, s2 = $1, $' #'
+      s1 = $1
+      s2 = $' # '
 
       if /(else|endif|elif)/ === s1
 
@@ -797,7 +830,7 @@ module IDL
         end
         case s1
         when 'else'
-          if @ifnest == 0
+          if @ifnest.zero?
             if @ifskip # true branch has already been parsed
               @ifdef[@ifdef.size - 1] = false
             else
@@ -806,14 +839,14 @@ module IDL
             end
           end
         when 'endif'
-          if @ifnest == 0
+          if @ifnest.zero?
             @ifdef.pop
             @ifskip = @ifdef.last
           else
             @ifnest -= 1
           end
         else
-          if @ifnest == 0
+          if @ifnest.zero?
             if @ifskip || @ifdef[@ifdef.size - 1]
               # true branch has already been parsed so skip from now on
               @ifdef[@ifdef.size - 1] = false
@@ -829,9 +862,9 @@ module IDL
                 @ifskip = @ifdef[@ifdef.size - 1]
               rescue IDL::ParseError
                 raise
-              rescue => ex
-                p ex
-                puts ex.backtrace.join("\n")
+              rescue => e
+                p e
+                puts e.backtrace.join("\n")
                 parse_error 'error evaluating #elif'
               end
             end
@@ -865,9 +898,9 @@ module IDL
               @ifskip = @ifdef.last
             rescue IDL::ParseError
               raise
-            rescue => ex
-              p ex
-              puts ex.backtrace.join("\n")
+            rescue => e
+              p e
+              puts e.backtrace.join("\n")
               parse_error 'error evaluating #if'
             end
           else
@@ -930,17 +963,17 @@ module IDL
     end
 
     def next_token_before_eol
-      @in.skipwhile {|c| SPACES.include?(c)}
+      @in.skipwhile { |c| SPACES.include?(c) }
       LFCR.include?(@in.lookc) ? nil : next_token
     end
 
     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?
+          if !@ifdef.empty? and !in_expansion?
             parse_error 'mismatched #if/#endif'
           end
           if more_source?
@@ -952,11 +985,11 @@ module IDL
         end
 
         if WHITESPACE.include? ch
-          @in.skipwhile {|c| WHITESPACE.include?(c) }
+          @in.skipwhile { |c| WHITESPACE.include?(c) }
           next
         end
 
-        if str.empty? && ch == ?\#
+        if str.empty? && ch == "\#"
           parse_directive
           next
         end
@@ -982,50 +1015,50 @@ module IDL
             return parse_annotation || next_token
           end
 
-        when ch == ?: #
-          if @in.lookc == ?: #
+        when ch == ':' #
+          if @in.lookc == ':' #
             @in.skipc
             return %w(:: ::)
           else
             return %w(: :)
           end
 
-        when ch == ?L
+        when ch == 'L'
           _nxtc = @in.lookc
-          if _nxtc == ?\'  #' #single quote, for a character literal.
+          if _nxtc == "\'" # ' #single quote, for a character literal.
             @in.skipc # skip 'L'
             _nxtc = @in.lookc
-            ret = if _nxtc == ?\\
+            ret = if _nxtc == "\\"
               @in.skipc
               next_escape_str
-            elsif _nxtc == ?\' #'
+            elsif _nxtc == "\'" # '
               [ nil, nil ]
             else
-              [ :char, '' << @in.getc ]
+              [:char, '' << @in.getc]
             end
 
-            if @in.lookc != ?\' #'
+            if @in.lookc != "\'" # '
               parse_error "wide character literal must be single wide character enclosed in \"'\""
             end
 
             @in.skipc
-            return [ :wide_character_literal, ret ]
+            return [:wide_character_literal, ret]
 
-          elsif _nxtc == ?\" #" #double quote, for a string literal.
+          elsif _nxtc == "\"" # " #double quote, for a string literal.
             ret = []
             chs = ''
             @in.skipc # skip 'L'
             while true
               _nxtc = @in.lookc
-              if _nxtc == ?\\
+              if _nxtc == "\\"
                 @in.skipc
                 ret << [:char, chs] unless chs.empty?
                 chs = ''
                 ret << next_escape_str
-              elsif _nxtc == ?\" #"
+              elsif _nxtc == "\"" # "
                 @in.skipc
                 ret << [:char, chs] unless chs.empty?
-                return [ :wide_string_literal, ret ]
+                return [:wide_string_literal, ret]
               else
                 chs << @in.getc
               end
@@ -1038,15 +1071,15 @@ module IDL
         when IDCHARS.include?(ch)
           return next_identifier(ch)
 
-        when ch == ?/ #
+        when ch == '/' #
           _nxtc = @in.lookc
-          if _nxtc == ?*
+          if _nxtc == '*'
             # skip comment like a `/* ... */'
             @in.skipc # forward stream beyond `/*'
             ch1 = nil
             @in.skipuntil { |ch_|
               ch0 = ch1; ch1 = ch_
-              ch0 == ?* and ch1 == ?/ #
+              ch0 == '*' and ch1 == '/' #
             }
             if @in.lookc.nil?
               parse_error "cannot find comment closing brace (\'*/\'). "
@@ -1055,17 +1088,17 @@ module IDL
             str = '' # reset
             next
 
-          elsif _nxtc == ?/
+          elsif _nxtc == '/'
             # skip comment like a `// ...\n'
             @in.skipc
-            unless @scan_comment  # scan_comment will be true when parsing commented annotations
+            unless @scan_comment # scan_comment will be true when parsing commented annotations
               _nxtc = @in.lookc
               if _nxtc == ANNOTATION
                 @in.skipc
                 # return token returned by parse_annotation or parse next token recursively
                 return parse_annotation(true) || next_token
               else
-                @in.skipuntil {|c| LFCR.include?(c) }
+                @in.skipuntil { |c| LFCR.include?(c) }
               end
             end
             str = '' # reset
@@ -1085,10 +1118,10 @@ module IDL
             return [str, str]
           end
 
-        when (?1..?9).include?(ch)
+        when ('1'..'9').include?(ch)
           @in.mark(sign, ch)
-          @in.skipwhile {|c| DIGITS.include?(c) }
-          num_type = ([?., ?e, ?E, ?d, ?D].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
+          @in.skipwhile { |c| DIGITS.include?(c) }
+          num_type = (['.', 'e', 'E', 'd', 'D'].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
 
           r = @in.getregion
 
@@ -1102,7 +1135,7 @@ module IDL
 
         when ch == DOT #
           @in.mark(ch)
-          @in.skipwhile {|c| DIGITS.include?(c) }
+          @in.skipwhile { |c| DIGITS.include?(c) }
           num_type = (DOT != @in.lookc) ? skipfloat_or_fixed : nil
           s = @in.getregion
           if s == '.'
@@ -1116,24 +1149,24 @@ module IDL
             parse_error 'invalid floating point constant.'
           end
 
-        when ch == ?0
+        when ch == '0'
           @in.mark(sign, ch)
 
           _nxtc = @in.lookc
-          if _nxtc == ?x || _nxtc == ?X
+          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 {|c| OCTALS.include?(c) }
-            if (?8..?9).include? @in.lookc
+            @in.skipwhile { |c| OCTALS.include?(c) }
+            if ('8'..'9').include? @in.lookc
               dec = TRUE
-              @in.skipwhile {|c| DIGITS.include?(c) }
+              @in.skipwhile { |c| DIGITS.include?(c) }
             end
 
-            num_type = ([?., ?e, ?E, ?d, ?D].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
+            num_type = (['.', 'e', 'E', 'd', 'D'].include?(@in.lookc)) ? skipfloat_or_fixed : :integer_literal
 
             s = @in.getregion
             ret = if num_type == :floating_pt_literal
@@ -1148,34 +1181,34 @@ module IDL
             return ret
           end
 
-        when ch == ?\'  #' #single quote, for a character literal.
+        when ch == "\'" # ' #single quote, for a character literal.
           _nxtc = @in.lookc
-          ret = if _nxtc == ?\\
+          ret = if _nxtc == "\\"
             @in.skipc
             next_escape
-          elsif _nxtc == ?\' #'
+          elsif _nxtc == "\'" # '
             0
           elsif _nxtc
             ('' << @in.getc).unpack('C').first
           end
 
-          if @in.lookc != ?\' #'
+          if @in.lookc != "\'" # '
             parse_error "character literal must be single character enclosed in \"'\""
           end
 
           @in.skipc
-          return [ :character_literal, ret ]
+          return [:character_literal, ret]
 
-        when ch == ?\" #" #double quote, for a string literal.
+        when ch == "\"" # " #double quote, for a string literal.
           ret = ''
           while true
             _nxtc = @in.lookc
-            if _nxtc == ?\\
+            if _nxtc == "\\"
               @in.skipc
               ret << next_escape
-            elsif _nxtc == ?\" #"
+            elsif _nxtc == "\"" # "
               @in.skipc
-              return [ :string_literal, ret ]
+              return [:string_literal, ret]
             elsif _nxtc
               ret << @in.getc
             else
@@ -1186,11 +1219,10 @@ module IDL
         else
           parse_error 'illegal character [' << ch << ']'
 
-        end #of case
+        end # of case
 
-      end #of while
+      end # of while
       parse_error 'unexcepted error'
-    end #of method next_token
+    end # of method next_token
   end
-
 end