adlint 2.6.0 → 2.6.2

data/lib/adlint/c/mediator.rb

@@ -114,8 +114,7 @@ module C #:nodoc:
       }
     end
 
-    def temporary_variable(type = undeclared_type,
-                           value = type.undefined_value)
+    def create_tempvar(type = undeclared_type, value = type.undefined_value)
       variable_table.define_temporary(type, value)
     end
 

data/lib/adlint/c/object.rb

@@ -687,7 +687,7 @@ module C #:nodoc:
     end
 
     def storage_duration_of(declaration_or_definition)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.2.2 Linkages of identifiers
       #
@@ -835,10 +835,10 @@ module C #:nodoc:
       return_values_via_pointer_arguments(interpreter, funcall_expr, args)
 
       if type.return_type.function?
-        interpreter.temporary_variable
+        interpreter.create_tempvar
       else
-        interpreter.temporary_variable(type.return_type,
-                                       type.return_type.return_value)
+        return_type = type.return_type
+        interpreter.create_tempvar(return_type, return_type.return_value)
       end
     end
 
@@ -853,16 +853,15 @@ module C #:nodoc:
           case
           when arg.type.array? && param_type.pointer?
             arg_value = interpreter.pointer_value_of(arg)
-            converted = interpreter.temporary_variable(param_type, arg_value)
+            converted = interpreter.create_tempvar(param_type, arg_value)
           when arg.type.pointer? && param_type.array?
             converted = interpreter.pointee_of(arg)
           when arg.type.function? && param_type.pointer?
             arg_value = interpreter.pointer_value_of(arg)
-            converted = interpreter.temporary_variable(param_type, arg_value)
+            converted = interpreter.create_tempvar(param_type, arg_value)
           when arg.variable? && !arg.type.same_as?(param_type)
-            converted =
-              interpreter.do_conversion(arg, param_type) ||
-              interpreter.temporary_variable(param_type)
+            converted = interpreter.do_conversion(arg, param_type) ||
+                        interpreter.create_tempvar(param_type)
           else
             converted = arg
           end

data/lib/adlint/c/seqp.rb

@@ -32,7 +32,7 @@
 module AdLint #:nodoc:
 module C #:nodoc:
 
-  # NOTE: The ISO C99 standard saids;
+  # NOTE: The ISO C99 standard says;
   #
   # Annex C (informative) Sequence points
   #

data/lib/adlint/c/syntax.rb

@@ -445,7 +445,7 @@ module C #:nodoc:
     def full=(full_expression)
       @full = full_expression
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # Annex C (informative) Sequence points
       #
@@ -1944,7 +1944,7 @@ module C #:nodoc:
     def initialize(operator, lhs_operand, rhs_operand)
       super
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.13 Logical AND operator
       #
@@ -1993,7 +1993,7 @@ module C #:nodoc:
     def initialize(operator, lhs_operand, rhs_operand)
       super
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.14 Logical OR operator
       #
@@ -2046,7 +2046,7 @@ module C #:nodoc:
       @else_expression = else_expression
       @question_mark = question_mark
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.15 Conditional operator
       #
@@ -2232,7 +2232,7 @@ module C #:nodoc:
     def push(expression)
       @expressions.push(expression)
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.17 Comma operator
       #
@@ -3055,7 +3055,7 @@ module C #:nodoc:
     def full=(full_declarator)
       @full = full_declarator
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.7.5 Declarators
       #

data/lib/adlint/c/type.rb

@@ -3475,7 +3475,7 @@ module C #:nodoc:
     end
 
     def integer_promoted_type
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.3.1 Arithmetic operands
       # 6.3.1.1 Boolean, characters, and integers
@@ -3500,7 +3500,7 @@ module C #:nodoc:
     end
 
     def argument_promoted_type
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.2.2 Function calls
       #
@@ -3609,7 +3609,7 @@ module C #:nodoc:
     end
 
     def integer_conversion_rank
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.3.1 Arithmetic operands
       # 6.3.1.1 Boolean, characters, and integers
@@ -4851,7 +4851,7 @@ module C #:nodoc:
 
     def integer_promoted_type
       # TODO: Should support the C99 _Bool type.
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.3.1 Arithmetic operands
       # 6.3.1.1 Boolean, characters, and integers
@@ -4960,7 +4960,7 @@ module C #:nodoc:
     end
 
     def integer_conversion_rank
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.3.1 Arithmetic operands
       # 6.3.1.1 Boolean, characters, and integers
@@ -5347,7 +5347,7 @@ module C #:nodoc:
     end
 
     def argument_promoted_type
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.2.2 Function calls
       #
@@ -5728,7 +5728,7 @@ module C #:nodoc:
     end
 
     def coerce_array_value(value)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.7.8 Initialization
       #
@@ -7051,7 +7051,7 @@ module C #:nodoc:
     end
 
     def integer_conversion_rank
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.3.1 Arithmetic operands
       # 6.3.1.1 Boolean, characters, and integers

data/lib/adlint/cpp/eval.rb

@@ -482,7 +482,7 @@ module Cpp #:nodoc:
       pp_tokens = pp_tokens(context)
       discard_extra_tokens_until_newline(context)
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.10.4 Line control
       #

data/lib/adlint/cpp/macro.rb

@@ -237,7 +237,7 @@ module Cpp #:nodoc:
 
     def substitute_argument(param_token, next_token, arg, location, result,
                             macro_table, context)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.1 Argument substitution
       #
@@ -263,7 +263,7 @@ module Cpp #:nodoc:
     end
 
     def stringize_argument(arg, expansion_location, macro_table)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.2 The # operator
       #
@@ -310,7 +310,7 @@ module Cpp #:nodoc:
 
     def concat_with_last_token(arg_tokens, expansion_location, result_tokens,
                                macro_table)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.3 The ## operator
       #
@@ -634,7 +634,7 @@ module Cpp #:nodoc:
       expanded = macro.expand(tokens[index, size], self, context)
       context.add_to_hide_set(tokens[index], expanded, macro.name.value)
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.4 Rescanning and further replacement
       #

data/lib/adlint/cpp/util.rb

@@ -79,7 +79,7 @@ module Cpp #:nodoc:
       string.chars.to_a - select_adapted(string)
     end
 
-    # NOTE: The ISO C99 standard saids;
+    # NOTE: The ISO C99 standard says;
     #
     # 5.2 Environmental considerations
     # 5.2.1 Character sets

data/lib/adlint/exam/c_builtin/c_check.rb

@@ -1695,15 +1695,19 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(unary_arithmetic_expression, operand_variable, result_variable)
-      if unary_arithmetic_expression.operator.type == "-"
-        if operand_variable.type.same_as?(@interp.unsigned_char_type) ||
-            operand_variable.type.same_as?(@interp.unsigned_short_type) ||
-            operand_variable.type.bitfield?
-          W(:W0082, unary_arithmetic_expression.location)
+    def check(unary_arith_expr, operand_var, *)
+      if unary_arith_expr.operator.type == "-"
+        if unsigned_underlying_type?(operand_var.type)
+          W(:W0082, unary_arith_expr.location, operand_var.type.brief_image)
         end
       end
     end
+
+    def unsigned_underlying_type?(type)
+      type.same_as?(@interp.unsigned_char_type) ||
+        type.same_as?(@interp.unsigned_short_type) ||
+        type.bitfield?
+    end
   end
 
   class W0084 < PassiveCodeCheck
@@ -11243,51 +11247,48 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(initializer_or_expression, original_variable, result_variable)
+    def check(init_or_expr, src_var, dst_var)
       return unless @rvalues
-      return unless original_variable.type.integer?
 
-      src_type = original_variable.type
-      dst_type = result_variable.type
+      src_type = src_var.type
+      dst_type = dst_var.type
+      return unless src_type.integer?
 
       if src_type.integer_conversion_rank < dst_type.integer_conversion_rank
-        case @rvalues[original_variable]
+        case @rvalues[src_var]
         when C::UnaryArithmeticExpression, C::ShiftExpression,
              C::AdditiveExpression, C::MultiplicativeExpression
-          W(:W0578, initializer_or_expression.location)
+          W(:W0578, init_or_expr.location,
+            src_type.brief_image, dst_type.brief_image)
         end
       end
     end
 
-    def clear_rvalues(function_definition, function)
+    def clear_rvalues(*)
       @rvalues = {}
     end
 
-    def handle_unary(unary_arithmetic_expression,
-                     operand_variable, result_variable)
-      return unless unary_arithmetic_expression.operator == "~"
-      memorize_rvalue_derivation(result_variable, unary_arithmetic_expression)
+    def handle_unary(unary_arith_expr, *, result_var)
+      return unless unary_arith_expr.operator == "~"
+      memorize_rvalue_derivation(result_var, unary_arith_expr)
     end
 
-    def handle_shift(shift_expression,
-                     lhs_variable, rhs_variable, result_variable)
-      return unless shift_expression.operator.type == "<<"
-      memorize_rvalue_derivation(result_variable, shift_expression)
+    def handle_shift(shift_expr, *, result_var)
+      return unless shift_expr.operator.type == "<<"
+      memorize_rvalue_derivation(result_var, shift_expr)
     end
 
-    def handle_additive(additive_expression,
-                        lhs_variable, rhs_variable, result_variable)
-      memorize_rvalue_derivation(result_variable, additive_expression)
+    def handle_additive(additive_expr, *, result_var)
+      memorize_rvalue_derivation(result_var, additive_expr)
     end
 
-    def handle_multiplicative(multiplicative_expression,
-                              lhs_variable, rhs_variable, result_variable)
-      return if multiplicative_expression.operator.type == "%"
-      memorize_rvalue_derivation(result_variable, multiplicative_expression)
+    def handle_multiplicative(multiplicative_expr, *, result_var)
+      return if multiplicative_expr.operator.type == "%"
+      memorize_rvalue_derivation(result_var, multiplicative_expr)
     end
 
-    def memorize_rvalue_derivation(rvalue_holder, expression)
-      @rvalues[rvalue_holder] = expression if @rvalues
+    def memorize_rvalue_derivation(rvalue_holder, expr)
+      @rvalues[rvalue_holder] = expr if @rvalues
     end
   end
 
@@ -11307,51 +11308,48 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(cast_expression, original_variable, result_variable)
+    def check(cast_expr, src_var, dst_var)
       return unless @rvalues
-      return unless original_variable.type.integer?
 
-      src_type = original_variable.type
-      dst_type = result_variable.type
+      src_type = src_var.type
+      dst_type = dst_var.type
+      return unless src_type.integer?
 
       if src_type.integer_conversion_rank < dst_type.integer_conversion_rank
-        case @rvalues[original_variable]
+        case @rvalues[src_var]
         when C::UnaryArithmeticExpression, C::ShiftExpression,
              C::AdditiveExpression, C::MultiplicativeExpression
-          W(:W0579, cast_expression.location)
+          W(:W0579, cast_expr.location,
+            src_type.brief_image, dst_type.brief_image)
         end
       end
     end
 
-    def clear_rvalues(function_definition, function)
+    def clear_rvalues(*)
       @rvalues = {}
     end
 
-    def handle_unary(unary_arithmetic_expression,
-                     operand_variable, result_variable)
-      return unless unary_arithmetic_expression.operator == "~"
-      memorize_rvalue_derivation(result_variable, unary_arithmetic_expression)
+    def handle_unary(unary_arith_expr, *, result_var)
+      return unless unary_arith_expr.operator == "~"
+      memorize_rvalue_derivation(result_var, unary_arith_expr)
     end
 
-    def handle_shift(shift_expression,
-                     lhs_variable, rhs_variable, result_variable)
-      return unless shift_expression.operator.type == "<<"
-      memorize_rvalue_derivation(result_variable, shift_expression)
+    def handle_shift(shift_expr, *, result_var)
+      return unless shift_expr.operator.type == "<<"
+      memorize_rvalue_derivation(result_var, shift_expr)
     end
 
-    def handle_additive(additive_expression,
-                        lhs_variable, rhs_variable, result_variable)
-      memorize_rvalue_derivation(result_variable, additive_expression)
+    def handle_additive(additive_expr, *, result_var)
+      memorize_rvalue_derivation(result_var, additive_expr)
     end
 
-    def handle_multiplicative(multiplicative_expression,
-                              lhs_variable, rhs_variable, result_variable)
-      return if multiplicative_expression.operator.type == "%"
-      memorize_rvalue_derivation(result_variable, multiplicative_expression)
+    def handle_multiplicative(multiplicative_expr, *, result_var)
+      return if multiplicative_expr.operator.type == "%"
+      memorize_rvalue_derivation(result_var, multiplicative_expr)
     end
 
-    def memorize_rvalue_derivation(rvalue_holder, expression)
-      @rvalues[rvalue_holder] = expression if @rvalues
+    def memorize_rvalue_derivation(rvalue_holder, expr)
+      @rvalues[rvalue_holder] = expr if @rvalues
     end
   end
 
@@ -11781,7 +11779,9 @@ module CBuiltin #:nodoc:
     end
 
     def refer_variable(expression, variable)
-      @refer_count[variable] += 1 if variable.named?
+      if variable.named?
+        @refer_count[variable] += 1
+      end
     end
 
     def update_variable(expression, variable)
@@ -12899,13 +12899,13 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(expr, lhs_variable, rhs_variable, result_variable)
+    def check(expr, lhs_var, rhs_var, *)
       if expr.rhs_operand.constant?(@enum_tbl)
-        promoted_type = lhs_variable.type.integer_promoted_type
+        promoted_type = lhs_var.type.integer_promoted_type
         promoted_bit_size = C::ScalarValue.of(promoted_type.bit_size)
-        if rhs_variable.value.must_be_equal_to?(promoted_bit_size) ||
-            rhs_variable.value.must_be_greater_than?(promoted_bit_size)
-          W(:W0650, expr.location)
+        if rhs_var.value.must_be_equal_to?(promoted_bit_size) ||
+            rhs_var.value.must_be_greater_than?(promoted_bit_size)
+          W(:W0650, expr.location, promoted_type.brief_image)
         end
       end
     end
@@ -14486,17 +14486,17 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(expr, lhs_variable, rhs_variable, result_variable)
+    def check(expr, lhs_var, rhs_var, *)
       if expr.rhs_operand.constant?(@enum_tbl)
-        underlying_type = lhs_variable.type
+        underlying_type = lhs_var.type
         underlying_bit_size = C::ScalarValue.of(underlying_type.bit_size)
-        promoted_type = lhs_variable.type.integer_promoted_type
+        promoted_type = lhs_var.type.integer_promoted_type
         promoted_bit_size = C::ScalarValue.of(promoted_type.bit_size)
 
-        if rhs_variable.value.must_be_equal_to?(underlying_bit_size) ||
-            rhs_variable.value.must_be_greater_than?(underlying_bit_size) and
-            rhs_variable.value.must_be_less_than?(promoted_bit_size)
-          W(:W0719, expr.location)
+        if rhs_var.value.must_be_equal_to?(underlying_bit_size) ||
+            rhs_var.value.must_be_greater_than?(underlying_bit_size) and
+            rhs_var.value.must_be_less_than?(promoted_bit_size)
+          W(:W0719, expr.location, underlying_type.brief_image)
         end
       end
     end
@@ -17509,29 +17509,28 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(binary_expression, lhs_variable, rhs_variable, result_variable)
-      return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
-      return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
-
-      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+    def check(binary_expr, lhs_var, rhs_var, result_var)
+      return unless lhs_var.type.scalar? && lhs_var.type.unsigned?
+      return unless rhs_var.type.scalar? && rhs_var.type.unsigned?
+      return unless lhs_var.value.scalar? && rhs_var.value.scalar?
 
-      case binary_expression.operator.type
+      case binary_expr.operator.type
       when "+"
-        unbound_value = lhs_variable.value + rhs_variable.value
+        unbound_val = lhs_var.value + rhs_var.value
       when "-"
-        unbound_value = lhs_variable.value - rhs_variable.value
+        unbound_val = lhs_var.value - rhs_var.value
       when "*"
-        unbound_value = lhs_variable.value * rhs_variable.value
+        unbound_val = lhs_var.value * rhs_var.value
       else
         return
       end
 
-      result_type = result_variable.type
-      lower_test = unbound_value < C::ScalarValue.of(result_type.min_value)
-      upper_test = unbound_value > C::ScalarValue.of(result_type.max_value)
+      result_type = result_var.type
+      lower_test = unbound_val < C::ScalarValue.of(result_type.min_value)
+      upper_test = unbound_val > C::ScalarValue.of(result_type.max_value)
 
       if lower_test.must_be_true? || upper_test.must_be_true?
-        W(:W1051, binary_expression.location)
+        W(:W1051, binary_expr.location, result_type.brief_image)
       end
     end
   end
@@ -17547,30 +17546,29 @@ module CBuiltin #:nodoc:
     end
 
     private
-    def check(binary_expression, lhs_variable, rhs_variable, result_variable)
-      return unless lhs_variable.type.scalar? && lhs_variable.type.unsigned?
-      return unless rhs_variable.type.scalar? && rhs_variable.type.unsigned?
+    def check(binary_expr, lhs_var, rhs_var, result_var)
+      return unless lhs_var.type.scalar? && lhs_var.type.unsigned?
+      return unless rhs_var.type.scalar? && rhs_var.type.unsigned?
+      return unless lhs_var.value.scalar? && rhs_var.value.scalar?
 
-      return unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-
-      case binary_expression.operator.type
+      case binary_expr.operator.type
       when "+"
-        unbound_value = lhs_variable.value + rhs_variable.value
+        unbound_val = lhs_var.value + rhs_var.value
       when "-"
-        unbound_value = lhs_variable.value - rhs_variable.value
+        unbound_val = lhs_var.value - rhs_var.value
       when "*"
-        unbound_value = lhs_variable.value * rhs_variable.value
+        unbound_val = lhs_var.value * rhs_var.value
       else
         return
       end
 
-      result_type = result_variable.type
-      lower_test = unbound_value < C::ScalarValue.of(result_type.min_value)
-      upper_test = unbound_value > C::ScalarValue.of(result_type.max_value)
+      result_type = result_var.type
+      lower_test = unbound_val < C::ScalarValue.of(result_type.min_value)
+      upper_test = unbound_val > C::ScalarValue.of(result_type.max_value)
 
       if !lower_test.must_be_true? && lower_test.may_be_true? or
           !upper_test.must_be_true? && upper_test.may_be_true?
-        W(:W1052, binary_expression.location)
+        W(:W1052, binary_expr.location, result_type.brief_image)
       end
     end
   end
@@ -17965,8 +17963,8 @@ module CBuiltin #:nodoc:
       if @current_function
         @return_values.each_value do |retval|
           unless retval[0]
-            fun_name = retval[2].named? ? retval[2].name : "(anonymous)"
-            W(:W1073, retval[1].location, fun_name)
+            func_name = retval[2].named? ? retval[2].name : "(anonymous)"
+            W(:W1073, retval[1].location, func_name)
           end
         end
       end

data/lib/adlint/exam/c_builtin/ld_check.rb

@@ -220,7 +220,7 @@ module CBuiltin #:nodoc:
       mapping = @context[:ld_function_mapping]
       functions = mapping.lookup_functions(function.name)
       if functions.size > 1
-        functions.each { |fun| W(:W0791, fun.location, fun.signature) }
+        functions.each { |func| W(:W0791, func.location, func.signature) }
       end
     end
 
@@ -257,9 +257,9 @@ module CBuiltin #:nodoc:
       mapping = @context[:ld_function_mapping]
       defs_and_decls =
         (mapping.lookup_function_declarations(function.name) +
-         mapping.lookup_functions(function.name)).select { |fun| fun.extern? }
-      if defs_and_decls.any? { |fun| fun.signature != function.signature }
-        defs_and_decls.each { |fun| W(:W1037, fun.location, fun.name) }
+         mapping.lookup_functions(function.name)).select { |f| f.extern? }
+      if defs_and_decls.any? { |f| f.signature != function.signature }
+        defs_and_decls.each { |f| W(:W1037, f.location, f.name) }
       end
     end
 

data/lib/adlint/traits.rb

@@ -111,14 +111,12 @@ module AdLint #:nodoc:
 
   class ProjectTraits
     include Validation
+    include CompoundPathParser
 
     def initialize(doc)
       @project_name = doc["project_name"]
       @project_root = Pathname.new(doc["project_root"])
-      @include_path =
-        (doc["include_path"] || []).compact.map { |compound_path_str|
-          compound_path_str.split(":").map { |str| Pathname.new(str) }
-        }.flatten
+      @include_path = parse_compound_path_list(doc["include_path"])
       @initial_header = doc["initial_header"]
       @coding_style = CodingStyle.new(doc["coding_style"])
       @file_encoding = doc["file_encoding"]
@@ -195,13 +193,11 @@ module AdLint #:nodoc:
   # Traits information of the compiler used in the project.
   class CompilerTraits
     include Validation
+    include CompoundPathParser
 
     def initialize(doc)
       @standard_type = StandardType.new(doc["standard_type"])
-      @include_path =
-        (doc["include_path"] || []).compact.map { |compound_path_str|
-          compound_path_str.split(":").map { |str| Pathname.new(str) }
-        }.flatten
+      @include_path = parse_compound_path_list(doc["include_path"])
       @initial_header = doc["initial_header"]
       @arithmetic = Arithmetic.new(doc["arithmetic"])
       @extension_substitution = doc["extension_substitution"] || {}
@@ -485,18 +481,13 @@ module AdLint #:nodoc:
 
   class MessageTraits
     include Validation
+    include CompoundPathParser
 
     def initialize(doc)
       @language = doc["language"]
       @message_with_class = doc["message_with_class"]
-      @warn_files_in =
-        (doc["warn_files_in"] || []).compact.map { |compound_path_str|
-          compound_path_str.split(":").map { |str| Pathname.new(str) }
-        }.flatten
-      @warn_files_not_in =
-        (doc["warn_files_not_in"] || []).compact.map { |compound_path_str|
-          compound_path_str.split(":").map { |str| Pathname.new(str) }
-        }.flatten
+      @warn_files_in = parse_compound_path_list(doc["warn_files_in"])
+      @warn_files_not_in = parse_compound_path_list(doc["warn_files_not_in"])
       @individual_selection = doc["individual_selection"]
       @exclusion = Exclusion.new(doc["exclusion"])
       @inclusion = Inclusion.new(doc["inclusion"])

data/lib/adlint/util.rb

@@ -582,6 +582,18 @@ module AdLint #:nodoc:
     module_function :package_name_of
   end
 
+  module CompoundPathParser
+    def parse_compound_path_list(ary)
+      (ary || []).compact.map { |str| parse_compound_path_str(str) }.flatten
+    end
+    module_function :parse_compound_path_list
+
+    def parse_compound_path_str(str)
+      str.split(File::PATH_SEPARATOR).map { |s| Pathname.new(s) }
+    end
+    module_function :parse_compound_path_str
+  end
+
 end
 
 if $0 == __FILE__