adlint 1.4.0 → 1.6.0

data/MANIFEST

@@ -38,6 +38,7 @@ lib/adlint/c/const.rb
 lib/adlint/c/conv.rb
 lib/adlint/c/ctrlexpr.rb
 lib/adlint/c/domain.rb
+lib/adlint/c/enum.rb
 lib/adlint/c/environ.rb
 lib/adlint/c/expr.rb
 lib/adlint/c/format.rb
@@ -61,6 +62,7 @@ lib/adlint/c/util.rb
 lib/adlint/c/value.rb
 lib/adlint/code.rb
 lib/adlint/cpp.rb
+lib/adlint/cpp/asm.rb
 lib/adlint/cpp/code.rb
 lib/adlint/cpp/constexpr.y
 lib/adlint/cpp/constexpr.rb
@@ -113,6 +115,7 @@ share/demo/bad_conv/bad_conv.c
 share/demo/bad_enum/bad_enum.c
 share/demo/bad_indent/bad_indent.c
 share/demo/bad_init/bad_init.c
+share/demo/bad_label/bad_label.c
 share/demo/bad_line/bad_line.c
 share/demo/bad_macro/bad_macro.c
 share/demo/bad_return/bad_return.c
@@ -140,6 +143,7 @@ share/demo/indirect_recur/indirect_recur_2.h
 share/demo/indirect_recur/indirect_recur_3.c
 share/demo/indirect_recur/indirect_recur_3.h
 share/demo/indirect_recur/indirect_recur_4.c
+share/demo/inline_asm/inline_asm.c
 share/demo/intro_demo/intro_demo.c
 share/demo/intro_demo/intro_demo.h
 share/demo/intro_demo/useless_header.h
@@ -180,6 +184,8 @@ share/demo/octal_const/octal_const.c
 share/demo/output_by_param/output_by_param.c
 share/demo/overflow/overflow.c
 share/demo/press_release/press_release.c
+share/demo/redundant_select/redundant_select.c
+share/demo/reserved_ident/reserved_ident.c
 share/demo/retn_lvar_addr/retn_lvar_addr.c
 share/demo/sequence_point/sequence_point.c
 share/demo/shift_expr/shift_expr.c

data/NEWS

@@ -21,6 +21,49 @@
 
 ++
 
+=== \AdLint 1.6.0 is released (2012-04-06)
+
+==== Changes since the 1.4.0 release
+
+* Add W0541 detection
+* Add W0573 detection
+* Add W0579 detection
+* Add W0685 detection
+* Add W0686 detection
+* Add W0781 detection
+* Add W0787 detection
+* Add W0788 detection
+* Add W0789 detection
+* Add W0807 detection
+* Add W0808 detection
+* Add W0809 detection
+* Add W1030 detection
+* Add W1053 detection
+* Add W1054 detection
+* Add W1055 detection
+* Add W1056 detection
+* Add W1057 detection
+* Add W1058 detection
+* Add W1059 detection
+* Add W1060 detection
+* Add W1061 detection
+* Add W1062 detection
+* Add W1063 detection
+* Fix W0027 detection not to warn when a pointer variable is compared
+  with NULL constant
+* Fix W0728, W0729 and W0730 detections not to warn when the target
+  is a variable of the other enum type
+* Fix W0104 detection not to warn about invariant parameter of array
+  type whose base type is qualified as const
+* Fix bad W0031, W0100, W0104, W0459 and W0460 detections
+* Fix bad FN_UNUV measurement
+* Update the user's guide in Japanese
+* Update the user's guide in English
+
+See the file
+{ChangeLog}[http://adlint.sourceforge.net/pmwiki/upload.d/Main/ChangeLog]
+for more details.
+
 === \AdLint 1.4.0 is released (2012-03-29)
 
 ==== Changes since the 1.2.0 release
@@ -56,10 +99,6 @@
 * Update the user's guide in Japanese
 * Update the user's guide in English
 
-See the file
-{ChangeLog}[http://adlint.sourceforge.net/pmwiki/upload.d/Main/ChangeLog]
-for more details.
-
 === \AdLint 1.2.0 is released (2012-03-21)
 
 ==== Changes since the 1.0.0 release

data/etc/mesg.d/en_US/messages.yml

@@ -36,7 +36,7 @@
 #     X9999: "Your custom message for the fatal error of #9999."
 #     E9999: "Your custom message for the error of #9999."
 
-version: "1.4.0"
+version: "1.6.0"
 
 message_definition:
   X0001: "An unknown exception `%s' is found."

data/etc/mesg.d/ja_JP/messages.yml

@@ -36,7 +36,7 @@
 #     X9999: "Your custom message for the fatal error of #9999."
 #     E9999: "Your custom message for the error of #9999."
 
-version: "1.4.0"
+version: "1.6.0"
 
 message_definition:
   X0001: "不明な例外条件 `%s' を検出しました。"

data/lib/adlint/c.rb

@@ -36,6 +36,7 @@ require "adlint/c/ctrlexpr"
 require "adlint/c/const"
 require "adlint/c/conv"
 require "adlint/c/domain"
+require "adlint/c/enum"
 require "adlint/c/environ"
 require "adlint/c/expr"
 require "adlint/c/format"

data/lib/adlint/c/enum.rb

@@ -0,0 +1,52 @@
+# C Enumerators.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@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/c/syntax"
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class EnumeratorTable
+    def initialize
+      @enumerators = {}
+    end
+
+    def define(enumerator)
+      @enumerators[enumerator.identifier.value] = enumerator
+    end
+
+    def lookup(name_str)
+      @enumerators[name_str]
+    end
+  end
+
+end
+end

data/lib/adlint/c/expr.rb

@@ -45,16 +45,10 @@ module C #:nodoc:
         variable.declarations_and_definitions.each do |decl_or_def|
           decl_or_def.mark_as_referred_by(node.identifier)
         end
-        if variable.type.array?
-          # NOTE: Array object is referred to derive the start address.
-          # NOTE: Kill this notification not to confuse the W0459 and W0460
-          #       detections of the expression-statement `a[i] = 0;' when
-          #       contents of `a' is not initialized.
-          # _notify_variable_value_referred(node, variable)
-          variable = temporary_variable(pointer_type(variable.type.base_type),
-                                        pointer_value_of(variable))
-        end
         _notify_object_referred(node, variable)
+        # NOTE: Array object will be converted into its start address by the
+        #       outer expression.  So, it is correct to return an array object
+        #       itself.
         return variable
       end
 
@@ -68,40 +62,43 @@ module C #:nodoc:
 
       if enumerator = enumerator_named(node.identifier.value)
         enumerator.mark_as_referred_by(node.identifier)
-        return temporary_variable(enumerator.type, ScalarValue.of(enumerator.value))
+        return temporary_variable(enumerator.type,
+                                  ScalarValue.of(enumerator.value))
       end
 
       define_implicit_function(node.identifier.value)
     end
-    module_function :execute_object_specifier
 
     def execute_array_subscript_expression(node, object, subscript)
       unless object.variable? && (object.type.array? || object.type.pointer?)
         return temporary_variable
       end
-      _notify_variable_value_referred(node, object)
 
       array_or_pointer = object
 
       result_type = array_or_pointer.type.unqualify.base_type
       result_type = pointer_type(result_type) if result_type.array?
 
-      unless subscript.variable? && subscript.value.scalar? &&
-          subscript.value.exist?
-        return temporary_variable(result_type)
-      end
-      _notify_variable_value_referred(node, subscript)
-
       case
       when array_or_pointer.type.array?
         array = array_or_pointer
+        # NOTE: An array-subscript-expression with an array object only refers
+        #       the array object, never refer the value of the array object.
       when array_or_pointer.type.pointer?
         if pointee = pointee_of(array_or_pointer) and pointee.type.array?
           array = pointee
-          _notify_variable_value_referred(node, array)
         end
+        # NOTE: An array-subscript-expression with a pointer object do refers
+        #       the value of the pointer object.
+        _notify_variable_value_referred(node, array_or_pointer)
       end
 
+      unless subscript.variable? && subscript.value.scalar? &&
+          subscript.value.exist?
+        return temporary_variable(result_type)
+      end
+      _notify_variable_value_referred(node, subscript)
+
       # NOTE: An array subscript converted to `int' implicitly.
       if subscript.type.same_as?(int_type)
         int_subscript = subscript
@@ -118,21 +115,16 @@ module C #:nodoc:
       subscript_value = int_subscript.value.unique_sample
       if array and inner_variable = array.inner_variable_at(subscript_value)
         _notify_object_referred(node, inner_variable)
-        if inner_variable.type.array?
-          result = temporary_variable(result_type,
-                                      pointer_value_of(inner_variable))
-        else
+        if inner_variable.type.same_as?(result_type)
           result = inner_variable
         end
-      else
-        result = temporary_variable(result_type)
       end
+      result ||= temporary_variable(result_type)
 
       notify_array_subscript_expr_evaled(node, array_or_pointer,
                                          int_subscript, array, result)
       result
     end
-    module_function :execute_array_subscript_expression
 
     def execute_function_call_expression(node, object, args)
       if object.function?
@@ -151,8 +143,6 @@ module C #:nodoc:
       end
       _notify_variable_value_referred(node, object)
 
-      args.each { |arg, expr| _notify_variable_value_referred(expr, arg) }
-
       # NOTE: The ISO C99 standard saids;
       #
       # 6.5.2.2 Function calls
@@ -166,13 +156,12 @@ module C #:nodoc:
 
       result = function.call(interpreter, node, args)
       unless function.builtin?
-        notify_function_call_expr_evaled(node, function,
-                                         args.map { |arg, expr| arg }, result)
+        arg_variables = args.map { |arg, expr| object_to_variable(arg) }
+        notify_function_call_expr_evaled(node, function, arg_variables, result)
       end
 
       result
     end
-    module_function :execute_function_call_expression
 
     def execute_member_access_by_value_expression(node, object)
       unless object.variable? && object.type.composite?
@@ -181,7 +170,8 @@ module C #:nodoc:
       variable = object
 
       member_variable = variable.inner_variable_named(node.identifier.value)
-      _notify_variable_value_referred(node, variable)
+      # NOTE: A member-access-by-value-expression only refers the composite
+      #       object, never refer the value of the composite object.
 
       # NOTE: `member_variable' is nil when this expression represents the
       #       direct member access extension.
@@ -189,16 +179,11 @@ module C #:nodoc:
 
       if member_variable
         _notify_object_referred(node, member_variable)
-        if member_variable.type.array?
-          type = pointer_type(member_variable.type.base_type)
-          return temporary_variable(type, pointer_value_of(member_variable))
-        end
         member_variable
       else
         temporary_variable
       end
     end
-    module_function :execute_member_access_by_value_expression
 
     def execute_member_access_by_pointer_expression(node, object)
       unqualified_type = object.type.unqualify
@@ -218,6 +203,8 @@ module C #:nodoc:
           end
         end
       end
+      # NOTE: A member-access-by-pointer-expression do refers the value of the
+      #       pointer object.
       _notify_variable_value_referred(node, pointer)
 
       if pointee && pointee.type.composite?
@@ -233,16 +220,11 @@ module C #:nodoc:
 
       if member_variable
         _notify_object_referred(node, member_variable)
-        if member_variable.type.array?
-          type = pointer_type(member_variable.type.base_type)
-          return temporary_variable(type, pointer_value_of(member_variable))
-        end
         member_variable
       else
         temporary_variable
       end
     end
-    module_function :execute_member_access_by_pointer_expression
 
     def execute_postfix_increment_expression(node, object)
       return temporary_variable unless object.variable? && object.type.scalar?
@@ -264,7 +246,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_postfix_increment_expression
 
     def execute_postfix_decrement_expression(node, object)
       return temporary_variable unless object.variable? && object.type.scalar?
@@ -286,7 +267,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_postfix_decrement_expression
 
     def execute_prefix_increment_expression(node, object)
       return temporary_variable unless object.variable? && object.type.scalar?
@@ -308,7 +288,6 @@ module C #:nodoc:
 
       variable
     end
-    module_function :execute_prefix_increment_expression
 
     def execute_prefix_decrement_expression(node, object)
       return temporary_variable unless object.variable? && object.type.scalar?
@@ -330,7 +309,6 @@ module C #:nodoc:
 
       variable
     end
-    module_function :execute_prefix_decrement_expression
 
     def execute_address_expression(node, object)
       # NOTE: An address-expression does not read the value of the object.  But
@@ -340,7 +318,6 @@ module C #:nodoc:
 
       temporary_variable(pointer_type(object.type), pointer_value_of(object))
     end
-    module_function :execute_address_expression
 
     def execute_indirection_expression(node, object)
       return temporary_variable unless object.variable? && object.type.pointer?
@@ -376,7 +353,6 @@ module C #:nodoc:
 
       pointee
     end
-    module_function :execute_indirection_expression
 
     def execute_unary_arithmetic_expression(node, object)
       variable = object_to_variable(object)
@@ -404,7 +380,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_unary_arithmetic_expression
 
     def execute_cast_expression(node, object)
       resolve_unresolved_type(node.type_name)
@@ -418,7 +393,6 @@ module C #:nodoc:
 
       converted
     end
-    module_function :execute_cast_expression
 
     def execute_multiplicative_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -478,7 +452,6 @@ module C #:nodoc:
                                         result)
       result
     end
-    module_function :execute_multiplicative_expression
 
     def execute_additive_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -531,7 +504,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_additive_expression
 
     def execute_shift_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -592,7 +564,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_shift_expression
 
     def execute_relational_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -652,7 +623,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_relational_expression
 
     def execute_equality_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -706,7 +676,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_equality_expression
 
     def execute_and_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -749,7 +718,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_and_expression
 
     def execute_exclusive_or_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -792,7 +760,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_exclusive_or_expression
 
     def execute_inclusive_or_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
@@ -835,7 +802,6 @@ module C #:nodoc:
 
       result
     end
-    module_function :execute_inclusive_or_expression
 
     def execute_simple_assignment_expression(node, lhs_object, rhs_object)
       return lhs_object unless lhs_object.variable?
@@ -870,7 +836,6 @@ module C #:nodoc:
 
       lhs_variable
     end
-    module_function :execute_simple_assignment_expression
 
     def execute_compound_assignment_expression(node, lhs_object, rhs_object)
       unless lhs_object.variable? && lhs_object.type.scalar?
@@ -911,7 +876,6 @@ module C #:nodoc:
 
       lhs_variable
     end
-    module_function :execute_compound_assignment_expression
 
     def execute_mul_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -962,7 +926,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_mul_then_assign_expression
 
     def execute_div_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1014,7 +977,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_div_then_assign_expression
 
     def execute_mod_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1066,7 +1028,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_mod_then_assign_expression
 
     def execute_add_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1117,7 +1078,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_add_then_assign_expression
 
     def execute_sub_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1168,7 +1128,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_sub_then_assign_expression
 
     def execute_shl_then_assign_expression(node, lhs_variable, rhs_variable)
       # NOTE: The ISO C99 standard saids;
@@ -1227,7 +1186,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_shl_then_assign_expression
 
     def execute_shr_then_assign_expression(node, lhs_variable, rhs_variable)
       # NOTE: The ISO C99 standard saids;
@@ -1286,7 +1244,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_shr_then_assign_expression
 
     def execute_and_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1336,7 +1293,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_and_then_assign_expression
 
     def execute_xor_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1387,7 +1343,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_xor_then_assign_expression
 
     def execute_ior_then_assign_expression(node, lhs_variable, rhs_variable)
       lhs_converted, rhs_converted =
@@ -1438,7 +1393,6 @@ module C #:nodoc:
 
       notify_assignment_expr_evaled(node, lhs_variable, result_converted)
     end
-    module_function :execute_ior_then_assign_expression
 
     def _notify_object_referred(node, object)
       case object
@@ -1448,7 +1402,6 @@ module C #:nodoc:
         interpreter.notify_function_referred(node, object)
       end
     end
-    module_function :_notify_object_referred
 
     def _notify_variable_value_referred(node, object)
       if object.variable?
@@ -1459,7 +1412,6 @@ module C #:nodoc:
       #       is referred, notification of the outer variable's value has
       #       already been done in sub expressions.
     end
-    module_function :_notify_variable_value_referred
 
     def _notify_variable_value_updated(node, object)
       if object.variable?
@@ -1473,19 +1425,16 @@ module C #:nodoc:
         _notify_variable_value_updated(node, object.owner)
       end
     end
-    module_function :_notify_variable_value_updated
 
     def _char_array_value(string_literal)
       chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
       ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
     end
-    module_function :_char_array_value
 
     def _wchar_array_value(string_literal)
       chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
       ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
     end
-    module_function :_wchar_array_value
   end
 
   module ExpressionEvaluator
@@ -1525,17 +1474,14 @@ module C #:nodoc:
 
       case node.literal.value
       when /\A"(.*)"\z/
-        array = temporary_variable(array_type(char_type, $1.length + 1),
-                                   _char_array_value($1))
+        temporary_variable(array_type(char_type, $1.length + 1),
+                           _char_array_value($1))
       when /\AL"(.*)"\z/i
-        array = temporary_variable(array_type(wchar_type, $1.length + 1),
-                                   _wchar_array_value($1))
+        temporary_variable(array_type(wchar_type, $1.length + 1),
+                           _wchar_array_value($1))
       else
-        return temporary_variable(pointer_type(char_type))
+        temporary_variable(array_type(char_type))
       end
-
-      temporary_variable(pointer_type(array.type.base_type),
-                         pointer_value_of(array))
     end
 
     def visit_null_constant_specifier(node)
@@ -1851,28 +1797,23 @@ module C #:nodoc:
     def visit_conditional_expression(node)
       checkpoint(node.location)
 
-      condition_object = node.condition.accept(self)
+      condition_variable = object_to_variable(node.condition.accept(self))
 
-      if condition_object.variable?
-        case
-        when condition_object.value.must_be_true?
-          result_object = node.then_expression.accept(self)
-        when condition_object.value.must_be_false?
-          result_object = node.else_expression.accept(self)
-        else
-          then_object = node.then_expression.accept(self)
-          else_object = node.else_expression.accept(self)
-          if then_object.variable? && else_object.variable?
-            result_value =
-              then_object.value.single_value_unified_with(else_object.value)
-            result_object = temporary_variable(then_object.type, result_value)
-          end
-        end
+      case
+      when condition_variable.value.must_be_true?
+        result_variable = object_to_variable(node.then_expression.accept(self))
+      when condition_variable.value.must_be_false?
+        result_variable = object_to_variable(node.else_expression.accept(self))
+      else
+        then_var = object_to_variable(node.then_expression.accept(self))
+        else_var = object_to_variable(node.else_expression.accept(self))
+        result_value = then_var.value.single_value_unified_with(else_var.value)
+        result_variable = temporary_variable(then_var.type, result_value)
       end
 
-      result = result_object ? result_object : temporary_variable
-      notify_conditional_expr_evaled(node, condition_object, result)
-      result
+      notify_conditional_expr_evaled(node, condition_variable, result_variable)
+
+      result_variable
     end
 
     def visit_simple_assignment_expression(node)