adlint 1.16.0 → 1.18.0

data/features/support/env.rb

@@ -1,5 +1,3 @@
-require "aruba/cucumber"
-
 NOARCH_TRAITS = <<EOF
 version: "1.0.0"
 
@@ -38,9 +36,24 @@ compiler_traits:
     data_ptr_alignment: 32
     char_as_unsigned_char: true
   include_path:
+    - "."
   arithmetic:
     logical_right_shift: true
   extension_substitution:
+    "pascal": ""
+    "__pascal": ""
+    "fortran": ""
+    "__fortran": ""
+    "cdecl": ""
+    "__cdecl": ""
+    "near": ""
+    "__near": ""
+    "far": ""
+    "__far": ""
+    "huge": ""
+    "__huge": ""
+    "__extension__": ""
+    "__attribute__(__adlint__any)": ""
   arbitrary_substitution:
     "typeof": "__typeof__"
     "__typeof": "__typeof__"
@@ -56,3 +69,105 @@ message_traits:
   language: "ja_JP"
   change_list:
 EOF
+
+DUMMY_STDIO_H = <<EOF
+#if !defined(DUMMY_STDIO_H)
+#define DUMMY_STDIO_H
+
+extern int printf(const char *, ...);
+extern int scanf(const char *, ...);
+
+typedef int FILE;
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+
+extern int fprintf(FILE *, const char *, ...);
+extern int fscanf(FILE *, const char *, ...);
+
+#endif
+EOF
+
+DUMMY_MATH_H = <<EOF
+#if !defined(DUMMY_MATH_H)
+#define DUMMY_MATH_H
+#endif
+EOF
+
+DUMMY_ASSERT_H = <<EOF
+#if !defined(DUMMY_ASSERT_H)
+#define DUMMY_ASSERT_H
+
+#define assert(expr) (0)
+
+#endif
+EOF
+
+require "pathname"
+require "stringio"
+
+if ENV["ADLINT_COV"] =~ /1|on|true/
+  require "simplecov"
+  require "simplecov-html"
+  SimpleCov.start
+end
+
+$envdir = Pathname.new(__FILE__).realpath.dirname
+$prefix = Pathname.new("../..").expand_path($envdir)
+$bindir = Pathname.new("bin").expand_path($prefix)
+$tmpdir = Pathname.new("cucumber-tmp").expand_path($prefix)
+
+module Kernel
+  def exit(status)
+    # NOTE: To avoid terminating cucumber process.
+  end
+end
+
+def run_adlint(cmd, *args)
+  create_adlint_files
+  cd_to_tmpdir { $all_output = exec(cmd, *args) }
+end
+
+def cd_to_tmpdir(&block)
+  orig_wd = Dir.getwd
+  Dir.mkdir($tmpdir) unless Dir.exist?($tmpdir)
+  Dir.chdir($tmpdir)
+  yield
+ensure
+  Dir.chdir(orig_wd)
+end
+
+def exec(cmd, *args)
+  ARGV.replace(args)
+  orig_stdout = $stdout.dup
+  orig_stderr = $stderr.dup
+  File.open("all_output", "w") do |io|
+    $stdout.reopen(io)
+    $stderr.reopen(io)
+    load "#{$bindir}/#{cmd}"
+    $stdout.flush
+    $stderr.flush
+  end
+  $stdout.reopen(orig_stdout)
+  $stderr.reopen(orig_stderr)
+  File.read("all_output")
+end
+
+def create_src_file(fpath, content)
+  cd_to_tmpdir { create_file(fpath, content) }
+end
+
+def create_adlint_files
+  cd_to_tmpdir do
+    create_file("noarch_traits.yml", NOARCH_TRAITS)
+    create_file("empty_pinit.h")
+    create_file("empty_cinit.h")
+    create_file("stdio.h", DUMMY_STDIO_H)
+    create_file("math.h", DUMMY_MATH_H)
+    create_file("assert.h", DUMMY_ASSERT_H)
+  end
+end
+
+def create_file(fname, content = "")
+  File.open(fname, "w") { |io| io.puts content }
+end

data/lib/adlint/c/branch.rb

@@ -125,8 +125,6 @@ module C #:nodoc:
         controlling_expression.ensure_true_by_narrowing(expression).commit!
       when widening?
         controlling_expression.ensure_true_by_widening(expression).commit!
-      else
-        raise "branch must be for narrowing or widening."
       end
       @group.all_controlling_variables_value_exist?
     end

data/lib/adlint/c/ctrlexpr.rb

@@ -35,6 +35,7 @@ require "adlint/c/mediator"
 require "adlint/c/expr"
 require "adlint/c/conv"
 require "adlint/c/operator"
+require "adlint/c/seqp"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -825,13 +826,29 @@ module C #:nodoc:
       @lhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
       lhs_variable = object_to_variable(@lhs_narrowing.result)
 
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.13 Logical AND operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise binary & operator, the && operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares equal
+      #   to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(@node.lhs_operand))
+
       # TODO: Must look about the short-circuit evaluation.
       @rhs_narrowing.load_original_values!(@lhs_narrowing)
       @rhs_narrowing.execute!
       @rhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
       rhs_variable = object_to_variable(@rhs_narrowing.result)
 
+      notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
+
       narrowing_merge!(@lhs_narrowing, @rhs_narrowing)
+      notify_variable_value_referred(@node, lhs_variable)
+      notify_variable_value_referred(@node, rhs_variable)
 
       unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
         return temporary_variable(int_type)
@@ -865,6 +882,18 @@ module C #:nodoc:
       @lhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
       lhs_variable = object_to_variable(@lhs_narrowing.result)
 
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.14 Logical OR operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise | operator, the || operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares
+      #   unequal to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(@node.lhs_operand))
+
       # TODO: Must look about the short-circuit evaluation.
       # FIXME: Base value of the RHS narrowing should be updated to ensure that
       #        the LHS condition is false.
@@ -872,7 +901,11 @@ module C #:nodoc:
       @rhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
       rhs_variable = object_to_variable(@rhs_narrowing.result)
 
+      notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
+
       widening_merge!(@lhs_narrowing, @rhs_narrowing)
+      notify_variable_value_referred(@node, lhs_variable)
+      notify_variable_value_referred(@node, rhs_variable)
 
       unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
         return temporary_variable(int_type)

data/lib/adlint/c/expr.rb

@@ -32,6 +32,7 @@
 require "adlint/c/mediator"
 require "adlint/c/const"
 require "adlint/c/conv"
+require "adlint/c/seqp"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -91,8 +92,10 @@ module C #:nodoc:
         _notify_variable_value_referred(node, array_or_pointer)
       end
 
-      unless subscript.variable? && subscript.value.scalar? &&
-          subscript.value.exist?
+      unless subscript.variable? and
+          subscript.value.scalar? && subscript.value.exist? or
+          subscript.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
         return temporary_variable(result_type)
       end
       _notify_variable_value_referred(node, subscript)
@@ -284,7 +287,7 @@ module C #:nodoc:
 
       notify_prefix_increment_expr_evaled(node, variable, original_value)
 
-      variable
+      temporary_variable(variable.type, variable.value)
     end
 
     def execute_prefix_decrement_expression(node, object)
@@ -305,7 +308,7 @@ module C #:nodoc:
 
       notify_prefix_decrement_expr_evaled(node, variable, original_value)
 
-      variable
+      temporary_variable(variable.type, variable.value)
     end
 
     def execute_address_expression(node, object)
@@ -358,7 +361,10 @@ module C #:nodoc:
 
     def execute_unary_arithmetic_expression(node, object)
       variable = object_to_variable(object)
-      return temporary_variable unless variable.type.scalar?
+      unless variable.type.scalar? || variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless variable == object
         notify_implicit_conv_performed(node.operand, object, variable)
@@ -393,12 +399,21 @@ module C #:nodoc:
 
       notify_explicit_conv_performed(node, variable, converted)
 
+      # NOTE: A cast-expression does not refer a source value essentially.
+      #       But, to avoid misunderstand that a return value of a function is
+      #       discarded when the return value is casted before assigning to a
+      #       variable.
+      _notify_variable_value_referred(node, variable)
+
       converted
     end
 
     def execute_multiplicative_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -406,7 +421,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -457,7 +475,10 @@ module C #:nodoc:
 
     def execute_additive_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -465,7 +486,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -509,7 +533,10 @@ module C #:nodoc:
 
     def execute_shift_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -517,7 +544,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -569,7 +599,8 @@ module C #:nodoc:
 
     def execute_relational_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
         return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
@@ -579,7 +610,8 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
         return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
@@ -627,7 +659,8 @@ module C #:nodoc:
 
     def execute_equality_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
         return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
@@ -637,7 +670,8 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
         return temporary_variable(int_type, ScalarValue.of_arbitrary)
       end
 
@@ -679,7 +713,10 @@ module C #:nodoc:
 
     def execute_and_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -687,7 +724,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -721,7 +761,10 @@ module C #:nodoc:
 
     def execute_exclusive_or_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -729,7 +772,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -763,7 +809,10 @@ module C #:nodoc:
 
     def execute_inclusive_or_expression(node, lhs_object, rhs_object)
       lhs_variable = object_to_variable(lhs_object)
-      return temporary_variable unless lhs_variable.type.scalar?
+      unless lhs_variable.type.scalar? || lhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless lhs_variable == lhs_object
         notify_implicit_conv_performed(node.lhs_operand,
@@ -771,7 +820,10 @@ module C #:nodoc:
       end
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -844,7 +896,10 @@ module C #:nodoc:
       lhs_variable = lhs_object
 
       rhs_variable = object_to_variable(rhs_object)
-      return temporary_variable unless rhs_variable.type.scalar?
+      unless rhs_variable.type.scalar? || rhs_variable.type.void?
+        # NOTE: To detect bad value reference of `void' expressions.
+        return temporary_variable
+      end
 
       unless rhs_variable == rhs_object
         notify_implicit_conv_performed(node.rhs_operand,
@@ -1166,7 +1221,7 @@ module C #:nodoc:
 
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
-      notify_shift_expr_evaled(node, lhs_converted, rhs_converted,
+      notify_shift_expr_evaled(node, lhs_variable, rhs_variable,
                                result_variable)
 
       if result_variable.type.same_as?(lhs_variable.type)
@@ -1224,7 +1279,7 @@ module C #:nodoc:
 
       result_variable = temporary_variable(lhs_converted.type, result_value)
 
-      notify_shift_expr_evaled(node, lhs_converted, rhs_converted,
+      notify_shift_expr_evaled(node, lhs_variable, rhs_variable,
                                result_variable)
 
       if result_variable.type.same_as?(lhs_variable.type)
@@ -1416,13 +1471,12 @@ module C #:nodoc:
     def _notify_variable_value_updated(node, object)
       if object.variable?
         interpreter.notify_variable_value_updated(node, object)
-      end
-
-      if object.kind_of?(InnerVariable)
-        # NOTE: When a value of the inner-variable of array or composite object
-        #       is updated, the outer variable's value should also be notified
-        #       to be updated.
-        _notify_variable_value_updated(node, object.owner)
+        if object.inner?
+          # NOTE: When a value of the inner-variable of array or composite
+          #       object is updated, the outer variable's value should also be
+          #       notified to be updated.
+          _notify_variable_value_updated(node, object.owner)
+        end
       end
     end
 
@@ -1743,8 +1797,22 @@ module C #:nodoc:
       return temporary_variable(int_type) unless lhs_object.variable?
 
       lhs_variable = lhs_object
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.13 Logical AND operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise binary & operator, the && operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares equal
+      #   to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+
       if lhs_variable.value.scalar? && lhs_variable.value.must_be_false?
         # NOTE: Doing the short-circuit evaluation.
+        notify_variable_value_referred(node, lhs_variable)
         return temporary_variable(int_type, ScalarValue.of_false)
       end
 
@@ -1752,6 +1820,9 @@ module C #:nodoc:
       return temporary_variable(int_type) unless rhs_object.variable?
 
       rhs_variable = rhs_object
+      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
+      notify_variable_value_referred(node, lhs_variable)
+      notify_variable_value_referred(node, rhs_variable)
 
       if lhs_variable.value.scalar? && rhs_variable.value.scalar?
         # NOTE: No usual-arithmetic-conversion.
@@ -1772,8 +1843,22 @@ module C #:nodoc:
       return temporary_variable(int_type) unless lhs_object.variable?
 
       lhs_variable = lhs_object
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.14 Logical OR operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise | operator, the || operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares
+      #   unequal to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+
       if lhs_variable.value.scalar? && lhs_variable.value.must_be_true?
         # NOTE: Doing the short-circuit evaluation.
+        notify_variable_value_referred(node, lhs_variable)
         return temporary_variable(int_type, ScalarValue.of_true)
       end
 
@@ -1781,6 +1866,9 @@ module C #:nodoc:
       return temporary_variable(int_type) unless rhs_object.variable?
 
       rhs_variable = rhs_object
+      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
+      notify_variable_value_referred(node, lhs_variable)
+      notify_variable_value_referred(node, rhs_variable)
 
       if lhs_variable.value.scalar? && rhs_variable.value.scalar?
         # NOTE: No usual-arithmetic-conversion.