adlint 2.6.14 → 3.0.0

data/lib/adlint/exam/c_builtin/c_check_shima.rb

@@ -1,983 +0,0 @@
-# Code checkings (cc1-phase) of adlint-exam-c_builtin package.
-#
-# Author::    Rie Shima <mailto:rkakuuchi@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
-# License::   GPLv3+: GNU General Public License version 3 or later
-#
-# Owner::     Rie Shima <mailto:rkakuuchi@users.sourceforge.net>
-
-#--
-#     ___    ____  __    ___   _________
-#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
-#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
-#  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
-#
-# This file is part of AdLint.
-#
-# AdLint is free software: you can redistribute it and/or modify it under the
-# terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version.
-#
-# AdLint is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along with
-# AdLint.  If not, see <http://www.gnu.org/licenses/>.
-#
-#++
-
-require "adlint/exam"
-require "adlint/report"
-require "adlint/c/phase"
-require "adlint/c/syntax"
-require "adlint/c/format"
-
-module AdLint #:nodoc:
-module Exam #:nodoc:
-module CBuiltin #:nodoc:
-
-  class W0573 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0573
-
-    def initialize(context)
-      super
-      interp = context[:c_interpreter]
-      interp.on_function_call_expr_evaled += method(:check)
-      @environ = interp.environment
-    end
-
-    private
-    def check(function_call_expression, function, arg_variables,
-              result_variable)
-      if function.named? && function.name =~ /\A.*scanf\z/
-        format = create_format(function_call_expression,
-                               format_str_index_of(function_call_expression),
-                               arg_variables, @environ)
-        return unless format
-
-        format.conversion_specifiers.each_with_index do |cs, index|
-          if cs.scanset && cs.scanset.include?("-")
-            W(:W0573, format.location)
-            break
-          end
-        end
-      end
-    end
-
-    def format_str_index_of(function_call_expression)
-      function_call_expression.argument_expressions.index do |arg_expr|
-        arg_expr.kind_of?(C::StringLiteralSpecifier)
-      end
-    end
-
-    def create_format(function_call_expression,
-                      format_str_index, arg_variables, environment)
-      if format_str_index
-        format_str =
-          function_call_expression.argument_expressions[format_str_index]
-        if format_str && format_str.literal.value =~ /\AL?"(.*)"\z/i
-          location = format_str.location
-          trailing_args = arg_variables[(format_str_index + 1)..-1] || []
-          return C::ScanfFormat.new($1, location, trailing_args, environment)
-        end
-      end
-      nil
-    end
-  end
-
-  class W0606 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0606
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_union_type_declaration += method(:check)
-    end
-
-    private
-    def check(node)
-      node.struct_declarations.each do |struct_declaration|
-        struct_declaration.items.each do |member_decl|
-          if member_decl.type.scalar? && member_decl.type.floating?
-            W(:W0606, node.location)
-            return
-          end
-        end
-      end
-    end
-  end
-
-  class W0645 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0645
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_kandr_function_definition += method(:check)
-    end
-
-    def check(node)
-      if node.type.parameter_types.any? { |type| type.void? }
-        W(:W0645, node.location)
-      end
-    end
-  end
-
-  class W0685 < W0573
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0685
-
-    def check(function_call_expression, function, arg_variables,
-              result_variable)
-      if function.named? && function.name =~ /\A.*scanf\z/
-        format = create_format(function_call_expression,
-                               format_str_index_of(function_call_expression),
-                               arg_variables, @environ)
-        return unless format
-
-        format.conversion_specifiers.each do |cs|
-          next unless cs.scanset
-
-          cs.scanset.scan(/(.)-(.)/).each do |lhs, rhs|
-            W(:W0685, format.location) if lhs.ord > rhs.ord
-          end
-        end
-      end
-    end
-  end
-
-  class W0686 < W0573
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0686
-
-    def check(function_call_expression, function, arg_variables,
-              result_variable)
-      if function.named? && function.name =~ /\A.*scanf\z/
-        format = create_format(function_call_expression,
-                               format_str_index_of(function_call_expression),
-                               arg_variables, @environ)
-        return unless format
-
-        format.conversion_specifiers.each do |cs|
-          next unless cs.scanset
-
-          unless cs.valid_scanset?
-            W(:W0686, format.location)
-          end
-        end
-      end
-    end
-  end
-
-  class W0697 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0697
-
-    def initialize(context)
-      super
-      interp = context[:c_interpreter]
-      interp.on_function_started += method(:start_function)
-      interp.on_function_ended += method(:end_function)
-      interp.on_implicit_return_evaled += method(:check_implicit_return)
-      @current_function = nil
-    end
-
-    private
-    def start_function(function_definition, function)
-      @current_function = function_definition
-    end
-
-    def end_function(function_definition, function)
-      @current_function = nil
-    end
-
-    def check_implicit_return
-      return unless @current_function
-
-      unless @current_function.type.return_type.void?
-        W(:W0697,
-          @current_function.location, @current_function.identifier.value)
-      end
-    end
-  end
-
-  class W0698 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0698
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_ansi_function_definition += method(:start_function)
-      visitor.enter_kandr_function_definition += method(:start_function)
-      visitor.leave_ansi_function_definition += method(:end_function)
-      visitor.leave_kandr_function_definition += method(:end_function)
-      visitor.enter_return_statement += method(:check)
-      @current_function = nil
-    end
-
-    private
-    def start_function(function_definition)
-      @current_function = function_definition
-    end
-
-    def end_function(function_definition)
-      @current_function = nil
-    end
-
-    def check(return_statement)
-      return unless @current_function.explicitly_typed?
-
-      if return_type = @current_function.type.return_type
-        if !return_type.void? && return_statement.expression.nil?
-          W(:W0698, return_statement.location,
-            @current_function.identifier.value)
-        end
-      end
-    end
-  end
-
-  class W0699 < W0698
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0699
-
-    private
-    def check(return_statement)
-      return unless @current_function.implicitly_typed?
-
-      if return_statement.expression.nil?
-        W(:W0699, return_statement.location,
-          @current_function.identifier.value)
-      end
-    end
-  end
-
-  class W0700 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0700
-
-    def initialize(context)
-      super
-      interp = context[:c_interpreter]
-      interp.on_function_started += method(:start_function)
-      interp.on_function_ended += method(:end_function)
-      interp.on_return_stmt_evaled += method(:check_explicit_return)
-      interp.on_implicit_return_evaled += method(:check_implicit_return)
-      @current_function = nil
-    end
-
-    private
-    def start_function(function_definition, function)
-      @current_function = function_definition
-    end
-
-    def end_function(function_definition, function)
-      @current_function = nil
-    end
-
-    def check_explicit_return(return_stmt, result_variable)
-      return unless @current_function
-
-      if @current_function.implicitly_typed? && return_stmt.expression.nil?
-        W(:W0700,
-          @current_function.location, @current_function.identifier.value)
-      end
-    end
-
-    def check_implicit_return
-      return unless @current_function
-
-      if @current_function.implicitly_typed?
-        W(:W0700,
-          @current_function.location, @current_function.identifier.value)
-      end
-    end
-  end
-
-  class W0711 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0711
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_relational_expression += method(:check)
-    end
-
-    private
-    def check(expression)
-      if !expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0711, expression.rhs_operand.location)
-      end
-    end
-  end
-
-  class W0712 < W0711
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0712
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && !expression.rhs_operand.logical?
-        W(:W0712, expression.lhs_operand.location)
-      end
-    end
-  end
-
-  class W0713 < W0711
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0713
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0713, expression.location)
-      end
-    end
-  end
-
-  class W0714 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0714
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_and_expression += method(:check)
-    end
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0714, expression.location)
-      end
-    end
-  end
-
-  class W0715 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0715
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_inclusive_or_expression += method(:check)
-    end
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0715, expression.location)
-      end
-    end
-  end
-
-  class W0716 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0716
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_additive_expression += method(:check)
-      visitor.enter_multiplicative_expression += method(:check)
-      visitor.enter_shift_expression += method(:check)
-      visitor.enter_and_expression += method(:check)
-      visitor.enter_exclusive_or_expression += method(:check)
-      visitor.enter_inclusive_or_expression += method(:check)
-      visitor.enter_compound_assignment_expression += lambda { |expr|
-        case expr.operator.type
-        when "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|="
-          check(expr)
-        end
-      }
-    end
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0716, expression.location)
-      end
-    end
-  end
-
-  class W0717 < W0716
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0717
-
-    private
-    def check(expression)
-      if expression.lhs_operand.logical? && !expression.rhs_operand.logical?
-        W(:W0717, expression.lhs_operand.location)
-      end
-    end
-  end
-
-  class W0718 < W0716
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0718
-
-    private
-    def check(expression)
-      if !expression.lhs_operand.logical? && expression.rhs_operand.logical?
-        W(:W0718, expression.rhs_operand.location)
-      end
-    end
-  end
-
-  class W0726 < W0698
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0726
-
-    private
-    def check(return_statement)
-      return unless return_statement.expression
-
-      if return_type = @current_function.type.return_type
-        if return_type.void? && (return_type.const? || return_type.volatile?)
-          W(:W0726, return_statement.location,
-            @current_function.identifier.value)
-        end
-      end
-    end
-  end
-
-  class W0732 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0732
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_logical_and_expression += method(:check)
-    end
-
-    private
-    def check(expr)
-      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
-        if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
-          W(:W0732, expr.location)
-        end
-      end
-    end
-  end
-
-  class W0733 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0733
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_logical_or_expression += method(:check)
-    end
-
-    private
-    def check(expr)
-      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
-        if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
-          W(:W0733, expr.location)
-        end
-      end
-    end
-  end
-
-  class W0734 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0734
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_logical_and_expression += method(:check)
-      visitor.enter_logical_or_expression += method(:check)
-    end
-
-    private
-    def check(expr)
-      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
-        unless expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
-          W(:W0734, expr.lhs_operand.location)
-        end
-      end
-    end
-  end
-
-  class W0735 < W0734
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0735
-
-    private
-    def check(expr)
-      if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
-        unless expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
-          W(:W0735, expr.rhs_operand.location)
-        end
-      end
-    end
-  end
-
-  class W0781 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0781
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_switch_statement += method(:enter_switch_statement)
-      visitor.leave_switch_statement += method(:check)
-      visitor.enter_case_labeled_statement += method(:add_exec_path)
-      visitor.enter_default_labeled_statement += method(:add_exec_path)
-      @exec_path_nums = []
-    end
-
-    private
-    def enter_switch_statement(node)
-      @exec_path_nums.push(0)
-    end
-
-    def check(node)
-      if exec_path_num = @exec_path_nums.last and exec_path_num < 2
-        W(:W0781, node.location)
-      end
-      @exec_path_nums.pop
-    end
-
-    def add_exec_path(node)
-      @exec_path_nums[-1] += 1 if node.executed?
-    end
-  end
-
-  class W0801 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0801
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_struct_type_declaration += method(:check)
-      visitor.enter_union_type_declaration += method(:check)
-    end
-
-    private
-    def check(node)
-      W(:W0801, node.location) if node.type.members.empty?
-    end
-  end
-
-  class W0809 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W0809
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_function_declaration += method(:check_function_name)
-      visitor.enter_variable_declaration += method(:check_variable_name)
-      visitor.enter_variable_definition += method(:check_variable_name)
-      visitor.enter_parameter_definition += method(:check_variable_name)
-      visitor.enter_typedef_declaration += method(:check_typedef_name)
-      visitor.enter_struct_type_declaration += method(:check_tag_name)
-      visitor.enter_union_type_declaration += method(:check_tag_name)
-      visitor.enter_enum_type_declaration += method(:check_tag_name)
-      visitor.enter_enumerator += method(:check_enumerator_name)
-      visitor.enter_kandr_function_definition += method(:enter_function)
-      visitor.enter_ansi_function_definition += method(:enter_function)
-      visitor.leave_kandr_function_definition += method(:leave_function)
-      visitor.leave_ansi_function_definition += method(:leave_function)
-      @function_def_level = 0
-    end
-
-    private
-    def check_function_name(function_decl)
-      check_object_name(function_decl)
-    end
-
-    def check_variable_name(variable_decl_or_def)
-      check_object_name(variable_decl_or_def)
-    end
-
-    def check_typedef_name(typedef_decl)
-      if typedef_decl.identifier
-        case name = typedef_decl.identifier.value
-        when /\A__/, /\A_[A-Z]/, /\A_/
-          W(:W0809, typedef_decl.location, name)
-        end
-      end
-    end
-
-    def check_tag_name(type_decl)
-      if type_decl.identifier
-        case name = type_decl.identifier.value
-        when /\A__adlint/
-          # NOTE: To ignore AdLint internal tag names.
-        when /\A__/, /\A_[A-Z]/, /\A_/
-          W(:W0809, type_decl.location, name)
-        end
-      end
-    end
-
-    def check_enumerator_name(enumerator)
-      if enumerator.identifier
-        case name = enumerator.identifier.value
-        when /\A__/, /\A_[A-Z]/, /\A_/
-          W(:W0809, enumerator.location, name)
-        end
-      end
-    end
-
-    def enter_function(node)
-      check_object_name(node)
-      @function_def_level += 1
-    end
-
-    def leave_function(node)
-      @function_def_level -= 1
-    end
-
-    def check_object_name(decl_or_def)
-      if decl_or_def.identifier
-        case name = decl_or_def.identifier.value
-        when /\A__/, /\A_[A-Z]/
-          W(:W0809, decl_or_def.location, name)
-        when /\A_/
-          check_filelocal_object_name(name, decl_or_def)
-        end
-      end
-    end
-
-    def check_filelocal_object_name(name, decl_or_def)
-      if @function_def_level == 0
-        if scs = decl_or_def.storage_class_specifier and scs.type == :STATIC
-          W(:W0809, decl_or_def.location, name)
-        end
-      end
-    end
-  end
-
-  class W1030 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1030
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_generic_labeled_statement += method(:check)
-      visitor.enter_ansi_function_definition += method(:enter_function)
-      visitor.leave_ansi_function_definition += method(:leave_function)
-      visitor.enter_kandr_function_definition += method(:enter_function)
-      visitor.leave_kandr_function_definition += method(:leave_function)
-      @labels = nil
-    end
-
-    private
-    def check(generic_labeled_statement)
-      return unless @labels
-
-      label = generic_labeled_statement.label
-      if @labels.include?(label.value)
-        W(:W1030, label.location, label.value)
-      else
-        @labels.add(label.value)
-      end
-    end
-
-    def enter_function(node)
-      @labels = Set.new
-    end
-
-    def leave_function(node)
-      @labels = nil
-    end
-  end
-
-  class W1033 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1033
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_ansi_function_definition += method(:check)
-      visitor.enter_kandr_function_definition += method(:check)
-      visitor.enter_function_declaration += method(:check)
-    end
-
-    private
-    def check(definition_or_declaration)
-      if return_type = definition_or_declaration.type.return_type
-        if return_type.const? || return_type.volatile?
-          W(:W1033, definition_or_declaration.location)
-        end
-      end
-    end
-  end
-
-  class W1066 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1066
-
-    def initialize(context)
-      super
-      @interp = context[:c_interpreter]
-      @interp.on_explicit_conv_performed += method(:check)
-      @interp.on_function_started += method(:clear_rvalues)
-      @interp.on_additive_expr_evaled += method(:handle_additive)
-      @interp.on_multiplicative_expr_evaled += method(:handle_multiplicative)
-      @rvalues = nil
-    end
-
-    private
-    def check(*, orig_var, result_var)
-      if @rvalues && orig_var.type.floating?
-        case expr = @rvalues[orig_var]
-        when C::AdditiveExpression, C::MultiplicativeExpression
-          if orig_var.type.same_as?(from_type) &&
-              result_var.type.same_as?(to_type)
-            W(message_id, expr.location)
-          end
-        end
-      end
-    end
-
-    def clear_rvalues(*)
-      @rvalues = {}
-    end
-
-    def handle_additive(expr, lhs_var, rhs_var, result_var)
-      memorize_rvalue_derivation(result_var, expr)
-    end
-
-    def handle_multiplicative(expr, lhs_var, rhs_var, result_var)
-      unless expr.operator.type == "%"
-        memorize_rvalue_derivation(result_var, expr)
-      end
-    end
-
-    def memorize_rvalue_derivation(rvalue_holder, expr)
-      @rvalues[rvalue_holder] = expr if @rvalues
-    end
-
-    def from_type
-      @interp.float_type
-    end
-
-    def to_type
-      @interp.double_type
-    end
-
-    def message_id
-      self.class.name.sub(/\A.*::/, "").intern
-    end
-  end
-
-  class W1067 < W1066
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1067
-
-    private
-    def from_type
-      @interp.float_type
-    end
-
-    def to_type
-      @interp.long_double_type
-    end
-  end
-
-  class W1068 < W1066
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1068
-
-    private
-    def from_type
-      @interp.double_type
-    end
-
-    def to_type
-      @interp.long_double_type
-    end
-  end
-
-  class W1069 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1069
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_ansi_function_definition += method(:enter_function)
-      visitor.enter_kandr_function_definition += method(:enter_function)
-      visitor.enter_compound_statement += method(:enter_compound_stmt)
-      visitor.leave_compound_statement += method(:leave_compound_stmt)
-      visitor.enter_if_else_statement += method(:enter_if_else_stmt)
-      visitor.leave_if_else_statement += method(:leave_if_else_stmt)
-      @if_else_stmt_chain_stack = []
-    end
-
-    private
-    def enter_function(*)
-      @if_else_stmt_chain_stack = []
-    end
-
-    def enter_compound_stmt(*)
-      @if_else_stmt_chain_stack.push([])
-    end
-
-    def leave_compound_stmt(*)
-      @if_else_stmt_chain_stack.pop
-    end
-
-    def enter_if_else_stmt(node)
-      @if_else_stmt_chain_stack.last.push(node)
-      if node.else_statement.kind_of?(C::IfStatement)
-        W(:W1069, @if_else_stmt_chain_stack.last.first.location)
-      end
-    end
-
-    def leave_if_else_stmt(*)
-      @if_else_stmt_chain_stack.last.pop
-    end
-  end
-
-  class W1070 < W0781
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1070
-
-    private
-    def check(node)
-      if exec_path_num = @exec_path_nums.last and exec_path_num == 2
-        W(:W1070, node.location)
-      end
-      @exec_path_nums.pop
-    end
-
-    def add_exec_path(node)
-      @exec_path_nums[-1] += 1
-    end
-  end
-
-  class W1072 < PassiveCodeCheck
-    def_registrant_phase C::Prepare2Phase
-
-    # NOTE: All messages of cc1-phase code check should be unique till function
-    #       step-in analysis is supported.
-    ensure_uniqueness_of :W1072
-
-    def initialize(context)
-      super
-      visitor = context[:c_visitor]
-      visitor.enter_goto_statement += method(:warn_goto)
-    end
-
-    private
-    def warn_goto(node)
-       W(:W1072, node.location)
-    end
-  end
-
-end
-end
-end