adlint 1.8.10 → 1.10.0

data/lib/adlint/c/interp.rb

@@ -36,14 +36,45 @@ require "adlint/c/mediator"
 require "adlint/c/syntax"
 require "adlint/c/expr"
 require "adlint/c/conv"
+require "adlint/c/option"
 require "adlint/c/util"
 
 module AdLint #:nodoc:
 module C #:nodoc:
 
+  class Program
+    def initialize(interpreter, translation_unit)
+      @interpreter = interpreter
+      @translation_unit = translation_unit
+    end
+
+    def execute
+      @interpreter.notify_translation_unit_started(@translation_unit)
+      @translation_unit.accept(ExecutionDriver.new(@interpreter))
+      @interpreter.notify_translation_unit_ended(@translation_unit)
+    end
+
+    class ExecutionDriver < SyntaxTreeVisitor
+      include InterpreterMediator
+
+      def initialize(interpreter)
+        @interpreter = interpreter
+      end
+
+      def visit_declaration(node) interpret(node) end
+      def visit_ansi_function_definition(node) interpret(node) end
+      def visit_kandr_function_definition(node) interpret(node) end
+
+      private
+      def interpreter; @interpreter end
+    end
+    private_constant :ExecutionDriver
+  end
+
   class Interpreter
     include InterpreterMediator
     include Conversion
+    include InterpreterOptions
 
     def initialize(type_table)
       type_table = type_table
@@ -51,7 +82,6 @@ module C #:nodoc:
       @type_resolver = DynamicTypeResolver.new(type_table, self)
 
       @sub_interpreters = [
-        TranslationUnitInterpreter.new(self),
         DeclarationInterpreter.new(self),
         ParameterDefinitionInterpreter.new(self),
         FunctionInterpreter.new(self),
@@ -60,7 +90,7 @@ module C #:nodoc:
         ExpressionInterpreter.new(self)
       ]
 
-      @suppress_notification = false
+      @options_stack = []
 
       # NOTE: Active (executing) function may be nested if the nested
       #       function-definition of the GCC extension is used.
@@ -76,7 +106,7 @@ module C #:nodoc:
       class_eval <<-EOS
         def_plugin :on_#{event_name}
         def notify_#{event_name}(#{arg_names.join(",")})
-          unless @suppress_notification
+          unless quiet?
             on_#{event_name}.invoke(#{arg_names.join(",")})
           end
         end
@@ -84,21 +114,24 @@ module C #:nodoc:
     end
     private_class_method :def_plugin_and_notifier
 
+    # NOTE: Notified when the interpreter evaluates a variable-declaration.
+    def_plugin_and_notifier :variable_declared,
+                            :variable_declaration, :variable
+
+    # NOTE: Notified when the interpreter evaluates a variable-definition.
+    def_plugin_and_notifier :variable_defined, :variable_definition, :variable
+
     # NOTE: Notified when the interpreter evaluates an initializer of
     #       variable-definition.
     def_plugin_and_notifier :variable_initialized,
                             :variable_definition, :variable, :init_variable
 
-    # NOTE: Notified when the interpreter evaluates a variable-definition.
-    def_plugin_and_notifier :variable_defined, :variable_definition, :variable
-
     # NOTE: Notified when the interpreter evaluates a function-declaration.
     def_plugin_and_notifier :function_declared,
                             :function_declaration, :function
 
-    # NOTE: Notified when the interpreter evaluates a variable-declaration.
-    def_plugin_and_notifier :variable_declared,
-                            :variable_declaration, :variable
+    # NOTE: Notified when the interpreter evaluates a function-definition.
+    def_plugin_and_notifier :function_defined, :function_definition, :function
 
     # NOTE: Notified when the interpreter evaluates a struct-type-declaration.
     def_plugin_and_notifier :struct_declared, :struct_type_declaration
@@ -235,7 +268,7 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter evaluates a conditional-expression.
     def_plugin_and_notifier :conditional_expr_evaled,
-                            :conditional_expression, :condition_variable,
+                            :conditional_expression, :controlling_variable,
                             :result_variable
 
     # NOTE: Notified when the interpreter evaluates an address-expression.
@@ -393,16 +426,10 @@ module C #:nodoc:
     def_plugin_and_notifier :sequence_point_reached, :sequence_point
 
     def execute(node, *options)
-      if options.include?(:suppress_notification)
-        @suppress_notification = true
-      end
-
+      @options_stack.push(current_options + options)
       node.accept(interpreter_for(node))
-
     ensure
-      if options.include?(:suppress_notification)
-        @suppress_notification = false
-      end
+      @options_stack.pop
     end
 
     def object_to_variable(object)
@@ -429,9 +456,17 @@ module C #:nodoc:
       ScalarValue.of(object.binding.memory.address)
     end
 
-    def _suppress_notification=(suppress_notification)
+    def quiet?
+      current_options.include?(QUIET)
+    end
+
+    def _quiet=(quiet)
       # NOTE: This method is called only from ControllingExpression.
-      @suppress_notification = suppress_notification
+      if quiet
+        current_options.add(QUIET)
+      else
+        current_options.delete(QUIET)
+      end
     end
 
     def _active_function
@@ -459,6 +494,10 @@ module C #:nodoc:
       end
     end
 
+    def current_options
+      @options_stack.last || Set.new
+    end
+
     def interpreter
       # NOTE: This method is of the requirement for including
       #       InterpreterMediator.
@@ -471,6 +510,7 @@ module C #:nodoc:
     include NotifierMediator
     include Conversion
     include MonitorUtil
+    include InterpreterOptions
 
     def initialize(owner, target_node_class)
       @owner = owner
@@ -485,38 +525,6 @@ module C #:nodoc:
     end
   end
 
-  class TranslationUnitInterpreter < SubInterpreter
-    def initialize(owner)
-      super(owner, TranslationUnit)
-    end
-
-    def visit_declaration(node)
-      checkpoint(node.location)
-
-      interpret(node)
-    end
-
-    def visit_translation_unit(node)
-      checkpoint(node.location)
-
-      notify_translation_unit_started(node)
-      super
-      notify_translation_unit_ended(node)
-    end
-
-    def visit_ansi_function_definition(node)
-      checkpoint(node.location)
-
-      interpret(node)
-    end
-
-    def visit_kandr_function_definition(node)
-      checkpoint(node.location)
-
-      interpret(node)
-    end
-  end
-
   class DeclarationInterpreter < SubInterpreter
     def initialize(owner)
       super(owner, Declaration)
@@ -531,7 +539,8 @@ module C #:nodoc:
         decl.mark_as_referred_by(node.identifier)
       end
 
-      function = define_explicit_function(node)
+      function = declare_function(node)
+
       notify_function_declared(node, function)
 
       evaluate_sequence_point(node.init_declarator.declarator)
@@ -562,12 +571,12 @@ module C #:nodoc:
       end
 
       if initializer = node.initializer
-        init_variable, converted = evaluate_initializer(initializer, node.type)
+        init_var, converted = evaluate_initializer(initializer, node.type)
         variable = define_variable(node, converted.value.to_defined_value)
 
-        notify_variable_value_referred(node, init_variable)
+        notify_variable_value_referred(node, init_var)
         notify_variable_defined(node, variable)
-        notify_variable_initialized(node, variable, init_variable)
+        notify_variable_initialized(node, variable, init_var)
       else
         notify_variable_defined(node, define_variable(node))
       end
@@ -809,8 +818,6 @@ module C #:nodoc:
     def interpret_function(node)
       checkpoint(node.location)
 
-      interpreter._enter_function(node)
-
       reset_environment
       resolve_unresolved_type(node)
 
@@ -823,27 +830,32 @@ module C #:nodoc:
         function = define_explicit_function(node)
       end
 
-      scoped_eval do
-        notify_function_started(node, function)
-        notify_block_started(node.function_body)
+      notify_function_defined(node, function)
 
-        node.parameter_definitions.each { |pdef| interpret(pdef) }
+      begin
+        interpreter._enter_function(node)
+        scoped_eval do
+          notify_function_started(node, function)
+          notify_block_started(node.function_body)
 
-        BreakEvent.catch do
-          node.function_body.block_items.each { |item| interpret(item) }
-        end
+          node.parameter_definitions.each { |pdef| interpret(pdef) }
+
+          BreakEvent.catch do
+            node.function_body.block_items.each { |item| interpret(item) }
+          end
 
-        notify_block_ended(node.function_body)
-        notify_function_ended(node, function)
+          notify_block_ended(node.function_body)
+          notify_function_ended(node, function)
+        end
+      ensure
+        interpreter._leave_function(node)
       end
-    ensure
-      interpreter._leave_function(node)
     end
   end
 
   class StatementInterpreter < SubInterpreter
-    include BranchGroup::Option
-    include Branch::Option
+    include BranchOptions
+    include BranchGroupOptions
     include SyntaxNodeCollector
 
     def initialize(owner)
@@ -865,8 +877,7 @@ module C #:nodoc:
 
       node.executed = true
       ctrlexpr = node.expression
-      ctrlexpr_result = object_to_variable(interpret(ctrlexpr,
-                                                     :suppress_notification))
+      ctrlexpr_result = object_to_variable(interpret(ctrlexpr, QUIET))
       notify_case_ctrlexpr_evaled(node, ctrlexpr_result)
 
       interpret(node.statement)
@@ -905,7 +916,7 @@ module C #:nodoc:
 
       node.executed = true
       ctrlexpr = node.expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
       notify_if_ctrlexpr_evaled(node, ctrlexpr_value)
 
       case
@@ -931,7 +942,7 @@ module C #:nodoc:
 
       node.executed = true
       ctrlexpr = node.expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
       notify_if_else_ctrlexpr_evaled(node, ctrlexpr_value)
 
       case
@@ -1303,8 +1314,8 @@ module C #:nodoc:
   end
 
   class SwitchStatementInterpreter < SubInterpreter
-    include BranchGroup::Option
-    include Branch::Option
+    include BranchOptions
+    include BranchGroupOptions
 
     def initialize(owner)
       super(owner, SwitchStatement)
@@ -1367,7 +1378,7 @@ module C #:nodoc:
 
     def execute_branch(labeled_statement, block_items, index, branch_options)
       ctrlexpr = labeled_statement.normalized_expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
 
       case
       when ctrlexpr_value.must_be_true?
@@ -1411,7 +1422,7 @@ module C #:nodoc:
 
       branch.restart_versioning do
         ctrlexpr = labeled_statement.normalized_expression
-        ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+        ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
 
         case
         when ctrlexpr_value.must_be_true?
@@ -1481,6 +1492,8 @@ module C #:nodoc:
 
   class ExpressionInterpreter < SubInterpreter
     include ExpressionEvaluator
+    include BranchOptions
+    include BranchGroupOptions
 
     def initialize(owner)
       super(owner, Expression)
@@ -1534,10 +1547,54 @@ module C #:nodoc:
     def_eval_with_sequence_point :visit_inclusive_or_expression
     def_eval_with_sequence_point :visit_logical_and_expression
     def_eval_with_sequence_point :visit_logical_or_expression
-    def_eval_with_sequence_point :visit_conditional_expression
     def_eval_with_sequence_point :visit_simple_assignment_expression
     def_eval_with_sequence_point :visit_compound_assignment_expression
     def_eval_with_sequence_point :visit_comma_separated_expression
+
+    def visit_conditional_expression(node)
+      checkpoint(node.location)
+
+      ctrlexpr = node.condition
+      ctrlexpr_variable = interpret(ctrlexpr, QUIET)
+      ctrlexpr_value = value_of(ctrlexpr_variable)
+
+      then_var = nil
+      if ctrlexpr_value.may_be_true?
+        branched_eval(ctrlexpr, NARROWING) do
+          then_var = object_to_variable(interpret(node.then_expression))
+        end
+      end
+
+      else_var = nil
+      if ctrlexpr_value.may_be_false?
+        branched_eval(nil, NARROWING, FINAL, COMPLETE) do
+          else_var = object_to_variable(interpret(node.else_expression))
+        end
+      else
+        branched_eval(nil, NARROWING, FINAL, COMPLETE) {}
+      end
+
+      case
+      when then_var && else_var
+        result_val = then_var.value.single_value_unified_with(else_var.value)
+        result = temporary_variable(then_var.type, result_val)
+      when then_var
+        result = then_var
+      when else_var
+        result = else_var
+      else
+        # FIXME: Nevertheless, the then-expression is not reachable, the branch
+        #        execution check may fail in evaluation of the else branch.
+        result = temporary_variable
+      end
+
+      notify_conditional_expr_evaled(node, ctrlexpr_variable, result)
+      result
+    ensure
+      if sequence_point = node.subsequent_sequence_point
+        notify_sequence_point_reached(sequence_point)
+      end
+    end
   end
 
 end

data/lib/adlint/c/mediator.rb

@@ -106,6 +106,7 @@ module C #:nodoc:
     def_delegator :variable_table, :lookup, :variable_named
     def_delegator :variable_table, :declare, :declare_variable
     def_delegator :variable_table, :define, :define_variable
+    def_delegator :variable_table, :storage_duration_of
 
     def local_variables
       variable_table.all_named_variables.select { |variable|
@@ -132,6 +133,7 @@ module C #:nodoc:
     extend Forwardable
 
     def_delegator :function_table, :lookup, :function_named
+    def_delegator :function_table, :declare, :declare_function
     def_delegator :function_table, :define, :define_function
 
     def define_explicit_function(function_declaration_or_definition)
@@ -177,10 +179,11 @@ module C #:nodoc:
 
     extend Forwardable
 
-    def_delegator :interpreter, :notify_variable_initialized
+    def_delegator :interpreter, :notify_variable_declared
     def_delegator :interpreter, :notify_variable_defined
+    def_delegator :interpreter, :notify_variable_initialized
     def_delegator :interpreter, :notify_function_declared
-    def_delegator :interpreter, :notify_variable_declared
+    def_delegator :interpreter, :notify_function_defined
     def_delegator :interpreter, :notify_struct_declared
     def_delegator :interpreter, :notify_union_declared
     def_delegator :interpreter, :notify_enum_declared