adlint 3.0.8 → 3.0.10

data/lib/adlint/cc1/parser.y

@@ -985,6 +985,9 @@ enum_specifier
         result = EnumSpecifier.new(create_anon_tag_name(val[0]), val[2])
         result.head_token = val[0]
         result.tail_token = val[3]
+        result.enumerators.each do |enum|
+          @lexer.add_enumerator_name(enum.identifier)
+        end
       }
     | ENUM IDENTIFIER "{" enumerator_list "}"
       {
@@ -992,6 +995,9 @@ enum_specifier
         result = EnumSpecifier.new(val[1], val[3])
         result.head_token = val[0]
         result.tail_token = val[4]
+        result.enumerators.each do |enum|
+          @lexer.add_enumerator_name(enum.identifier)
+        end
       }
     | ENUM "{" enumerator_list "," "}"
       {
@@ -1000,6 +1006,9 @@ enum_specifier
                                    val[2], val[3])
         result.head_token = val[0]
         result.tail_token = val[4]
+        result.enumerators.each do |enum|
+          @lexer.add_enumerator_name(enum.identifier)
+        end
       }
     | ENUM IDENTIFIER "{" enumerator_list "," "}"
       {
@@ -1007,6 +1016,9 @@ enum_specifier
         result = EnumSpecifier.new(val[1], val[3], val[4])
         result.head_token = val[0]
         result.tail_token = val[5]
+        result.enumerators.each do |enum|
+          @lexer.add_enumerator_name(enum.identifier)
+        end
       }
     | ENUM IDENTIFIER
       {
@@ -1031,14 +1043,14 @@ enumerator_list
     ;
 
 enumerator
-    : IDENTIFIER
+    : enumerator_name
       {
         checkpoint(val[0].location)
         sym = @sym_tbl.create_new_symbol(EnumeratorName, val[0])
         result = Enumerator.new(val[0], nil, sym)
         result.head_token = result.tail_token = val[0]
       }
-    | IDENTIFIER "=" constant_expression
+    | enumerator_name "=" constant_expression
       {
         checkpoint(val[0].location)
         val[2].full = true
@@ -1049,6 +1061,14 @@ enumerator
       }
     ;
 
+enumerator_name
+    : IDENTIFIER
+    | TYPEDEF_NAME
+      {
+        result = val[0].class.new(:IDENTIFIER, val[0].value, val[0].location)
+      }
+    ;
+
 type_qualifier
     : CONST
     | VOLATILE

data/lib/adlint/cc1/syntax.rb

@@ -3619,10 +3619,17 @@ module Cc1 #:nodoc:
 
     private
     def deduct_controlling_expression_candidates(rough_cands)
-      varying_var_names = varying_variable_names
-      rough_cands.select do |expr_pair|
-        collect_object_specifiers(expr_pair.first).any? do |os|
-          varying_var_names.include?(os.identifier.value)
+      case
+      when rough_cands.empty?
+        [[nil, nil]]
+      when rough_cands.size == 1
+        rough_cands
+      else
+        varying_var_names = varying_variable_names
+        rough_cands.select do |expr_pair|
+          collect_object_specifiers(expr_pair.first).any? do |os|
+            varying_var_names.include?(os.identifier.value)
+          end
         end
       end
     end
@@ -3726,7 +3733,8 @@ module Cc1 #:nodoc:
 
     def deduct_controlling_expression
       sels = collect_loop_breaking_selection_statements(@statement)
-      rough_cands = [[@expression, @expression]] + sels.map { |stmt|
+      expr = @expression
+      rough_cands = [[expr, expr.to_normalized_logical]] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3765,7 +3773,8 @@ module Cc1 #:nodoc:
 
     def deduct_controlling_expression
       sels = collect_loop_breaking_selection_statements(@statement)
-      rough_cands = [[@expression, @expression]] + sels.map { |stmt|
+      expr = @expression
+      rough_cands = [[expr, expr.to_normalized_logical]] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3806,12 +3815,17 @@ module Cc1 #:nodoc:
 
     def deduct_controlling_expression
       sels = collect_loop_breaking_selection_statements(@body_statement)
-      rough_cands = [
-        [@condition_statement.expression, @condition_statement.expression]
-      ] + sels.map { |stmt|
-        [stmt.expression,
-          stmt.expression.to_normalized_logical.to_complemental_logical]
-      }
+      if expr = @condition_statement.expression
+        rough_cands = [[expr, expr.to_normalized_logical]] + sels.map { |stmt|
+          [stmt.expression,
+            stmt.expression.to_normalized_logical.to_complemental_logical]
+        }
+      else
+        rough_cands = sels.map { |stmt|
+          [stmt.expression,
+            stmt.expression.to_normalized_logical.to_complemental_logical]
+        }
+      end
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?
@@ -3852,12 +3866,17 @@ module Cc1 #:nodoc:
 
     def deduct_controlling_expression
       sels = collect_loop_breaking_selection_statements(@body_statement)
-      rough_cands = [
-        [@condition_statement.expression, @condition_statement.expression]
-      ] + sels.map { |stmt|
-        [stmt.expression,
-          stmt.expression.to_normalized_logical.to_complemental_logical]
-      }
+      if expr = @condition_statement.expression
+        rough_cands = [[expr, expr.to_normalized_logical]] + sels.map { |stmt|
+          [stmt.expression,
+            stmt.expression.to_normalized_logical.to_complemental_logical]
+        }
+      else
+        rough_cands = sels.map { |stmt|
+          [stmt.expression,
+            stmt.expression.to_normalized_logical.to_complemental_logical]
+        }
+      end
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?

data/lib/adlint/cc1/type.rb

@@ -5646,15 +5646,15 @@ module Cc1 #:nodoc:
     end
 
     def const?
-      false
+      @base_type.const?
     end
 
     def volatile?
-      false
+      @base_type.volatile?
     end
 
     def restrict?
-      false
+      @base_type.restrict?
     end
 
     def bitfield?

data/lib/adlint/cc1/value.rb

@@ -440,9 +440,9 @@ module Cc1 #:nodoc:
     def narrow_domain!(op, ope_val)
       case ope_single_val = ope_val.to_single_value
       when ScalarValue
-        org_dom = @domain
+        orig_dom = @domain
         @domain = @domain.narrow(op, ope_single_val.domain)
-        !@domain.equal?(org_dom)
+        !@domain.equal?(orig_dom)
       else
         raise TypeError, "cannot narrow scalar value domain with non-scalar."
       end
@@ -451,9 +451,9 @@ module Cc1 #:nodoc:
     def widen_domain!(op, ope_val)
       case ope_single_val = ope_val.to_single_value
       when ScalarValue
-        org_dom = @domain
+        orig_dom = @domain
         @domain = @domain.widen(op, ope_single_val.domain)
-        !@domain.equal?(org_dom)
+        !@domain.equal?(orig_dom)
       else
         raise TypeError, "cannot widen scalar value domain with non-scalar."
       end
@@ -997,8 +997,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs < rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs < rhs)
           end
         else
           scalar_value_of_false
@@ -1017,8 +1017,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs > rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs > rhs)
           end
         else
           scalar_value_of_false
@@ -1037,8 +1037,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_value.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs == rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs == rhs)
           end
         else
           scalar_value_of_false
@@ -1057,8 +1057,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs != rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs != rhs)
           end
         else
           scalar_value_of_false
@@ -1077,8 +1077,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs <= rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs <= rhs)
           end
         else
           scalar_value_of_false
@@ -1097,8 +1097,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_value.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs >= rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs >= rhs)
           end
         else
           scalar_value_of_false
@@ -1117,8 +1117,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs.logical_and(rhs))
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs.logical_and(rhs))
           end
         else
           scalar_value_of_false
@@ -1137,8 +1137,8 @@ module Cc1 #:nodoc:
       when ArrayValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs.logical_or(rhs))
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs.logical_or(rhs))
           end
         else
           scalar_value_of_false
@@ -1484,8 +1484,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs < rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs < rhs)
           end
         else
           scalar_value_of_false
@@ -1502,8 +1502,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs > rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs > rhs)
           end
         else
           scalar_value_of_false
@@ -1520,8 +1520,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs == rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs == rhs)
           end
         else
           scalar_value_of_false
@@ -1538,8 +1538,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs != rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs != rhs)
           end
         else
           scalar_value_of_false
@@ -1556,8 +1556,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs <= rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs <= rhs)
           end
         else
           scalar_value_of_false
@@ -1574,8 +1574,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs >= rhs)
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs >= rhs)
           end
         else
           scalar_value_of_false
@@ -1592,8 +1592,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs.logical_and(rhs))
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs.logical_and(rhs))
           end
         else
           scalar_value_of_false
@@ -1610,8 +1610,8 @@ module Cc1 #:nodoc:
       when CompositeValue
         if @values.size == rhs_single_val.values.size
           zipped = @values.zip(rhs_single_val.values)
-          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
-            res_val.single_value_unified_with(lhs.logical_or(rhs))
+          zipped.reduce(scalar_value_of_nil) do |rslt_val, (lhs, rhs)|
+            rslt_val.single_value_unified_with(lhs.logical_or(rhs))
           end
         else
           scalar_value_of_false
@@ -2120,10 +2120,10 @@ module Cc1 #:nodoc:
   end
 
   class VersionedValue < MultipleValue
-    def initialize(org_val)
-      # NOTE: `org_val.to_single_value' will be done in
+    def initialize(orig_val)
+      # NOTE: `orig_val.to_single_value' will be done in
       #       MultipleValue#initialize.
-      super(org_val, nil)
+      super(orig_val, nil)
 
       @version_controller = ValueVersionController.new(self)
     end
@@ -2155,22 +2155,30 @@ module Cc1 #:nodoc:
 
     def rollback_all_versions!
       delete_descendants!
-      org_val = @version_controller.original_value
+      orig_val = @version_controller.original_value
       @version_controller = nil
-      _org_overwrite!(org_val)
+      _orig_overwrite!(orig_val)
       @version_controller = ValueVersionController.new(self)
       invalidate_memo!
     end
 
-    alias :_org_overwrite! :overwrite!
+    alias :_orig_overwrite! :overwrite!
 
     def overwrite!(val)
       @version_controller.fork_current_version
-      super(val.to_single_value)
+      super
       @version_controller.mark_current_versioning_group_as_sticky
       invalidate_memo!
     end
 
+    def force_overwrite!(val)
+      # NOTE: This method will be invoked only from VariableTable#define.
+      single_val = val.to_single_value
+      @version_controller.original_value.overwrite!(single_val)
+      _orig_overwrite!(single_val)
+      invalidate_memo!
+    end
+
     def narrow_domain!(op, ope_val)
       @version_controller.fork_current_version
       super
@@ -2212,8 +2220,8 @@ module Cc1 #:nodoc:
   end
 
   class ValueVersionController
-    def initialize(org_val)
-      @versioning_group_stack = [RootVersioningGroup.new(org_val)]
+    def initialize(orig_val)
+      @versioning_group_stack = [RootVersioningGroup.new(orig_val)]
     end
 
     def original_value
@@ -2255,8 +2263,8 @@ module Cc1 #:nodoc:
         current_versioning_group.delete_current_version_completely
         base_vals = current_versioning_group.base_values
         base_vals.zip(initial_vals).each do |multi_val, initial_val|
-          forked and multi_val.rollback!
-          initial_val and multi_val.overwrite!(initial_val)
+          multi_val.rollback! if forked
+          multi_val.overwrite!(initial_val) if initial_val
         end
         begin_forking
       else
@@ -2316,7 +2324,7 @@ module Cc1 #:nodoc:
         vals.each do |base_multi_val, initial_single_val|
           base_multi_val.delete_descendants!
           if base_multi_val.kind_of?(VersionedValue)
-            base_multi_val._org_overwrite!(initial_single_val)
+            base_multi_val._orig_overwrite!(initial_single_val)
           else
             base_multi_val.overwrite!(initial_single_val)
           end
@@ -2415,8 +2423,8 @@ module Cc1 #:nodoc:
     private_constant :VersioningGroup
 
     class RootVersioningGroup < VersioningGroup
-      def initialize(org_val)
-        super(Version.new([org_val], true), true)
+      def initialize(orig_val)
+        super(Version.new([orig_val], true), true)
       end
     end
     private_constant :RootVersioningGroup