adlint 1.4.0 → 1.6.0

data/lib/adlint/c/message_shima.rb

@@ -35,6 +35,53 @@ require "adlint/message"
 module AdLint #:nodoc:
 module C #:nodoc:
 
+  class W0573 < PassiveMessageDetection
+    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?(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 ScanfFormat.new($1, location, trailing_args, environment)
+        end
+      end
+      nil
+    end
+  end
+
   class W0606 < PassiveMessageDetection
     def initialize(context)
       super
@@ -55,6 +102,46 @@ module C #:nodoc:
     end
   end
 
+  class W0685 < W0573
+    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 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 W0698 < PassiveMessageDetection
     def initialize(context)
       super
@@ -114,6 +201,34 @@ module C #:nodoc:
     end
   end
 
+  class W0781 < PassiveMessageDetection
+    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 < PassiveMessageDetection
     def initialize(context)
       super
@@ -128,6 +243,127 @@ module C #:nodoc:
     end
   end
 
+  class W0809 < PassiveMessageDetection
+    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
+        storage_class_specifier = decl_or_def.storage_class_specifier
+        if storage_class_specifier && storage_class_specifier.type == :STATIC
+          W(:W0809, decl_or_def.location, name)
+        end
+      end
+    end
+  end
+
+  class W1030 < PassiveMessageDetection
+    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 < PassiveMessageDetection
     def initialize(context)
       super

data/lib/adlint/c/metric.rb

@@ -291,6 +291,7 @@ module C #:nodoc:
       interp.on_function_ended += method(:leave_function)
       interp.on_variable_defined += method(:define_variable)
       interp.on_parameter_defined += method(:define_variable)
+      interp.on_variable_referred += method(:refer_variable)
       interp.on_variable_value_referred += method(:read_variable)
       interp.on_variable_value_updated += method(:write_variable)
       @current_function = nil
@@ -329,6 +330,14 @@ module C #:nodoc:
       end
     end
 
+    def refer_variable(expression, variable)
+      return unless @current_function
+
+      if variable.named? && @variables[variable.name]
+        @variables[variable.name] += 1
+      end
+    end
+
     def read_variable(expression, variable)
       return unless @current_function
 

data/lib/adlint/c/object.rb

@@ -661,14 +661,19 @@ module C #:nodoc:
               interpreter.do_conversion(arg, param_type) ||
               interpreter.temporary_variable(param_type)
           else
-            next
+            converted = arg
           end
         else
           converted = interpreter.do_default_argument_promotion(arg)
-          next if arg.type.same_as?(converted.type)
         end
 
-        if converted
+        # NOTE: Value of the argument is referred when the assignment to the
+        #       parameter is performed.
+        if arg.variable? && !arg.type.array?
+          interpreter.notify_variable_value_referred(expr, arg)
+        end
+
+        if converted && arg != converted
           interpreter.notify_implicit_conv_performed(expr, arg, converted)
         end
       end
@@ -677,26 +682,40 @@ module C #:nodoc:
     def return_values_via_pointer_arguments(interpreter, funcall_expr, args)
       args.zip(type.parameter_types).each do |(arg, expr), param_type|
         next if param_type && param_type.void?
-        next unless arg.variable? && arg.value.scalar?
+        next unless arg.variable? && (arg.type.pointer? || arg.type.array?)
 
         param_type = param_type.unqualify if param_type
 
-        if param_type && param_type.pointer? && !param_type.base_type.const? or
-            param_type.nil? && arg.type.pointer?
-          if pointee = interpreter.pointee_of(arg) and
-              pointee.designated_by_lvalue? && pointee.variable?
-            pointee.assign!(pointee.type.return_value)
-            interpreter.notify_variable_value_updated(expr, pointee)
-
-            # NOTE: Returning a value via a pointer parameter can be considered
-            #       as an evaluation of a statement-expression with a
-            #       simple-assignment-expression.
-            #       Control will reach to a sequence-point at the end of a full
-            #       expression.
-            interpreter.notify_sequence_point_reached(
-              SequencePoint.new(funcall_expr, false))
+        case
+        when param_type.nil? && (arg.type.pointer? || arg.type.array?),
+             param_type && param_type.pointer? && !param_type.base_type.const?,
+             param_type && param_type.array? && !param_type.base_type.const?
+        else
+          next
+        end
+
+        case
+        when arg.type.pointer?
+          pointee = interpreter.pointee_of(arg)
+          if pointee && pointee.designated_by_lvalue? && pointee.variable?
+            sink = pointee
+          else
+            next
           end
+        when arg.type.array?
+          sink = arg
         end
+
+        sink.assign!(sink.type.return_value)
+        interpreter.notify_variable_value_updated(expr, sink)
+
+        # NOTE: Returning a value via a pointer parameter can be considered as
+        #       an evaluation of a statement-expression with a
+        #       simple-assignment-expression.
+        #       Control will reach to a sequence-point at the end of a full
+        #       expression.
+        interpreter.notify_sequence_point_reached(
+          SequencePoint.new(funcall_expr, false))
       end
     end
   end
@@ -1009,19 +1028,5 @@ module C #:nodoc:
     end
   end
 
-  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/parser.rb

@@ -70,7 +70,7 @@ def value_of(token)
   token == "$" ? "EOF" : token.value
 end
 
-def create_unnamed_type_name(base_token)
+def create_unnamed_tag_name(base_token)
   Token.new(:IDENTIFIER, "__adlint__unnamed_#{@unnamed_type_no += 1}",
             base_token.location)
 end
@@ -2342,7 +2342,7 @@ module_eval(<<'.,.,', 'parser.y', 904)
   def _reduce_126(val, _values, result)
             checkpoint(val[0].location)
 
-        result = StructSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = StructSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       
@@ -2354,7 +2354,7 @@ module_eval(<<'.,.,', 'parser.y', 912)
   def _reduce_127(val, _values, result)
             checkpoint(val[0].location)
 
-        result = StructSpecifier.new(create_unnamed_type_name(val[0]), [])
+        result = StructSpecifier.new(create_unnamed_tag_name(val[0]), [])
         result.head_token = val[0]
         result.tail_token = val[2]
       
@@ -2366,7 +2366,7 @@ module_eval(<<'.,.,', 'parser.y', 920)
   def _reduce_128(val, _values, result)
             checkpoint(val[0].location)
 
-        result = UnionSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = UnionSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       
@@ -2378,7 +2378,7 @@ module_eval(<<'.,.,', 'parser.y', 928)
   def _reduce_129(val, _values, result)
             checkpoint(val[0].location)
 
-        result = UnionSpecifier.new(create_unnamed_type_name(val[0]), [])
+        result = UnionSpecifier.new(create_unnamed_tag_name(val[0]), [])
         result.head_token = val[0]
         result.tail_token = val[2]
       
@@ -2578,7 +2578,7 @@ module_eval(<<'.,.,', 'parser.y', 1076)
   def _reduce_146(val, _values, result)
             checkpoint(val[0].location)
 
-        result = EnumSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = EnumSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       
@@ -2602,7 +2602,7 @@ module_eval(<<'.,.,', 'parser.y', 1092)
   def _reduce_148(val, _values, result)
             checkpoint(val[0].location)
 
-        result = EnumSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = EnumSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[4]
       

data/lib/adlint/c/parser.y

@@ -904,7 +904,7 @@ struct_or_union_specifier
       {
         checkpoint(val[0].location)
 
-        result = StructSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = StructSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       }
@@ -912,7 +912,7 @@ struct_or_union_specifier
       {
         checkpoint(val[0].location)
 
-        result = StructSpecifier.new(create_unnamed_type_name(val[0]), [])
+        result = StructSpecifier.new(create_unnamed_tag_name(val[0]), [])
         result.head_token = val[0]
         result.tail_token = val[2]
       }
@@ -920,7 +920,7 @@ struct_or_union_specifier
       {
         checkpoint(val[0].location)
 
-        result = UnionSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = UnionSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       }
@@ -928,7 +928,7 @@ struct_or_union_specifier
       {
         checkpoint(val[0].location)
 
-        result = UnionSpecifier.new(create_unnamed_type_name(val[0]), [])
+        result = UnionSpecifier.new(create_unnamed_tag_name(val[0]), [])
         result.head_token = val[0]
         result.tail_token = val[2]
       }
@@ -1076,7 +1076,7 @@ enum_specifier
       {
         checkpoint(val[0].location)
 
-        result = EnumSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = EnumSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
       }
@@ -1092,7 +1092,7 @@ enum_specifier
       {
         checkpoint(val[0].location)
 
-        result = EnumSpecifier.new(create_unnamed_type_name(val[0]), val[2])
+        result = EnumSpecifier.new(create_unnamed_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[4]
       }
@@ -2078,7 +2078,7 @@ def value_of(token)
   token == "$" ? "EOF" : token.value
 end
 
-def create_unnamed_type_name(base_token)
+def create_unnamed_tag_name(base_token)
   Token.new(:IDENTIFIER, "__adlint__unnamed_#{@unnamed_type_no += 1}",
             base_token.location)
 end