adlint 1.6.0 → 1.8.0

data/lib/adlint/c/value.rb

@@ -749,15 +749,15 @@ module C #:nodoc:
     end
 
     def exist?
-      @values.all? { |value| value.exist? }
+      @values.empty? ? true : @values.all? { |value| value.exist? }
     end
 
     def undefined?
-      @values.all? { |value| value.undefined? }
+      @values.empty? ? false : @values.all? { |value| value.undefined? }
     end
 
     def ambiguous?
-      @values.all? { |value| value.ambiguous? }
+      @values.empty? ? false : @values.all? { |value| value.ambiguous? }
     end
 
     def overwrite!(value)
@@ -1224,15 +1224,15 @@ module C #:nodoc:
     end
 
     def exist?
-      @values.all? { |value| value.exist? }
+      @values.empty? ? true : @values.all? { |value| value.exist? }
     end
 
     def undefined?
-      @values.all? { |value| value.undefined? }
+      @values.empty? ? false : @values.all? { |value| value.undefined? }
     end
 
     def ambiguous?
-      @values.all? { |value| value.ambiguous? }
+      @values.empty? ? false : @values.all? { |value| value.ambiguous? }
     end
 
     def overwrite!(value)
@@ -1717,9 +1717,16 @@ module C #:nodoc:
     end
 
     def fork
-      descendant = MultipleValue.new(@base_value.dup, self)
-      @descendants.push(descendant)
-      descendant
+      same_value = @descendants.find { |multi_value|
+        multi_value.eql?(@base_value)
+      }
+      if same_value
+        same_value
+      else
+        new_descendant = MultipleValue.new(@base_value.dup, self)
+        @descendants.push(new_descendant)
+        new_descendant
+      end
     end
 
     def rollback!
@@ -1998,12 +2005,12 @@ module C #:nodoc:
       @version_controller = ValueVersionController.new(self)
     end
 
-    def begin_versioning_group
+    def enter_versioning_group
       @version_controller.enter_new_versioning_group
     end
 
-    def end_versioning_group(raise_complement_values)
-      @version_controller.copy_current_version if raise_complement_values
+    def leave_versioning_group(raise_complement)
+      @version_controller.copy_current_version if raise_complement
       @version_controller.merge_forked_versions
       @version_controller.leave_current_versioning_group
       invalidate_memo!
@@ -2018,58 +2025,44 @@ module C #:nodoc:
       invalidate_memo!
     end
 
-    alias :_rollback_latest_version! :rollback!
-
-    def rollback!
+    def rollback_latest_version!
       if @version_controller.rollback
         invalidate_memo!
       end
     end
 
-    def rollback_to_original!
+    def rollback_all_versions!
       delete_descendants!
-      _direct_overwrite!(@version_controller.initial_value)
+      _orig_overwrite!(@version_controller.original_value)
       @version_controller = ValueVersionController.new(self)
       invalidate_memo!
     end
 
-    alias :_direct_overwrite! :overwrite!
+    alias :_orig_overwrite! :overwrite!
 
     def overwrite!(value)
-      single_value = value.to_single_value
-      no_effect = effective_values.all? { |multi_value|
-        multi_value.ambiguous? || multi_value.eql?(single_value)
-      }
-      unless no_effect
-        @version_controller.fork_new_version
-        super(single_value)
-        @version_controller.mark_current_versioning_group_as_sticky
-        invalidate_memo!
-      end
+      @version_controller.fork_current_version
+      super(value.to_single_value)
+      @version_controller.mark_current_versioning_group_as_sticky
+      invalidate_memo!
     end
 
     def narrow_domain!(operator_symbol, operand_value)
-      if effective_values.any? { |multi_value| !multi_value.ambiguous? }
-        @version_controller.fork_new_version
-        super
-        invalidate_memo!
-      end
+      @version_controller.fork_current_version
+      super
+      invalidate_memo!
     end
 
     def widen_domain!(operator_symbol, operand_value)
-      if effective_values.any? { |multi_value| !multi_value.ambiguous? }
-        @version_controller.fork_new_version
-        super
-        invalidate_memo!
-      end
+      @version_controller.fork_current_version
+      super
+      invalidate_memo!
     end
 
     def invert_domain!
-      if effective_values.any? { |multi_value| !multi_value.ambiguous? }
-        @version_controller.fork_new_version
-        super
-        invalidate_memo!
-      end
+      @version_controller.fork_current_version
+      super
+      invalidate_memo!
     end
 
     def coerce_to(type)
@@ -2097,77 +2090,56 @@ module C #:nodoc:
   end
 
   class ValueVersionController
-    VersioningGroup = Struct.new(:sticky, :original_values)
-    Version = Struct.new(:group, :state, :values)
-
     def initialize(original_value)
-      @versioning_groups = [initial_versioning_group(original_value)]
-      @versions = [initial_version(@versioning_groups.first, original_value)]
+      @versioning_group_stack = [RootVersioningGroup.new(original_value)]
     end
 
-    def initial_value
-      @versioning_groups.first.original_values.first
+    def original_value
+      root_versioning_group.initial_values.first
     end
 
     def current_values
-      current_version.values
+      current_versioning_group.current_values
     end
 
     def enter_new_versioning_group
-      original_values = current_values.map { |multi_value|
-        multi_value.base_value.dup
-      }
-      VersioningGroup.new(false, original_values).tap do |group|
-        @versioning_groups.push(group)
-      end
+      new_group = VersioningGroup.new(current_versioning_group.current_version)
+      @versioning_group_stack.push(new_group)
     end
 
     def leave_current_versioning_group
-      @versioning_groups.pop
+      @versioning_group_stack.pop
     end
 
     def begin_forking
-      @versions.push(Version.new(current_versioning_group,
-                                 :forking, current_version.values))
+      current_versioning_group.begin_new_version
     end
 
     def end_forking
-      @versions.pop
+      current_versioning_group.end_current_version
     end
 
-    def fork_new_version
-      if current_version.state == :forking
-        fork_all_base_versions
-        current_version.values = current_version.values.map { |multi_value|
-          multi_value.fork
-        }
-        current_version.state = :forked
-      end
+    def fork_current_version
+      fork_all_versions
     end
 
     def rollback
+      return false unless current_version.forked?
+
       # NOTE: This method must be called in the forking section.
-      if current_version.state == :forked
-        end_forking
-        current_version.values.each do |multi_value|
-          case multi_value
-          when VersionedValue
-            multi_value._rollback_latest_version!
-          else
-            multi_value.rollback!
-          end
-        end
-        begin_forking
-        mark_current_versioning_group_as_sticky
-        true
-      else
-        false
+      current_versioning_group.delete_current_version
+      current_versioning_group.base_values.each do |multi_value|
+        multi_value.rollback!
       end
+      begin_forking
+      mark_current_versioning_group_as_sticky
+
+      true
     end
 
     def mark_current_versioning_group_as_sticky
-      @versioning_groups.reverse_each do |group|
-        if group.sticky
+      @versioning_group_stack.reverse_each do |group|
+        if group.sticky?
           break
         else
           group.sticky = true
@@ -2176,69 +2148,170 @@ module C #:nodoc:
     end
 
     def copy_current_version
+      return unless current_versioning_group.sticky?
+
       # NOTE: This method must be called between ending of the forking section
       #       and ending of the versioning group.
-      if current_versioning_group.sticky
-        current_values.each do |multi_value|
-          base_value = multi_value.base_value
-          already_exist = multi_value.descendants.any? { |desc|
-            !desc.equal?(multi_value) && desc.eql?(base_value)
-          }
-          multi_value.fork unless already_exist
-        end
+      current_values.each do |multi_value|
+        base_value = multi_value.base_value
+        already_exist = multi_value.descendants.any? { |desc_multi_value|
+          !desc_multi_value.equal?(multi_value) &&
+            desc_multi_value.eql?(base_value)
+        }
+        multi_value.fork unless already_exist
       end
     end
 
     def merge_forked_versions
       # NOTE: This method must be called between ending of the forking section
       #       and ending of the versioning group.
-      if current_versioning_group.sticky
-        current_version.values = current_values.map { |multi_value|
-          multi_value.descendants
+      base_version = current_versioning_group.base_version
+
+      case
+      when current_versioning_group.sticky?
+        fork_all_versions
+        base_version.values = base_version.values.map { |base_multi_value|
+          base_multi_value.descendants
         }.flatten.uniq
-      else
-        values = current_values.zip(current_versioning_group.original_values)
-        values.each do |current_multi_value, original_single_value|
-          current_multi_value.delete_descendants!
-          case current_multi_value
-          when VersionedValue
-            current_multi_value._direct_overwrite!(original_single_value)
+      when current_versioning_group.versions_forked?
+        # NOTE: When versions in the current versioning group have been forked,
+        #       base_version of the current versioning group has already been
+        #       forked.  So, it is safe to overwrite the base_version's values
+        #       with the current versioning group's initial snapshot values.
+        initial_values = current_versioning_group.initial_values
+        values = base_version.values.zip(initial_values)
+        values.each do |base_multi_value, initial_single_value|
+          base_multi_value.delete_descendants!
+          if base_multi_value.kind_of?(VersionedValue)
+            base_multi_value._orig_overwrite!(initial_single_value)
           else
-            current_multi_value.overwrite!(original_single_value)
+            base_multi_value.overwrite!(initial_single_value)
           end
         end
+      else
+        # NOTE: Nothing to be done when base_version of the current versioning
+        #       group has not been forked.
       end
     end
 
     private
-    def initial_versioning_group(original_value)
-      VersioningGroup.new(true, [original_value.base_value.dup])
+    def fork_all_versions
+      parent_group = root_versioning_group
+      active_versioning_groups.each do |active_group|
+        active_group.base_version = parent_group.current_version
+        active_group.fork_all_versions
+        parent_group = active_group
+      end
     end
 
-    def initial_version(versioning_group, original_value)
-      Version.new(versioning_group, :original, [original_value])
+    def root_versioning_group
+      @versioning_group_stack.first
     end
 
-    def fork_all_base_versions
-      base_version = @versions.first
-      @versions[1..-2].each do |version|
-        if version.state == :forking
-          version.values = base_version.values.map { |multi_value|
-            multi_value.fork
-          }
-          version.state = :forked
-        end
-        base_version = version
-      end
+    def active_versioning_groups
+      @versioning_group_stack[1..-1]
     end
 
     def current_versioning_group
-      @versioning_groups.last
+      @versioning_group_stack.last
     end
 
     def current_version
-      @versions.last
+      current_versioning_group.current_version
+    end
+
+    class VersioningGroup
+      def initialize(base_version, sticky = false)
+        @base_version = base_version
+        @sticky = sticky
+
+        @initial_values = base_version.values.map { |multi_value|
+          multi_value.base_value.dup
+        }
+        @version_stack = []
+        @all_versions = []
+      end
+
+      attr_accessor :base_version
+      attr_writer :sticky
+      attr_reader :initial_values
+
+      def sticky?
+        @sticky
+      end
+
+      def versions_forked?
+        @all_versions.any? { |version| version.forked? }
+      end
+
+      def base_values
+        @base_version.values
+      end
+
+      def current_version
+        @version_stack.empty? ? @base_version : @version_stack.last
+      end
+
+      def current_values
+        current_version.values
+      end
+
+      def begin_new_version
+        new_version = Version.new(base_values)
+        @version_stack.push(new_version)
+        @all_versions.push(new_version)
+      end
+
+      def end_current_version
+        @version_stack.pop
+      end
+
+      def delete_current_version
+        end_current_version
+        @all_versions.pop
+      end
+
+      def fork_all_versions
+        @all_versions.each { |version| version.fork_from(@base_version) }
+      end
+    end
+    private_constant :VersioningGroup
+
+    class RootVersioningGroup < VersioningGroup
+      def initialize(original_value)
+        super(Version.new([original_value], true), true)
+      end
+    end
+    private_constant :RootVersioningGroup
+
+    class Version
+      def initialize(values, original = false)
+        @values = values
+        @state = original ? :original : :forking
+      end
+
+      attr_accessor :values
+
+      def original?
+        @state == :original
+      end
+
+      def forking?
+        @state == :forking
+      end
+
+      def forked?
+        @state == :forked
+      end
+
+      def fork_from(base_version)
+        if forking?
+          @values = base_version.values.map { |multi_value| multi_value.fork }
+          @state = :forked
+        end
+      end
     end
+    private_constant :Version
   end
 
   class FrozenValue < Value
@@ -2254,12 +2327,12 @@ module C #:nodoc:
     def_delegator :@versioned_value, :undefined?
     def_delegator :@versioned_value, :exist?
     def_delegator :@versioned_value, :multiple?
-    def_delegator :@versioned_value, :begin_versioning_group
-    def_delegator :@versioned_value, :end_versioning_group
+    def_delegator :@versioned_value, :enter_versioning_group
+    def_delegator :@versioned_value, :leave_versioning_group
     def_delegator :@versioned_value, :begin_versioning
     def_delegator :@versioned_value, :end_versioning
-    def_delegator :@versioned_value, :rollback!
-    def_delegator :@versioned_value, :rollback_to_original!
+    def_delegator :@versioned_value, :rollback_latest_version!
+    def_delegator :@versioned_value, :rollback_all_versions!
     def_delegator :@versioned_value, :single_value_unified_with
     def_delegator :@versioned_value, :~
     def_delegator :@versioned_value, :+@

data/lib/adlint/cpp/asm.rb

@@ -42,8 +42,8 @@ module Cpp #:nodoc:
 
     def create_cxx_asm_definition(source)
       CodeSubstitution.new("asm(__adlint__any);", "").tap do |subst|
-        subst.on_substitution += lambda { |location, matched|
-          source.on_inline_assembly.invoke(location, matched)
+        subst.on_substitution += lambda { |matched_tokens|
+          source.on_inline_assembly.invoke(matched_tokens)
         }
       end
     end
@@ -61,8 +61,8 @@ module Cpp #:nodoc:
         "asm __volatile__ (__adlint__any);"
       ].map do |pattern|
         CodeSubstitution.new(pattern, "").tap { |subst|
-          subst.on_substitution += lambda { |location, matched|
-            source.on_inline_assembly.invoke(location, matched)
+          subst.on_substitution += lambda { |matched_tokens|
+            source.on_inline_assembly.invoke(matched_tokens)
           }
         }
       end

data/lib/adlint/cpp/constexpr.rb

@@ -1,6 +1,6 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.7
+# This file is automatically generated by Racc 1.4.8
 # from Racc grammer file "".
 #
 

data/lib/adlint/cpp/eval.rb

@@ -648,7 +648,7 @@ module Cpp #:nodoc:
       if fpath = resolve_next_user_header(basename, current_dpath)
         include_user_header(fpath, user_include_next_line, context)
       else
-        E(:E0010, user_include_line.location, basename)
+        E(:E0010, user_include_next_line.location, basename)
         raise MissingUserHeaderError.new(user_include_next_line.location,
                                          basename,
                                          context.msg_fpath, context.log_fpath)
@@ -688,7 +688,7 @@ module Cpp #:nodoc:
         include_system_header(fpath, system_include_next_line, context)
       else
         E(:E0009, system_include_line.location, basename)
-        raise MissingSystemHeaderError.new(system_include_line.location,
+        raise MissingSystemHeaderError.new(system_include_next_line.location,
                                            basename,
                                            context.msg_fpath,
                                            context.log_fpath)
@@ -723,7 +723,8 @@ module Cpp #:nodoc:
       result = []
       include_paths.each do |dpath|
         fpath = dpath.join(Pathname.new(basename))
-        result.push(fpath) if File.readable?(fpath)
+        fpath = Pathname.new(fpath.to_s.gsub(/\\\\|\\/, "/"))
+        result.push(fpath) if fpath.readable?
         break if result.size == max_num
       end
       result
@@ -744,7 +745,8 @@ module Cpp #:nodoc:
       result = []
       include_paths.each do |dpath|
         fpath = dpath.join(Pathname.new(basename))
-        result.push(fpath) if File.readable?(fpath)
+        fpath = Pathname.new(fpath.to_s.gsub(/\\\\|\\/, "/"))
+        result.push(fpath) if fpath.readable?
         break if result.size == max_num
       end
       result

data/lib/adlint/cpp/message.rb

@@ -258,8 +258,18 @@ module Cpp #:nodoc:
 
     def initialize(context)
       super
-      context[:c_source].on_language_extension +=
-        lambda { |location, matched| W(:W0061, location, matched) }
+      context[:c_source].on_language_extension += method(:check)
+    end
+
+    private
+    def check(matched_tokens)
+      W(:W0061, matched_tokens.first.location, tokens_to_str(matched_tokens))
+    end
+
+    def tokens_to_str(tokens)
+      tokens.map { |token|
+        token.type == :NEW_LINE ? nil : token.value
+      }.compact.join(" ")
     end
   end
 
@@ -772,15 +782,20 @@ module Cpp #:nodoc:
   end
 
   class W0541 < PassiveMessageDetection
-    # NOTE: W0541 may be duplicative when the same header which has the token
-    #       sequence of the compiler specific extension is included twice or
-    #       more.
+    # NOTE: W0541 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
     ensure_uniqueness_of :W0541
 
     def initialize(context)
       super
-      context[:c_source].on_inline_assembly +=
-        lambda { |location, matched| W(:W0541, location) }
+      context[:c_source].on_inline_assembly += method(:check)
+    end
+
+    private
+    def check(asm_tokens)
+      unless asm_tokens.any? { |token| token.replaced? }
+        W(:W0541, asm_tokens.first.location)
+      end
     end
   end
 
@@ -948,6 +963,68 @@ module Cpp #:nodoc:
     end
   end
 
+  class W0632 < PassiveMessageDetection
+    # NOTE: W0632 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0632
+
+    def initialize(context)
+      super
+      visitor = context[:cpp_visitor]
+      visitor.enter_system_include_line += method(:check)
+      visitor.enter_system_include_next_line += method(:check)
+    end
+
+    private
+    def check(include_line)
+      if include_line.header_name.value =~ /['"]/
+        W(:W0632, include_line.location, include_line.header_name.value)
+      end
+    end
+  end
+
+  class W0633 < PassiveMessageDetection
+    # NOTE: W0633 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0633
+
+    def initialize(context)
+      super
+      visitor = context[:cpp_visitor]
+      visitor.enter_user_include_line += method(:check)
+      visitor.enter_user_include_next_line += method(:check)
+    end
+
+    private
+    def check(include_line)
+      if include_line.header_name.value =~ /'/
+        W(:W0633, include_line.location, include_line.header_name.value)
+      end
+    end
+  end
+
+  class W0634 < PassiveMessageDetection
+    # NOTE: W0634 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0634
+
+    def initialize(context)
+      super
+      visitor = context[:cpp_visitor]
+      visitor.enter_user_include_line += method(:check)
+      visitor.enter_user_include_next_line += method(:check)
+      visitor.enter_system_include_line += method(:check)
+      visitor.enter_system_include_next_line += method(:check)
+    end
+
+    private
+    def check(include_line)
+      if include_line.header_name.value.include?("\\")
+        W(:W0634, include_line.location)
+      end
+    end
+  end
+
   class W0696 < PassiveMessageDetection
     # NOTE: W0696 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
@@ -990,6 +1067,22 @@ module Cpp #:nodoc:
     end
   end
 
+  class W0832 < PassiveMessageDetection
+    # NOTE: W0832 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W0832
+
+    def initialize(context)
+      super
+      context[:c_source].on_inline_assembly += method(:check)
+    end
+
+    private
+    def check(asm_tokens)
+      W(:W0832, asm_tokens.first.location)
+    end
+  end
+
   class W9002 < PassiveMessageDetection
     # NOTE: W9002 may be duplicative when the same header which has no newline
     #       at end of the file is included twice or more.