adlint 3.0.4 → 3.0.8

data/lib/adlint/cc1/mediator.rb

@@ -97,6 +97,7 @@ module Cc1 #:nodoc:
     def_delegator :variable_table, :declare, :declare_variable
     def_delegator :variable_table, :define, :define_variable
     def_delegator :variable_table, :storage_duration_of
+    def_delegator :variable_table, :designators, :variable_designators
 
     def local_variables
       variable_table.all_named_variables.select { |var| var.scope.local? }
@@ -114,6 +115,7 @@ module Cc1 #:nodoc:
     extend Forwardable
 
     def_delegator :function_table, :lookup, :function_named
+    def_delegator :function_table, :designators, :function_designators
 
     def declare_explicit_function(fun_dcl)
       function_table.declare_explicitly(fun_dcl)
@@ -145,6 +147,7 @@ module Cc1 #:nodoc:
 
     def_delegator :enumerator_table, :lookup, :enumerator_named
     def_delegator :enumerator_table, :define, :define_enumerator
+    def_delegator :enumerator_table, :designators, :enumerator_designators
   end
 
   module NotifierMediator
@@ -174,6 +177,7 @@ module Cc1 #:nodoc:
     def_delegator :interpreter, :notify_sizeof_type_expr_evaled
     def_delegator :interpreter, :notify_explicit_conv_performed
     def_delegator :interpreter, :notify_implicit_conv_performed
+    def_delegator :interpreter, :notify_address_derivation_performed
     def_delegator :interpreter, :notify_array_subscript_expr_evaled
     def_delegator :interpreter, :notify_function_call_expr_evaled
     def_delegator :interpreter, :notify_unary_arithmetic_expr_evaled
@@ -239,6 +243,9 @@ module Cc1 #:nodoc:
     include EnumeratorTableMediator
     include ArithmeticAccessor
 
+    include InterpObjectBridge
+    include InterpSyntaxBridge
+
     def interpret(node, *opts)
       interpreter.execute(node, *opts)
     end
@@ -247,12 +254,6 @@ module Cc1 #:nodoc:
       environment.reset
     end
 
-    extend Forwardable
-
-    def_delegator :interpreter, :object_to_variable
-    def_delegator :interpreter, :value_of
-    def_delegator :interpreter, :pointer_value_of
-
     def scalar_value_of(numeric)
       ScalarValue.of(numeric, logical_right_shift?)
     end
@@ -269,6 +270,34 @@ module Cc1 #:nodoc:
       ScalarValue.of_arbitrary(logical_right_shift?)
     end
 
+    def constant_expression?(expr)
+      expr.constant?(_interp_syntax_bridge_)
+    end
+
+    def object_to_variable(obj, init_or_expr = nil)
+      obj.to_variable(_interp_object_bridge_).tap do |var|
+        if init_or_expr && !obj.type.pointer? && var.type.pointer?
+          notify_address_derivation_performed(init_or_expr, obj, var)
+        end
+      end
+    end
+
+    def object_to_pointer(obj, init_or_expr = nil)
+      obj.to_pointer(_interp_object_bridge_).tap do |ptr|
+        if init_or_expr
+          notify_address_derivation_performed(init_or_expr, obj, ptr)
+        end
+      end
+    end
+
+    def value_of(obj)
+      obj.to_value(_interp_object_bridge_)
+    end
+
+    def pointer_value_of(obj)
+      obj.to_pointer_value(_interp_object_bridge_)
+    end
+
     private
     def scoped_eval(&block)
       environment.enter_scope

data/lib/adlint/cc1/object.rb

@@ -147,6 +147,18 @@ module Cc1 #:nodoc:
     end
   end
 
+  module InterpObjectBridge
+    # NOTE: InterpreterMediator includes this module to bridge runtime object
+    #       creator to this layer.
+
+    def _interp_object_bridge_
+      {
+        create_tmpvar:   method(:create_tmpvar),
+        scalar_value_of: method(:scalar_value_of)
+      }
+    end
+  end
+
   class TypedObject < Object
     def initialize(type, dcl_or_def = nil)
       super(dcl_or_def)
@@ -154,6 +166,35 @@ module Cc1 #:nodoc:
     end
 
     attr_reader :type
+
+    def to_variable(interp_bridge)
+      if function? or variable? && @type.array?
+        to_pointer(interp_bridge)
+      else
+        self
+      end
+    end
+
+    def to_pointer(interp_bridge)
+      if @type.array?
+        ptr_type = @type.type_table.pointer_type(@type.base_type)
+      else
+        ptr_type = @type.type_table.pointer_type(@type)
+      end
+      interp_bridge[:create_tmpvar][ptr_type, to_pointer_value(interp_bridge)]
+    end
+
+    def to_value(interp_bridge)
+      if @type.array? || @type.function?
+        to_pointer_value(interp_bridge)
+      else
+        value.to_single_value
+      end
+    end
+
+    def to_pointer_value(interp_bridge)
+      interp_bridge[:scalar_value_of][binding.memory.address]
+    end
   end
 
   # == DESCRIPTION
@@ -643,6 +684,10 @@ module Cc1 #:nodoc:
       nil
     end
 
+    def designators
+      @named_variables.map { |hash| hash.keys }.flatten.to_set
+    end
+
     def enter_variables_value_versioning_group
       @named_variables.each do |hash|
         hash.each_value { |var| var.enter_value_versioning_group }
@@ -837,35 +882,29 @@ module Cc1 #:nodoc:
     private
     def assign_arguments_to_parameters(interp, args)
       args.zip(type.parameter_types).each do |(arg, expr), param_type|
+        arg_var = interp.object_to_variable(arg, expr)
+
         if param_type
           case
-          when arg.type.array? && param_type.pointer?
-            conved = interp.create_tmpvar(param_type,
-                                          interp.pointer_value_of(arg))
-          when arg.type.pointer? && param_type.array?
-            conved = interp.pointee_of(arg)
-          when arg.type.function? && param_type.pointer?
-            conved = interp.create_tmpvar(param_type,
-                                          interp.pointer_value_of(arg))
-          when arg.variable? && !arg.type.same_as?(param_type)
-            conved = interp.do_conversion(arg, param_type) ||
+          when arg_var.type.pointer? && param_type.array?
+            conved = interp.pointee_of(arg_var)
+          when !arg_var.type.same_as?(param_type)
+            conved = interp.do_conversion(arg_var, param_type) ||
                      interp.create_tmpvar(param_type)
+            interp.notify_implicit_conv_performed(expr, arg_var, conved)
           else
-            conved = arg
+            conved = arg_var
           end
         else
-          conved = interp.do_default_argument_promotion(arg)
+          conved = interp.do_default_argument_promotion(arg_var)
+          if arg_var != conved
+            interp.notify_implicit_conv_performed(expr, arg_var, conved)
+          end
         end
 
         # NOTE: Value of the argument is referred when the assignment to the
         #       parameter is performed.
-        if arg.variable? && !arg.type.array?
-          interp.notify_variable_value_referred(expr, arg)
-        end
-
-        if conved && arg != conved
-          interp.notify_implicit_conv_performed(expr, arg, conved)
-        end
+        interp.notify_variable_value_referred(expr, arg_var)
       end
     end
 
@@ -1045,6 +1084,10 @@ module Cc1 #:nodoc:
       end
       nil
     end
+
+    def designators
+      @functions.map { |hash| hash.keys }.flatten.to_set
+    end
   end
 
   class Memory