adlint 2.6.14 → 3.0.0

data/lib/adlint/{c → cc1}/format.rb

@@ -1,7 +1,7 @@
 # Format of the formatted input/output functions.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,15 +29,15 @@
 #
 #++
 
-require "adlint/c/mediator"
+require "adlint/cc1/mediator"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class PrintfFormat
-    def initialize(format_str, location, trailing_args, environment)
-      @location = location
-      @directives = create_directives(format_str, trailing_args, environment)
+    def initialize(fmt_str, loc, trailing_args, env)
+      @location = loc
+      @directives = create_directives(fmt_str, trailing_args, env)
       @extra_arguments = trailing_args
     end
 
@@ -46,65 +46,65 @@ module C #:nodoc:
     attr_reader :extra_arguments
 
     def conversion_specifiers
-      @directives.select { |directive| directive.conversion_specifier? }
+      @directives.select { |dire| dire.conversion_specifier? }
     end
 
     def min_length
-      @directives.reduce(0) { |len, directive| len + directive.min_length }
+      @directives.reduce(0) { |len, dire| len + dire.min_length }
     end
 
     def max_length
-      @directives.reduce(0) { |len, directive| len + directive.max_length }
+      @directives.reduce(0) { |len, dire| len + dire.max_length }
     end
 
     private
-    def create_directives(format_str, trailing_args, environment)
-      directives = []
-      str = format_str.dup
+    def create_directives(fmt_str, trailing_args, env)
+      dires = []
+      str = fmt_str.dup
       until str.empty?
-        directives.push(Directive.guess(str, trailing_args, environment))
+        dires.push(Directive.guess(str, trailing_args, env))
       end
-      directives
+      dires
     end
 
     # == DESCRIPTION
     # === Directive class hierarchy
     #  Directive
-    #    <--- Ordinary
-    #    <--- ConversionSpecifier
-    #           <--- CompleteConversionSpecifier
-    #                  <--- NumberConversionSpecifier
-    #                         <--- Conversion_d
-    #                                <--- Conversion_i
-    #                                <--- Conversion_o
-    #                                       <--- Conversion_u
-    #                                       <--- Conversion_x
-    #                                       <--- Conversion_X
-    #                         <--- Conversion_f
-    #                                <--- Conversion_F
-    #                                <--- Conversion_e
-    #                                <--- Conversion_E
-    #                                <--- Conversion_g
-    #                                <--- Conversion_G
-    #                                <--- Conversion_a
-    #                                <--- Conversion_A
-    #                         <--- Conversion_p
-    #                  <--- CharacterConversionSpecifier
-    #                         <--- Conversion_c
-    #                  <--- StringConversionSpecifier
-    #                         <--- Conversion_s
-    #                  <--- Conversion_n
-    #                  <--- Conversion_percent
-    #                  <--- UndefinedConversionSpecifier
-    #           <--- IncompleteConversionSpecifier
+    #    <-- Ordinary
+    #    <-- ConversionSpecifier
+    #          <-- CompleteConversionSpecifier
+    #                <-- NumberConversionSpecifier
+    #                      <-- Conversion_d
+    #                            <-- Conversion_i
+    #                            <-- Conversion_o
+    #                                  <-- Conversion_u
+    #                                  <-- Conversion_x
+    #                                  <-- Conversion_X
+    #                      <-- Conversion_f
+    #                            <-- Conversion_F
+    #                            <-- Conversion_e
+    #                            <-- Conversion_E
+    #                            <-- Conversion_g
+    #                            <-- Conversion_G
+    #                            <-- Conversion_a
+    #                            <-- Conversion_A
+    #                      <-- Conversion_p
+    #                <-- CharacterConversionSpecifier
+    #                      <-- Conversion_c
+    #                <-- StringConversionSpecifier
+    #                      <-- Conversion_s
+    #                <-- Conversion_n
+    #                <-- Conversion_percent
+    #                <-- UndefinedConversionSpecifier
+    #          <-- IncompleteConversionSpecifier
     class Directive
-      def self.guess(format_str, trailing_args, environ)
-        try_to_create_ordinary(format_str) or
-        try_to_create_conversion_specifier(format_str, trailing_args, environ)
+      def self.guess(fmt_str, trailing_args, env)
+        try_to_create_ordinary(fmt_str) or
+        try_to_create_conversion_specifier(fmt_str, trailing_args, env)
       end
 
-      def initialize(format, consume_args)
-        @format = format
+      def initialize(fmt, consume_args)
+        @format = fmt
         @consume_arguments = consume_args
       end
 
@@ -205,26 +205,25 @@ module C #:nodoc:
         subclass_responsibility
       end
 
-      def self.try_to_create_ordinary(format_str)
-        (format = Ordinary.scan(format_str)) ? Ordinary.new(format) : nil
+      def self.try_to_create_ordinary(fmt_str)
+        (fmt = Ordinary.scan(fmt_str)) ? Ordinary.new(fmt) : nil
       end
       private_class_method :try_to_create_ordinary
 
-      def self.try_to_create_conversion_specifier(format_str,
-                                                  trailing_args, environment)
-        format, flags, field_width, precision, length_modifier, cs_char =
-          ConversionSpecifier.scan(format_str)
+      def self.try_to_create_conversion_specifier(fmt_str, trailing_args, env)
+        fmt, flags, field_width, prec, len_mod, cs_char =
+          ConversionSpecifier.scan(fmt_str)
 
         case
         when cs_char.nil?
-          IncompleteConversionSpecifier.new(format, flags, field_width,
-                                            precision, length_modifier)
+          IncompleteConversionSpecifier.new(fmt, flags, field_width, prec,
+                                            len_mod)
         when cs_class = CONVERSION_SPECIFIER_TBL[cs_char]
-          cs_class.new(format, trailing_args, environment,
-                       flags, field_width, precision, length_modifier, cs_char)
+          cs_class.new(fmt, trailing_args, env, flags, field_width, prec,
+                       len_mod, cs_char)
         else
-          UndefinedConversionSpecifier.new(format, flags, field_width,
-                                           precision, length_modifier, cs_char)
+          UndefinedConversionSpecifier.new(fmt, flags, field_width, prec,
+                                           len_mod, cs_char)
         end
       end
       private_class_method :try_to_create_conversion_specifier
@@ -232,7 +231,7 @@ module C #:nodoc:
     private_constant :Directive
 
     class Ordinary < Directive
-      def self.scan(format_str)
+      def self.scan(fmt_str)
         # NOTE: The ISO C99 standard says;
         #
         # 7.19.6.1 The fprintf function
@@ -245,11 +244,11 @@ module C #:nodoc:
         #   subsequent arguments, converting them, if applicable, according to
         #   the corresponding conversion specifier, and then writing the result
         #   to the output stream.
-        format_str.slice!(/\A[^%]+/)
+        fmt_str.slice!(/\A[^%]+/)
       end
 
-      def initialize(format)
-        super(format, false)
+      def initialize(fmt)
+        super(fmt, false)
       end
 
       def conversion_specifier?
@@ -337,7 +336,7 @@ module C #:nodoc:
       include TypeTableMediator
       include MemoryPoolMediator
 
-      def self.scan(format_str)
+      def self.scan(fmt_str)
         # NOTE: The ISO C99 standard says;
         #
         # 7.19.6.1 The fprintf function
@@ -369,51 +368,50 @@ module C #:nodoc:
         #   -- A conversion specifier character that specifies the type of
         #      conversion to be applied.
 
-        if header = format_str.slice!(/\A%/)
+        if header = fmt_str.slice!(/\A%/)
           scanned = header
         else
           return nil, nil, nil, nil, nil, nil
         end
 
-        if flags = format_str.slice!(/\A#{flags_re}/)
+        if flags = fmt_str.slice!(/\A#{flags_re}/)
           scanned += flags
         end
 
-        if field_width = format_str.slice!(/\A#{field_width_re}/)
+        if field_width = fmt_str.slice!(/\A#{field_width_re}/)
           scanned += field_width
         end
 
-        if precision = format_str.slice!(/\A#{precision_re}/)
-          scanned += precision
+        if prec = fmt_str.slice!(/\A#{precision_re}/)
+          scanned += prec
         end
 
-        if length_modifier = format_str.slice!(/\A#{length_modifier_re}/)
-          scanned += length_modifier
+        if len_mod = fmt_str.slice!(/\A#{length_modifier_re}/)
+          scanned += len_mod
         end
 
-        if cs_char = format_str.slice!(/\A#{cs_char_re}/)
+        if cs_char = fmt_str.slice!(/\A#{cs_char_re}/)
           scanned += cs_char
         else
           # NOTE: If no valid conversion specifier character, force to scan
           #       the heading 1 character as a conversion specifier character.
-          if cs_char = format_str.slice!(/\A[a-z]/i)
+          if cs_char = fmt_str.slice!(/\A[a-z]/i)
             scanned += cs_char
           end
         end
 
-        return scanned, flags, field_width, precision, length_modifier, cs_char
+        return scanned, flags, field_width, prec, len_mod, cs_char
       end
 
-      def initialize(format, trailing_args, environment, consume_args,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, consume_args)
+      def initialize(fmt, trailing_args, env, consume_args, flags, field_width,
+                     prec, len_mod, cs_char)
+        super(fmt, consume_args)
 
         @flags = flags
         @field_width = field_width
-        @precision = precision
-        @length_modifier = length_modifier
-        @conversion_specifier_character = conversion_specifier_character
+        @precision = prec
+        @length_modifier = len_mod
+        @conversion_specifier_character = cs_char
 
         if consume_arguments? && @field_width == "*"
           @field_width_argument = trailing_args.shift
@@ -433,7 +431,7 @@ module C #:nodoc:
           @conversion_argument = nil
         end
 
-        @environment = environment
+        @environment = env
       end
 
       def conversion_specifier?
@@ -747,13 +745,13 @@ module C #:nodoc:
         "%#{flags}#{fw}#{pr}#{conversion_specifier_character}"
       end
 
-      def type_table
-        @environment.type_table
-      end
+      extend Forwardable
 
-      def memory_pool
-        @environment.memory_pool
-      end
+      def_delegator :@environment, :type_table
+      private :type_table
+
+      def_delegator :@environment, :memory_pool
+      private :memory_pool
     end
     private_constant :ConversionSpecifier
 
@@ -765,15 +763,15 @@ module C #:nodoc:
       # Boolean -- True if types of arguments match this directive.
       def acceptable?
         if @field_width_argument
-          unless @field_width_argument.type.convertible?(signed_int_type) ||
-              @field_width_argument.type.convertible?(unsigned_int_type)
+          unless @field_width_argument.type.convertible?(signed_int_t) ||
+              @field_width_argument.type.convertible?(unsigned_int_t)
             return false
           end
         end
 
         if @precision_argument
-          unless @precision_argument.type.convertible?(signed_int_type) ||
-              @precision_argument.type.convertible?(unsigned_int_type)
+          unless @precision_argument.type.convertible?(signed_int_t) ||
+              @precision_argument.type.convertible?(unsigned_int_t)
             return false
           end
         end
@@ -838,12 +836,10 @@ module C #:nodoc:
     private_constant :CompleteConversionSpecifier
 
     class NumberConversionSpecifier < CompleteConversionSpecifier
-      def initialize(format, trailing_args, environment,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, trailing_args, environment, true,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, trailing_args, env, flags, field_width, prec,
+                     len_mod, cs_char)
+        super(fmt, trailing_args, env, true, flags, field_width, prec, len_mod,
+              cs_char)
       end
 
       def valid_conversion_specifier_character?
@@ -852,15 +848,15 @@ module C #:nodoc:
 
       def min_length
         # NOTE: Ruby has the buitin mostly C compliant sprintf.
-        sprintf(ruby_sprintf_format, 0).length
+        (ruby_sprintf_format % 0).length
       end
 
       def max_length
         # NOTE: Ruby has the buitin mostly C compliant sprintf.
         if conversion_type.signed?
-          sprintf(ruby_sprintf_format, conversion_type.min_value).length
+          (ruby_sprintf_format % conversion_type.min).length
         else
-          sprintf(ruby_sprintf_format, conversion_type.max_value).length
+          (ruby_sprintf_format % conversion_type.max).length
         end
       end
 
@@ -951,24 +947,24 @@ module C #:nodoc:
         #        specifier applies to a pointer to a ptrdiff_t argument.
         case length_modifier
         when "hh"
-          [signed_char_type, unsigned_char_type]
+          [signed_char_t, unsigned_char_t]
         when "h"
-          [signed_short_type, unsigned_short_type]
+          [signed_short_t, unsigned_short_t]
         when "l"
-          [signed_long_type, unsigned_long_type]
+          [signed_long_t, unsigned_long_t]
         when "ll"
-          [signed_long_long_type, unsigned_long_long_type]
+          [signed_long_long_t, unsigned_long_long_t]
         when "j"
           # FIXME: `intmax_t' and `uintmax_t' are not supported yet.
-          [signed_long_long_type, unsigned_long_long_type]
+          [signed_long_long_t, unsigned_long_long_t]
         when "z"
           # FIXME: `size_t' is not supported yet.
-          [unsigned_long_type]
+          [unsigned_long_t]
         when "t"
           # FIXME: `ptrdiff_t' is not supported yet.
-          [signed_int_type]
+          [signed_int_t]
         else
-          [signed_int_type, unsigned_int_type]
+          [signed_int_t, unsigned_int_t]
         end
       end
 
@@ -980,48 +976,48 @@ module C #:nodoc:
         case length_modifier
         when "hh"
           if conversion_argument && conversion_argument.type.signed?
-            signed_char_type
+            signed_char_t
           else
-            unsigned_char_type
+            unsigned_char_t
           end
         when "h"
           if conversion_argument && conversion_argument.type.signed?
-            signed_short_type
+            signed_short_t
           else
-            unsigned_short_type
+            unsigned_short_t
           end
         when "l"
           if conversion_argument && conversion_argument.type.signed?
-            signed_long_type
+            signed_long_t
           else
-            unsigned_long_type
+            unsigned_long_t
           end
         when "ll"
           if conversion_argument && conversion_argument.type.signed?
-            signed_long_long_type
+            signed_long_long_t
           else
-            unsigned_long_long_type
+            unsigned_long_long_t
           end
         when "j"
           # FIXME: `intmax_t' and `uintmax_t' are not supported yet.
           if conversion_argument && conversion_argument.type.signed?
-            signed_long_long_type
+            signed_long_long_t
           else
-            unsigned_long_long_type
+            unsigned_long_long_t
           end
         when "z"
           # FIXME: `size_t' is not supported yet.
-          unsigned_long_type
+          unsigned_long_t
         when "t"
           # FIXME: `ptrdiff_t' is not supported yet.
-          signed_int_type
+          signed_int_t
         else
           default_conversion_type
         end
       end
 
       def default_conversion_type
-        signed_int_type
+        signed_int_t
       end
     end
     private_constant :Conversion_d
@@ -1040,7 +1036,7 @@ module C #:nodoc:
 
       private
       def default_conversion_type
-        unsigned_int_type
+        unsigned_int_t
       end
     end
     private_constant :Conversion_o
@@ -1140,11 +1136,11 @@ module C #:nodoc:
         #        conversion specifier applies to a long double argument.
         case length_modifier
         when "L"
-          [long_double_type]
+          [long_double_t]
         else
           # NOTE: The argument will be argument promoted, so float type should
           #       be acceptable, too.
-          [float_type, double_type]
+          [float_t, double_t]
         end
       end
 
@@ -1155,9 +1151,9 @@ module C #:nodoc:
       def conversion_type
         case length_modifier
         when "L"
-          long_double_type
+          long_double_t
         else
-          double_type
+          double_t
         end
       end
     end
@@ -1246,12 +1242,10 @@ module C #:nodoc:
     private_constant :Conversion_A
 
     class CharacterConversionSpecifier < CompleteConversionSpecifier
-      def initialize(format, trailing_args, environment,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, trailing_args, environment, true,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, trailing_args, env, flags, field_width, prec,
+                     len_mod, cs_char)
+        super(fmt, trailing_args, env, true, flags, field_width, prec, len_mod,
+              cs_char)
       end
 
       def valid_conversion_specifier_character?
@@ -1260,7 +1254,7 @@ module C #:nodoc:
 
       def min_length
         # NOTE: Ruby has the buitin mostly C compliant sprintf.
-        sprintf(ruby_sprintf_format, " ").length
+        (ruby_sprintf_format % " ").length
       end
 
       def max_length
@@ -1297,13 +1291,13 @@ module C #:nodoc:
         case length_modifier
         when "l"
           # FIXME: `wint_t' is not supported yet.
-          [wchar_type]
+          [wchar_t]
         else
           # NOTE: The argument will be integer promoted, so the argument type
           #       whose conversion-rank is less than one of the int should be
           #       acceptable, too.
-          [signed_char_type, unsigned_char_type, signed_short_type,
-            unsigned_short_type, signed_int_type, unsigned_int_type]
+          [signed_char_t, unsigned_char_t, signed_short_t,
+            unsigned_short_t, signed_int_t, unsigned_int_t]
         end
       end
 
@@ -1314,12 +1308,10 @@ module C #:nodoc:
     private_constant :Conversion_c
 
     class StringConversionSpecifier < CompleteConversionSpecifier
-      def initialize(format, trailing_args, environment,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, trailing_args, environment, true,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, trailing_args, env, flags, field_width, prec,
+                     len_mod, cs_char)
+        super(fmt, trailing_args, env, true, flags, field_width, prec, len_mod,
+              cs_char)
       end
 
       def valid_conversion_specifier_character?
@@ -1328,15 +1320,15 @@ module C #:nodoc:
 
       def min_length
         # NOTE: Ruby has the buitin mostly C compliant sprintf.
-        sprintf(ruby_sprintf_format, "").length
+        (ruby_sprintf_format % "").length
       end
 
       def max_length
         # NOTE: Ruby has the buitin mostly C compliant sprintf.
         if conversion_argument && conversion_argument.type.pointer? and
             pointee = pointee_of(conversion_argument) and pointee.type.array?
-          length = pointee.type.length ? pointee.type.length - 1 : 0
-          sprintf(ruby_sprintf_format, " " * length).length
+          len = pointee.type.length ? pointee.type.length - 1 : 0
+          (ruby_sprintf_format % (" " * len)).length
         else
           min_length
         end
@@ -1371,10 +1363,10 @@ module C #:nodoc:
         #        or G conversion specifier.
         case length_modifier
         when "l"
-          [pointer_type(qualified_type(wchar_type, :const))]
+          [pointer_type(qualified_type(wchar_t, :const))]
         else
-          [pointer_type(qualified_type(signed_char_type, :const)),
-            pointer_type(qualified_type(unsigned_char_type, :const))]
+          [pointer_type(qualified_type(signed_char_t, :const)),
+            pointer_type(qualified_type(unsigned_char_t, :const))]
         end
       end
 
@@ -1392,14 +1384,13 @@ module C #:nodoc:
       def min_length
         # NOTE: `%p' conversion specifier of the Ruby's builtin sprintf does
         #       not convert the argument.
-        sprintf("%##{flags}#{field_width}#{precision}x", 0).length
+        ("%##{flags}#{field_width}#{precision}x" % 0).length
       end
 
       def max_length
         # NOTE: `%p' conversion specifier of the Ruby's builtin sprintf does
         #       not convert the argument.
-        sprintf("%##{flags}#{field_width}#{precision}x",
-                conversion_type.max_value).length
+        ("%##{flags}#{field_width}#{precision}x" % conversion_type.max).length
       end
 
       private
@@ -1411,7 +1402,7 @@ module C #:nodoc:
         if conversion_argument && conversion_argument.type.pointer?
           [conversion_argument.type.unqualify]
         else
-          [pointer_type(qualified_type(void_type, :const))]
+          [pointer_type(qualified_type(void_t, :const))]
         end
       end
 
@@ -1420,7 +1411,7 @@ module C #:nodoc:
       end
 
       def conversion_type
-        pointer_type(void_type)
+        pointer_type(void_t)
       end
     end
     private_constant :Conversion_p
@@ -1430,12 +1421,10 @@ module C #:nodoc:
         "n"
       end
 
-      def initialize(format, trailing_args, environment,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, trailing_args, environment, true,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, trailing_args, env, flags, field_width, prec,
+                     len_mod, cs_char)
+        super(fmt, trailing_args, env, true, flags, field_width, prec, len_mod,
+              cs_char)
       end
 
       def valid_conversion_specifier_character?
@@ -1503,24 +1492,24 @@ module C #:nodoc:
         #        specifier applies to a pointer to a ptrdiff_t argument.
         case length_modifier
         when "hh"
-          [pointer_type(qualified_type(signed_char_type, :const))]
+          [pointer_type(qualified_type(signed_char_t, :const))]
         when "h"
-          [pointer_type(qualified_type(signed_short_type, :const))]
+          [pointer_type(qualified_type(signed_short_t, :const))]
         when "l"
-          [pointer_type(qualified_type(signed_long_type, :const))]
+          [pointer_type(qualified_type(signed_long_t, :const))]
         when "ll"
-          [pointer_type(qualified_type(signed_long_long_type, :const))]
+          [pointer_type(qualified_type(signed_long_long_t, :const))]
         when "j"
           # FIXME: `intmax_t' is not supported yet.
-          [pointer_type(qualified_type(signed_long_long_type, :const))]
+          [pointer_type(qualified_type(signed_long_long_t, :const))]
         when "z"
           # FIXME: `size_t' is not supported yet.
-          [pointer_type(qualified_type(signed_long_type, :const))]
+          [pointer_type(qualified_type(signed_long_t, :const))]
         when "t"
           # FIXME: `ptrdiff_t' is not supported yet.
-          [pointer_type(qualified_type(signed_int_type, :const))]
+          [pointer_type(qualified_type(signed_int_t, :const))]
         else
-          [pointer_type(qualified_type(signed_int_type, :const))]
+          [pointer_type(qualified_type(signed_int_t, :const))]
         end
       end
 
@@ -1535,12 +1524,10 @@ module C #:nodoc:
         "%"
       end
 
-      def initialize(format, trailing_args, environment,
-                     flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, trailing_args, environment, false,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, trailing_args, env, flags, field_width, prec,
+                     len_mod, cs_char)
+        super(fmt, trailing_args, env, false, flags, field_width, prec,
+              len_mod, cs_char)
       end
 
       def valid_flags?
@@ -1587,11 +1574,8 @@ module C #:nodoc:
     private_constant :Conversion_percent
 
     class UndefinedConversionSpecifier < CompleteConversionSpecifier
-      def initialize(format, flags, field_width, precision, length_modifier,
-                     conversion_specifier_character)
-        super(format, [], nil, false,
-              flags, field_width, precision, length_modifier,
-              conversion_specifier_character)
+      def initialize(fmt, flags, field_width, prec, len_mod, cs_char)
+        super(fmt, [], nil, false, flags, field_width, prec, len_mod, cs_char)
       end
 
       def undefined?
@@ -1626,9 +1610,8 @@ module C #:nodoc:
     private_constant :UndefinedConversionSpecifier
 
     class IncompleteConversionSpecifier < ConversionSpecifier
-      def initialize(format, flags, field_width, precision, length_modifier)
-        super(format, [], nil, false,
-              flags, field_width, precision, length_modifier, nil)
+      def initialize(fmt, flags, field_width, prec, len_mod)
+        super(fmt, [], nil, false, flags, field_width, prec, len_mod, nil)
       end
 
       # === DESCRIPTION
@@ -1724,9 +1707,9 @@ module C #:nodoc:
   end
 
   class ScanfFormat
-    def initialize(format_str, location, trailing_args, environment)
-      @location = location
-      @directives = create_directives(format_str, trailing_args, environment)
+    def initialize(fmt_str, loc, trailing_args, env)
+      @location        = loc
+      @directives      = create_directives(fmt_str, trailing_args, env)
       @extra_arguments = trailing_args
     end
 
@@ -1735,57 +1718,57 @@ module C #:nodoc:
     attr_reader :extra_arguments
 
     def conversion_specifiers
-      @directives.select { |directive| directive.conversion_specifier? }
+      @directives.select { |dire| dire.conversion_specifier? }
     end
 
     private
-    def create_directives(format_str, trailing_args, environment)
-      directives = []
-      str = format_str.dup
+    def create_directives(fmt_str, trailing_args, env)
+      dires = []
+      str = fmt_str.dup
       until str.empty?
-        directives.push(Directive.guess(str, trailing_args, environment))
+        dires.push(Directive.guess(str, trailing_args, env))
       end
-      directives
+      dires
     end
 
     # == DESCRIPTION
     # === Directive class hierarchy
     #  Directive
-    #    <--- Whitespace
-    #    <--- Ordinary
-    #    <--- ConversionSpecifier
-    #           <--- CompleteConversionSpecifier
-    #                  <--- Conversion_d
-    #                         <--- Conversion_i
-    #                         <--- Conversion_o
-    #                                <--- Conversion_u
-    #                                <--- Conversion_x
-    #                                <--- Conversion_X
-    #                  <--- Conversion_a
-    #                         <--- Conversion_A
-    #                         <--- Conversion_e
-    #                         <--- Conversion_E
-    #                         <--- Conversion_f
-    #                         <--- Conversion_F
-    #                         <--- Conversion_g
-    #                         <--- Conversion_G
-    #                  <--- Conversion_c
-    #                         <--- Conversion_s
-    #                         <--- Conversion_bracket
-    #                  <--- Conversion_p
-    #                  <--- Conversion_n
-    #                  <--- Conversion_percent
-    #                  <--- UndefinedConversionSpecifier
-    #           <--- IncompleteConversionSpecifier
+    #    <-- Whitespace
+    #    <-- Ordinary
+    #    <-- ConversionSpecifier
+    #          <-- CompleteConversionSpecifier
+    #                <-- Conversion_d
+    #                      <-- Conversion_i
+    #                      <-- Conversion_o
+    #                            <-- Conversion_u
+    #                            <-- Conversion_x
+    #                            <-- Conversion_X
+    #                <-- Conversion_a
+    #                      <-- Conversion_A
+    #                      <-- Conversion_e
+    #                      <-- Conversion_E
+    #                      <-- Conversion_f
+    #                      <-- Conversion_F
+    #                      <-- Conversion_g
+    #                      <-- Conversion_G
+    #                <-- Conversion_c
+    #                      <-- Conversion_s
+    #                      <-- Conversion_bracket
+    #                <-- Conversion_p
+    #                <-- Conversion_n
+    #                <-- Conversion_percent
+    #                <-- UndefinedConversionSpecifier
+    #          <-- IncompleteConversionSpecifier
     class Directive
-      def self.guess(format_str, trailing_args, environ)
-        try_to_create_whitespace(format_str) or
-        try_to_create_ordinary(format_str) or
-        try_to_create_conversion_specifier(format_str, trailing_args, environ)
+      def self.guess(fmt_str, trailing_args, env)
+        try_to_create_whitespace(fmt_str) or
+        try_to_create_ordinary(fmt_str) or
+        try_to_create_conversion_specifier(fmt_str, trailing_args, env)
       end
 
-      def initialize(format)
-        @format = format
+      def initialize(fmt)
+        @format = fmt
       end
 
       attr_reader :format
@@ -1881,34 +1864,33 @@ module C #:nodoc:
         subclass_responsibility
       end
 
-      def self.try_to_create_whitespace(format_str)
-        (format = Whitespace.scan(format_str)) ? Whitespace.new(format) : nil
+      def self.try_to_create_whitespace(fmt_str)
+        (fmt = Whitespace.scan(fmt_str)) ? Whitespace.new(fmt) : nil
       end
       private_class_method :try_to_create_whitespace
 
-      def self.try_to_create_ordinary(format_str)
-        (format = Ordinary.scan(format_str)) ? Ordinary.new(format) : nil
+      def self.try_to_create_ordinary(fmt_str)
+        (fmt = Ordinary.scan(fmt_str)) ? Ordinary.new(fmt) : nil
       end
       private_class_method :try_to_create_ordinary
 
-      def self.try_to_create_conversion_specifier(format_str,
-                                                  trailing_args, environment)
-        format, as_char, field_width, length_modifier, cs_char, scanset =
-          ConversionSpecifier.scan(format_str)
+      def self.try_to_create_conversion_specifier(fmt_str, trailing_args, env)
+        fmt, as_char, field_width, len_mod, cs_char, scanset =
+          ConversionSpecifier.scan(fmt_str)
 
         case
         when cs_char.nil?
-          IncompleteConversionSpecifier.new(format, as_char, field_width,
-                                            length_modifier, nil)
+          IncompleteConversionSpecifier.new(fmt, as_char, field_width, len_mod,
+                                            nil)
         when cs_char == "[" && scanset.nil?
-          IncompleteConversionSpecifier.new(format, as_char, field_width,
-                                            length_modifier, cs_char)
+          IncompleteConversionSpecifier.new(fmt, as_char, field_width, len_mod,
+                                            cs_char)
         when cs_class = CONVERSION_SPECIFIER_TBL[cs_char]
-          cs_class.new(format, trailing_args, environment,
-                       as_char, field_width, length_modifier, cs_char, scanset)
+          cs_class.new(fmt, trailing_args, env, as_char, field_width, len_mod,
+                       cs_char, scanset)
         else
-          UndefinedConversionSpecifier.new(format, as_char, field_width,
-                                           length_modifier, cs_char)
+          UndefinedConversionSpecifier.new(fmt, as_char, field_width, len_mod,
+                                           cs_char)
         end
       end
       private_class_method :try_to_create_conversion_specifier
@@ -1916,7 +1898,7 @@ module C #:nodoc:
     private_constant :Directive
 
     class Whitespace < Directive
-      def self.scan(format_str)
+      def self.scan(fmt_str)
         # NOTE: The ISO C99 standard says;
         #
         # 7.19.6.2 The fscanf function
@@ -1936,7 +1918,7 @@ module C #:nodoc:
         #      receiving object.
         #   -- A conversion specifier character that specifies the type of
         #      conversion to be applied.
-        format_str.slice!(/\A\s+/)
+        fmt_str.slice!(/\A\s+/)
       end
 
       def whitespace?
@@ -2025,7 +2007,7 @@ module C #:nodoc:
     private_constant :Whitespace
 
     class Ordinary < Directive
-      def self.scan(format_str)
+      def self.scan(fmt_str)
         # NOTE: The ISO C99 standard says;
         #
         # 7.19.6.2 The fscanf function
@@ -2045,7 +2027,7 @@ module C #:nodoc:
         #      receiving object.
         #   -- A conversion specifier character that specifies the type of
         #      conversion to be applied.
-        format_str.slice!(/\A[^%\s]+/)
+        fmt_str.slice!(/\A[^%\s]+/)
       end
 
       def whitespace?
@@ -2136,7 +2118,7 @@ module C #:nodoc:
     class ConversionSpecifier < Directive
       include TypeTableMediator
 
-      def self.scan(format_str)
+      def self.scan(fmt_str)
         # NOTE: The ISO C99 standard says;
         #
         # 7.19.6.2 The fscanf function
@@ -2157,60 +2139,59 @@ module C #:nodoc:
         #   -- A conversion specifier character that specifies the type of
         #      conversion to be applied.
 
-        if header = format_str.slice!(/\A%/)
+        if header = fmt_str.slice!(/\A%/)
           scanned = header
         else
           return nil, nil, nil, nil, nil, nil
         end
 
-        if as_char = format_str.slice!(/\A#{as_char_re}/)
+        if as_char = fmt_str.slice!(/\A#{as_char_re}/)
           scanned += as_char
         end
 
-        if field_width = format_str.slice!(/\A#{field_width_re}/)
+        if field_width = fmt_str.slice!(/\A#{field_width_re}/)
           scanned += field_width
         end
 
-        if length_modifier = format_str.slice!(/\A#{length_modifier_re}/)
-          scanned += length_modifier
+        if len_mod = fmt_str.slice!(/\A#{length_modifier_re}/)
+          scanned += len_mod
         end
 
-        if cs_char = format_str.slice!(/\A#{cs_char_re}/)
+        if cs_char = fmt_str.slice!(/\A#{cs_char_re}/)
           scanned += cs_char
         else
           # NOTE: If no valid conversion specifier character, force to scan
           #       the heading 1 character as a conversion specifier character.
-          if cs_char = format_str.slice!(/\A[a-z]/i)
+          if cs_char = fmt_str.slice!(/\A[a-z]/i)
             scanned += cs_char
           end
         end
 
         if cs_char == "["
-          if scanset = format_str.slice!(/\A#{scanset_re}/)
+          if scanset = fmt_str.slice!(/\A#{scanset_re}/)
             scanned += scanset
           end
         else
           scanset = nil
         end
 
-        return scanned, as_char, field_width, length_modifier, cs_char, scanset
+        return scanned, as_char, field_width, len_mod, cs_char, scanset
       end
 
-      def initialize(format, trailing_args, environment, consume_args,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format)
+      def initialize(fmt, trailing_args, env, consume_args, as_char,
+                     field_width, len_mod, cs_char, scanset)
+        super(fmt)
 
-        if assignment_suppressing_character == "*"
+        if as_char == "*"
           @consume_arguments = false
         else
           @consume_arguments = consume_args
         end
 
-        @assignment_suppressing_character = assignment_suppressing_character
+        @assignment_suppressing_character = as_char
         @field_width = field_width
-        @length_modifier = length_modifier
-        @conversion_specifier_character = conversion_specifier_character
+        @length_modifier = len_mod
+        @conversion_specifier_character = cs_char
         @scanset = scanset
 
         if consume_arguments?
@@ -2219,7 +2200,7 @@ module C #:nodoc:
           @conversion_argument = nil
         end
 
-        @environment = environment
+        @environment = env
       end
 
       def whitespace?
@@ -2486,10 +2467,10 @@ module C #:nodoc:
       end
       private_class_method :scanset_re
 
-      private
-      def type_table
-        @environment.type_table
-      end
+      extend Forwardable
+
+      def_delegator :@environment, :type_table
+      private :type_table
     end
     private_constant :ConversionSpecifier
 
@@ -2556,12 +2537,10 @@ module C #:nodoc:
         "d"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, true,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, true, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -2614,24 +2593,24 @@ module C #:nodoc:
         #       or the corresponding unsigned integer type.
         case length_modifier
         when "hh"
-          [pointer_type(signed_char_type), pointer_type(unsigned_char_type)]
+          [pointer_type(signed_char_t), pointer_type(unsigned_char_t)]
         when "h"
-          [pointer_type(signed_short_type), pointer_type(unsigned_short_type)]
+          [pointer_type(signed_short_t), pointer_type(unsigned_short_t)]
         when "l"
-          [pointer_type(signed_long_type), pointer_type(unsigned_long_type)]
+          [pointer_type(signed_long_t), pointer_type(unsigned_long_t)]
         when "ll"
-          [pointer_type(signed_long_long_type),
-            pointer_type(unsigned_long_long_type)]
+          [pointer_type(signed_long_long_t),
+            pointer_type(unsigned_long_long_t)]
         when "j"
           # FIXME: `intmax_t' and `uintmax_t' are not supported yet.
-          [pointer_type(signed_long_long_type),
-            pointer_type(unsigned_long_long_type)]
+          [pointer_type(signed_long_long_t),
+            pointer_type(unsigned_long_long_t)]
         when "z"
           # FIXME: `size_t' is not supported yet.
-          [pointer_type(signed_long_type), pointer_type(unsigned_long_type)]
+          [pointer_type(signed_long_t), pointer_type(unsigned_long_t)]
         when "t"
           # FIXME: `ptrdiff_t' is not supported yet.
-          [pointer_type(signed_int_type), pointer_type(unsigned_int_type)]
+          [pointer_type(signed_int_t), pointer_type(unsigned_int_t)]
         else
           default_argument_types
         end
@@ -2642,7 +2621,7 @@ module C #:nodoc:
       end
 
       def default_argument_types
-        [pointer_type(signed_int_type)]
+        [pointer_type(signed_int_t)]
       end
     end
     private_constant :Conversion_d
@@ -2661,7 +2640,7 @@ module C #:nodoc:
 
       private
       def default_argument_types
-        [pointer_type(unsigned_int_type)]
+        [pointer_type(unsigned_int_t)]
       end
     end
     private_constant :Conversion_o
@@ -2692,12 +2671,10 @@ module C #:nodoc:
         "a"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, true,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, true, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -2735,11 +2712,11 @@ module C #:nodoc:
         #       double.
         case length_modifier
         when "l"
-          [pointer_type(double_type)]
+          [pointer_type(double_t)]
         when "L"
-          [pointer_type(long_double_type)]
+          [pointer_type(long_double_t)]
         else
-          [pointer_type(float_type)]
+          [pointer_type(float_t)]
         end
       end
 
@@ -2803,12 +2780,10 @@ module C #:nodoc:
         "c"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, true,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, true, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -2843,9 +2818,9 @@ module C #:nodoc:
         #       applies to an argument with type pointer to wchar_t.
         case length_modifier
         when "l"
-          [pointer_type(wchar_type)]
+          [pointer_type(wchar_t)]
         else
-          [pointer_type(signed_char_type), pointer_type(unsigned_char_type)]
+          [pointer_type(signed_char_t), pointer_type(unsigned_char_t)]
         end
       end
 
@@ -2871,9 +2846,9 @@ module C #:nodoc:
         # NOTE: The `-' character in the scanset causes implementation-defined
         #       behavior.  So, AdLint treats the `-' character as an ordinary
         #       character in the scanset.
-        orig_set = scanset.chop.chars.to_a
-        uniq_set = orig_set.uniq
-        orig_set.size == uniq_set.size
+        org_set = scanset.chop.chars.to_a
+        uniq_set = org_set.uniq
+        org_set.size == uniq_set.size
       end
     end
     private_constant :Conversion_bracket
@@ -2883,12 +2858,10 @@ module C #:nodoc:
         "p"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, true,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, true, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -2912,7 +2885,7 @@ module C #:nodoc:
         if conversion_argument && conversion_argument.type.pointer?
           [conversion_argument.type.unqualify]
         else
-          [pointer_type(void_type)]
+          [pointer_type(void_t)]
         end
       end
 
@@ -2927,12 +2900,10 @@ module C #:nodoc:
         "n"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, true,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, true, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -3001,26 +2972,26 @@ module C #:nodoc:
         #       or the corresponding unsigned integer type.
         case length_modifier
         when "hh"
-          [pointer_type(signed_char_type), pointer_type(unsigned_char_type)]
+          [pointer_type(signed_char_t), pointer_type(unsigned_char_t)]
         when "h"
-          [pointer_type(signed_short_type), pointer_type(unsigned_short_type)]
+          [pointer_type(signed_short_t), pointer_type(unsigned_short_t)]
         when "l"
-          [pointer_type(signed_long_type), pointer_type(unsigned_long_type)]
+          [pointer_type(signed_long_t), pointer_type(unsigned_long_t)]
         when "ll"
-          [pointer_type(signed_long_long_type),
-            pointer_type(unsigned_long_long_type)]
+          [pointer_type(signed_long_long_t),
+            pointer_type(unsigned_long_long_t)]
         when "j"
           # FIXME: `intmax_t' and `uintmax_t' are not supported yet.
-          [pointer_type(signed_long_long_type),
-            pointer_type(unsigned_long_long_type)]
+          [pointer_type(signed_long_long_t),
+            pointer_type(unsigned_long_long_t)]
         when "z"
           # FIXME: `size_t' is not supported yet.
-          [pointer_type(signed_long_type), pointer_type(unsigned_long_type)]
+          [pointer_type(signed_long_t), pointer_type(unsigned_long_t)]
         when "t"
           # FIXME: `ptrdiff_t' is not supported yet.
-          [pointer_type(signed_int_type), pointer_type(unsigned_int_type)]
+          [pointer_type(signed_int_t), pointer_type(unsigned_int_t)]
         else
-          [pointer_type(signed_int_type)]
+          [pointer_type(signed_int_t)]
         end
       end
 
@@ -3035,12 +3006,10 @@ module C #:nodoc:
         "%"
       end
 
-      def initialize(format, trailing_args, environment,
-                     assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character, scanset)
-        super(format, trailing_args, environment, false,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, scanset)
+      def initialize(fmt, trailing_args, env, as_char, field_width, len_mod,
+                     cs_char, scanset)
+        super(fmt, trailing_args, env, false, as_char, field_width, len_mod,
+              cs_char, scanset)
       end
 
       def valid_assignment_suppressing_character?
@@ -3080,11 +3049,8 @@ module C #:nodoc:
     private_constant :Conversion_percent
 
     class UndefinedConversionSpecifier < CompleteConversionSpecifier
-      def initialize(format, assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character)
-        super(format, [], nil, false,
-              assignment_suppressing_character, field_width,
-              length_modifier, conversion_specifier_character, nil)
+      def initialize(fmt, as_char, field_width, len_mod, cs_char)
+        super(fmt, [], nil, false, as_char, field_width, len_mod, cs_char, nil)
       end
 
       def undefined?
@@ -3119,11 +3085,8 @@ module C #:nodoc:
     private_constant :UndefinedConversionSpecifier
 
     class IncompleteConversionSpecifier < ConversionSpecifier
-      def initialize(format, assignment_suppressing_character, field_width,
-                     length_modifier, conversion_specifier_character)
-        super(format, [], nil, false, assignment_suppressing_character,
-              field_width, length_modifier, conversion_specifier_character,
-              nil)
+      def initialize(fmt, as_char, field_width, len_mod, cs_char)
+        super(fmt, [], nil, false, as_char, field_width, len_mod, cs_char, nil)
       end
 
       # === DESCRIPTION