adlint 3.0.8 → 3.0.10

data/features/code_check/W0610.feature

@@ -34,3 +34,62 @@ Feature: W0610
       | W0593 | 1    | 21     |
       | W0589 | 2    | 6      |
       | W0593 | 2    | 6      |
+
+  Scenario: no explicit controlling-expression in for-statement
+    Given a target source named "fixture.c" with:
+      """
+      void foo(void)
+      {
+          int i;
+          for (i = 0; ; i++) {
+              if (i < 0) { /* W0610 */
+                  i++;
+              }
+              if (i == 3) { /* OK not W0610 */
+                  i++;
+              }
+              if (i == 5) { /* OK */
+                  break;
+              }
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 1    | 6      |
+      | W0610 | 5    | 15     |
+      | W0613 | 5    | 15     |
+      | W0708 | 9    | 14     |
+      | W9001 | 6    | 13     |
+      | W0114 | 4    | 5      |
+      | W0628 | 1    | 6      |
+
+  Scenario: no explicit controlling-expression in c99-for-statement
+    Given a target source named "fixture.c" with:
+      """
+      void foo(void)
+      {
+          for (int i = 0; ; i++) {
+              if (i < 0) { /* W0610 */
+                  i++;
+              }
+              if (i == 3) { /* OK not W0610 */
+                  i++;
+              }
+              if (i == 5) { /* OK */
+                  break;
+              }
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 1    | 6      |
+      | W0610 | 4    | 15     |
+      | W0613 | 4    | 15     |
+      | W0708 | 8    | 14     |
+      | W9001 | 5    | 13     |
+      | W0114 | 3    | 5      |
+      | W0628 | 1    | 6      |

data/features/code_check/W0612.feature

@@ -0,0 +1,29 @@
+Feature: W0612
+
+  W0612 detects that a controlling expression of the selection-statement always
+  be true.
+
+  Scenario: bitwise and expression as the controlling expression
+    Given a target source named "fixture.c" with:
+      """
+      void foo(unsigned int ui)
+      {
+          while (ui) {
+              if (ui & 1) { /* OK not W0612 */
+                  break;
+              }
+              else {
+                  ui >>= 1;
+              }
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 1    | 6      |
+      | W0167 | 4    | 18     |
+      | W0572 | 4    | 16     |
+      | W0114 | 3    | 5      |
+      | W0114 | 4    | 9      |
+      | W0628 | 1    | 6      |

data/features/code_check/W0613.feature

@@ -0,0 +1,33 @@
+Feature: W0613
+
+  W0613 detects that a controlling expression of the iteration-statement always
+  be false.
+
+  Scenario: array-subscript-expression refers to global constant table
+    Given a target source named "fixture.c" with:
+      """
+      static const int a[256] = { 0, 1, 0, 0, 1 };
+
+      extern unsigned char foo(int);
+
+      int main(void)
+      {
+          int i, j = 0;
+
+          for (i = 0; a[foo(i)]; i++) { /* OK */
+              j++;
+          }
+
+          return j;
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 3    | 22     |
+      | W0246 | 9    | 22     |
+      | W0736 | 1    | 18     |
+      | W0043 | 1    | 27     |
+      | W0950 | 1    | 20     |
+      | W0114 | 9    | 5      |
+      | W0425 | 7    | 12     |

data/features/code_check/W0704.feature

@@ -0,0 +1,25 @@
+Feature: W0704
+
+  W0704 detects that an ordinary identifier is hiding other identifier.
+
+  Scenario: hiding typedef name by enumerator name
+    Given a target source named "fixture.c" with:
+      """
+      typedef double DOUBLE;
+
+      void foo(void)
+      {
+          enum arg_type { INT, DOUBLE } type;
+          type = DOUBLE;
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 3    | 6      |
+      | W0704 | 5    | 26     |
+      | C0001 | 1    | 16     |
+      | W0789 | 5    | 26     |
+      | C0001 | 1    | 16     |
+      | W0100 | 5    | 35     |
+      | W0628 | 3    | 6      |

data/features/code_check/W0705.feature

@@ -360,3 +360,36 @@ Feature: W0705
       | W0502 | 5    | 9      |
       | W0498 | 7    | 18     |
       | W0628 | 3    | 5      |
+
+  Scenario: size of array is specified by the global constant variable
+    Given a target source named "fixture.c" with:
+      """
+      const int size = 2;
+
+      void foo(void)
+      {
+          int i;
+          char a[size];
+          for (i = 0; i < size; i++) {
+              a[i] = (char) 0; /* OK */
+          }
+      }
+
+      void bar(void)
+      {
+          int i;
+          char a[size];
+          for (i = 0; i < size; i++) {
+              a[i] = (char) 0; /* OK */
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 1    | 11     |
+      | W0117 | 3    | 6      |
+      | W0117 | 12   | 6      |
+      | W0628 | 3    | 6      |
+      | W0628 | 12   | 6      |
+      | W0593 | 1    | 11     |

data/features/code_check/W1050.feature

@@ -0,0 +1,43 @@
+Feature: W1050
+
+  W1050 detects that an explicit conversion to signed integer must cause
+  overflow.
+
+  Scenario: conversion from `int' to `signed char'
+    Given a target source named "fixture.c" with:
+      """
+      static void foo(const int i)
+      {
+          if (i > 127) {
+              const signed char c = (signed char) i; /* W1050 */
+          }
+          if (i < -128) {
+              const signed char c = (signed char) i; /* W1050 */
+          }
+
+          if (i > 100) {
+              const signed char c = (signed char) i; /* OK but W1049 */
+          }
+          if (i < -100) {
+              const signed char c = (signed char) i; /* OK but W1049 */
+          }
+
+          if (i > -129 && i < 128) {
+              const signed char c = (signed char) i; /* OK */
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W1076 | 1    | 13     |
+      | W1050 | 4    | 31     |
+      | W1050 | 7    | 31     |
+      | W1049 | 11   | 31     |
+      | W1049 | 14   | 31     |
+      | W0629 | 1    | 13     |
+      | W0489 | 17   | 9      |
+      | W0490 | 17   | 9      |
+      | W0499 | 17   | 9      |
+      | W0502 | 17   | 9      |
+      | W0628 | 1    | 13     |

data/features/code_check/W1071.feature

@@ -79,3 +79,33 @@ Feature: W1071
       | W0104 | 1    | 13     |
       | W1071 | 1    | 5      |
       | W0628 | 1    | 5      |
+
+  Scenario: array-subscript-expression as the controlling expression
+    Given a target source named "fixture.c" with:
+      """
+      struct foo {
+          int len;
+          int ary[];
+      };
+
+      static void foo(struct foo *p)
+      {
+          int i;
+          for (i = 0; i < p->len; i++) {
+              if (p->ary[i]) return;
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W1076 | 6    | 13     |
+      | W0422 | 9    | 22     |
+      | W0422 | 10   | 14     |
+      | W0104 | 6    | 29     |
+      | W0105 | 6    | 29     |
+      | W1071 | 6    | 13     |
+      | W0629 | 6    | 13     |
+      | W0414 | 10   | 24     |
+      | W0114 | 10   | 9      |
+      | W0628 | 6    | 13     |

data/features/code_check/W9001.feature

@@ -29,3 +29,27 @@ Feature: W9001
     When I successfully run `adlint fixture.c` on noarch
     Then the output should exactly match with:
       | mesg  | line | column |
+
+  Scenario: indefinitive controlling variable narrowing
+    Given a target source named "fixture.c" with:
+      """
+      void foo(int i)
+      {
+          if (i > 0) {
+              do {
+                  puts("foo"); /* OK not W9001 */
+              } while (i == -1);
+          }
+      }
+      """
+    When I successfully run `adlint fixture.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0117 | 1    | 6      |
+      | W0109 | 5    | 13     |
+      | W0610 | 6    | 20     |
+      | W0614 | 6    | 20     |
+      | W0104 | 1    | 14     |
+      | W1073 | 5    | 17     |
+      | W0947 | 5    | 18     |
+      | W0628 | 1    | 6      |

data/lib/adlint/cc1/branch.rb

@@ -38,8 +38,8 @@ module Cc1 #:nodoc:
   class Branch
     include BranchOptions
 
-    def initialize(br_group, *opts)
-      @group = br_group
+    def initialize(branch_group, *opts)
+      @group = branch_group
       @options = opts
       @break_event = nil
       @controlling_expression = nil
@@ -103,9 +103,17 @@ module Cc1 #:nodoc:
         # TODO: Study about introducing inter-value-constraints to correctly
         #       manage value domains of controlling variables related with each
         #       other.
-        env.end_versioning(break_with_return?, true)
+        if @group.in_iteration? && !smother_break?
+          env.end_versioning(break_with_return? || break_with_break?, true)
+        else
+          env.end_versioning(break_with_return?, true)
+        end
       else
-        env.end_versioning(break_with_return?, false)
+        if @group.in_iteration? && !smother_break?
+          env.end_versioning(break_with_return? || break_with_break?, false)
+        else
+          env.end_versioning(break_with_return?, false)
+        end
       end
 
       if final?
@@ -167,13 +175,15 @@ module Cc1 #:nodoc:
     include BranchOptions
     include BranchGroupOptions
 
-    def initialize(env, *opts)
+    def initialize(env, parent, *opts)
       @environment = env
+      @parent_group = parent
       @options = opts
       @branches = []
     end
 
     attr_reader :environment
+    attr_reader :parent_group
     attr_reader :branches
 
     def add_options(*new_opts)
@@ -184,14 +194,27 @@ module Cc1 #:nodoc:
       @options.include?(COMPLETE)
     end
 
+    def iteration?
+      @options.include?(ITERATION)
+    end
+
+    def in_iteration?
+      branch_group = @parent_group
+      while branch_group
+        return true if branch_group.iteration?
+        branch_group = branch_group.parent_group
+      end
+      false
+    end
+
     def create_first_branch(*opts)
-      @branches.push(new_br = Branch.new(self, FIRST, *opts))
-      new_br
+      @branches.push(new_branch = Branch.new(self, FIRST, *opts))
+      new_branch
     end
 
     def create_trailing_branch(*opts)
-      @branches.push(new_br = Branch.new(self, *opts))
-      new_br
+      @branches.push(new_branch = Branch.new(self, *opts))
+      new_branch
     end
 
     def all_controlling_variables

data/lib/adlint/cc1/builtin.rb

@@ -73,8 +73,8 @@ module Cc1 #:nodoc:
 
     def call(interp, *, args)
       puts "__adlint__eval"
-      char_ary = interp.pointee_of(args.first.first)
-      if char_ary && char_ary.type.array?
+      char_ary = args.first.first
+      if char_ary.type.array?
         without_nil = char_ary.value.to_single_value.values[0..-2]
         prog_text = without_nil.map { |char| char.unique_sample.chr }.join
         if prog_text.empty?

data/lib/adlint/cc1/conv.rb

@@ -35,55 +35,55 @@ module Cc1 #:nodoc:
   module Conversion
     # NOTE: Host class of this module must include InterpreterMediator.
 
-    def do_conversion(org_var, to_type)
-      if org_var.type.coercible?(to_type)
+    def do_conversion(orig_var, to_type)
+      if orig_var.type.coercible?(to_type)
         # NOTE: Value will be coerced into the destination type in
         #       VariableTableMediator#create_tmpvar.
-        create_tmpvar(to_type, wrap_around_value(org_var, to_type))
+        create_tmpvar(to_type, wrap_around_value(orig_var, to_type))
       else
         nil
       end
     end
 
-    def do_integer_promotion(org_var)
-      return org_var unless org_var.type.integer?
+    def do_integer_promotion(orig_var)
+      return orig_var unless orig_var.type.integer?
 
-      promoted_type = org_var.type.integer_promoted_type
-      if org_var.type.same_as?(promoted_type)
-        org_var
+      promoted_type = orig_var.type.integer_promoted_type
+      if orig_var.type.same_as?(promoted_type)
+        orig_var
       else
-        do_conversion(org_var, promoted_type) || org_var
+        do_conversion(orig_var, promoted_type) || orig_var
       end
     end
 
-    def do_usual_arithmetic_conversion(lhs_org, rhs_org)
-      if lhs_org.type.pointer? && rhs_org.type.pointer?
-        return lhs_org, rhs_org
+    def do_usual_arithmetic_conversion(lhs_orig, rhs_orig)
+      if lhs_orig.type.pointer? && rhs_orig.type.pointer?
+        return lhs_orig, rhs_orig
       end
 
-      arith_type = lhs_org.type.arithmetic_type_with(rhs_org.type)
+      arith_type = lhs_orig.type.arithmetic_type_with(rhs_orig.type)
 
-      if lhs_org.type.same_as?(arith_type)
-        lhs_conved = lhs_org
+      if lhs_orig.type.same_as?(arith_type)
+        lhs_conved = lhs_orig
       else
-        lhs_conved = do_conversion(lhs_org, arith_type) || lhs_org
+        lhs_conved = do_conversion(lhs_orig, arith_type) || lhs_orig
       end
 
-      if rhs_org.type.same_as?(arith_type)
-        rhs_conved = rhs_org
+      if rhs_orig.type.same_as?(arith_type)
+        rhs_conved = rhs_orig
       else
-        rhs_conved = do_conversion(rhs_org, arith_type) || rhs_org
+        rhs_conved = do_conversion(rhs_orig, arith_type) || rhs_orig
       end
 
       return lhs_conved, rhs_conved
     end
 
-    def do_default_argument_promotion(org_var)
-      promoted_type = org_var.type.argument_promoted_type
-      if org_var.type.same_as?(promoted_type)
-        org_var
+    def do_default_argument_promotion(orig_var)
+      promoted_type = orig_var.type.argument_promoted_type
+      if orig_var.type.same_as?(promoted_type)
+        orig_var
       else
-        do_conversion(org_var, promoted_type) || org_var
+        do_conversion(orig_var, promoted_type) || orig_var
       end
     end
 
@@ -115,23 +115,23 @@ module Cc1 #:nodoc:
     end
 
     private
-    def wrap_around_value(org_var, to_type)
-      return org_var.value unless org_var.type.scalar? && to_type.scalar?
+    def wrap_around_value(orig_var, to_type)
+      return orig_var.value unless orig_var.type.scalar? && to_type.scalar?
 
       case
-      when org_var.type.signed? && to_type.unsigned?
+      when orig_var.type.signed? && to_type.unsigned?
         min_val = scalar_value_of(to_type.min)
-        if (org_var.value < min_val).may_be_true?
-          return min_val - org_var.value + scalar_value_of(1)
+        if (orig_var.value < min_val).may_be_true?
+          return min_val - orig_var.value + scalar_value_of(1)
         end
-      when org_var.type.unsigned? && to_type.signed?
+      when orig_var.type.unsigned? && to_type.signed?
         max_val = scalar_value_of(to_type.max)
-        if (org_var.value > max_val).may_be_true?
-          return max_val - org_var.value + scalar_value_of(1)
+        if (orig_var.value > max_val).may_be_true?
+          return max_val - orig_var.value + scalar_value_of(1)
         end
       end
 
-      org_var.value
+      orig_var.value
     end
 
     def void_pointer?(type)