adlint 2.6.14 → 3.0.0

data/lib/adlint/cc1/lexer.rb

@@ -0,0 +1,246 @@
+# Lexical analyzer which retokenizes pp-tokens into c-tokens.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
+#
+# This file is part of AdLint.
+#
+# AdLint is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# AdLint is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# AdLint.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/lexer"
+require "adlint/util"
+require "adlint/cc1/scanner"
+require "adlint/cc1/scope"
+
+module AdLint #:nodoc:
+module Cc1 #:nodoc:
+
+  class Lexer < TokensRelexer
+    def initialize(pp_src)
+      super(pp_src.pp_tokens)
+      @lst_tok = nil
+      @nxt_tok = nil
+      @typedef_names = ScopedNameSet.new
+      @object_names  = ScopedNameSet.new
+      @identifier_translation = true
+    end
+
+    extend Pluggable
+
+    def_plugin :on_string_literals_concatenated
+
+    def add_typedef_name(tok)
+      @typedef_names.add(tok.value)
+    end
+
+    def add_object_name(tok)
+      @object_names.add(tok.value)
+    end
+
+    def enter_scope
+      @typedef_names.enter_scope
+      @object_names.enter_scope
+    end
+
+    def leave_scope
+      @typedef_names.leave_scope
+      @object_names.leave_scope
+    end
+
+    def start_identifier_translation
+      @identifier_translation = true
+    end
+
+    def stop_identifier_translation
+      @identifier_translation = false
+    end
+
+    private
+    def create_lexer_context(tok_ary)
+      LexerContext.new(TokensContent.new(tok_ary))
+    end
+
+    def tokenize(lexer_ctxt)
+      if @nxt_tok
+        tok = @nxt_tok
+        @nxt_tok = nil
+      else
+        until lexer_ctxt.content.empty?
+          pp_tok = lexer_ctxt.content.next_token
+
+          if type_hint = pp_tok.type_hint
+            tok = pp_tok.class.new(type_hint, pp_tok.value, pp_tok.location)
+          else
+            tok = retokenize_keyword(pp_tok, lexer_ctxt)        ||
+                  retokenize_constant(pp_tok, lexer_ctxt)       ||
+                  retokenize_string_literal(pp_tok, lexer_ctxt) ||
+                  retokenize_null_constant(pp_tok, lexer_ctxt)  ||
+                  retokenize_identifier(pp_tok, lexer_ctxt)     ||
+                  retokenize_punctuator(pp_tok, lexer_ctxt)
+          end
+
+          break if tok
+        end
+      end
+
+      if tok
+        case tok.type
+        when :IDENTIFIER
+          tok = translate_identifier(tok, lexer_ctxt)
+        when :STRING_LITERAL
+          tok = concat_contiguous_string_literals(tok, lexer_ctxt)
+        end
+        @lst_tok = tok
+      else
+        nil
+      end
+    end
+
+    def translate_identifier(tok, lexer_ctxt)
+      if @identifier_translation
+        if tok.type == :IDENTIFIER
+          return tok if @object_names.include?(tok.value)
+          if @typedef_names.include?(tok.value)
+            unless @lst_tok and
+                   @lst_tok.type == :STRUCT || @lst_tok.type == :UNION ||
+                   @lst_tok.type == :ENUM ||
+                   @lst_tok.type == "->" || @lst_tok.type == "."
+              tok = tok.class.new(:TYPEDEF_NAME, tok.value, tok.location)
+            end
+          end
+        end
+      end
+      tok
+    end
+
+    def concat_contiguous_string_literals(tok, lexer_ctxt)
+      until lexer_ctxt.content.empty?
+        nxt_tok = tokenize(lexer_ctxt)
+        if nxt_tok.type == :STRING_LITERAL
+          res_tok = tok.class.new(tok.type, tok.value.sub(/"\z/, "") +
+                                 nxt_tok.value.sub(/\AL?"/, ""),
+                                 tok.location)
+          notify_string_literals_concatenated(tok, nxt_tok, res_tok)
+          return res_tok
+        else
+          @nxt_tok = nxt_tok
+          break
+        end
+      end
+      tok
+    end
+
+    def retokenize_keyword(pp_tok, lexer_ctxt)
+      if keyword = Scanner::KEYWORDS[pp_tok.value]
+        pp_tok.class.new(keyword, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def retokenize_constant(pp_tok, lexer_ctxt)
+      # NOTE: For extended bit-access operators.
+      return nil if @lst_tok && @lst_tok.type == :IDENTIFIER
+
+      case pp_tok.value
+      when /\AL?'.*'\z/,
+           /\A(?:[0-9]*\.[0-9]+|[0-9]+\.)[FL]*\z/i,
+           /\A(?:[0-9]*\.[0-9]*E[+-]?[0-9]+|[0-9]+\.?E[+-]?[0-9]+)[FL]*\z/i,
+           /\A(?:0x[0-9a-f]+|0b[01]+|[0-9]+)[UL]*\z/i
+        pp_tok.class.new(:CONSTANT, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def retokenize_string_literal(pp_tok, lexer_ctxt)
+      if pp_tok.value =~ /\AL?".*"\z/
+        pp_tok.class.new(:STRING_LITERAL, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def retokenize_null_constant(pp_tok, lexer_ctxt)
+      if pp_tok.value == "NULL"
+        pp_tok.class.new(:NULL, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def retokenize_identifier(pp_tok, lexer_ctxt)
+      if pp_tok.value =~ /\A[a-z_][a-z_0-9]*\z/i
+        pp_tok.class.new(:IDENTIFIER, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def retokenize_punctuator(pp_tok, lexer_ctxt)
+      case pp_tok.value
+      when "{", "}", "(", ")", "[", "]", ";", ",", "::", ":", "?", "||",
+           "|=", "|", "&&", "&=", "&", "^=", "^", "==", "=", "!=", "!",
+           "<<=", "<=", "<<", "<", ">>=", ">=", ">>", ">", "+=", "++", "+",
+           "->*", "->", "-=", "--", "-", "*=", "*", "/=", "/", "%=", "%",
+           "...", ".*", ".", "~"
+        pp_tok.class.new(pp_tok.value, pp_tok.value, pp_tok.location)
+      else
+        nil
+      end
+    end
+
+    def notify_string_literals_concatenated(former, latter, res_tok)
+      on_string_literals_concatenated.invoke(former, latter, res_tok)
+    end
+  end
+
+  class ScopedNameSet
+    def initialize
+      @name_stack  = [Set.new]
+      @scope_stack = [GlobalScope.new]
+    end
+
+    def enter_scope
+      @name_stack.push(Set.new)
+      @scope_stack.push(Scope.new(@scope_stack.size))
+    end
+
+    def leave_scope
+      @name_stack.pop
+      @scope_stack.pop
+    end
+
+    def add(name)
+      @name_stack.last.add(name)
+    end
+
+    def include?(name)
+      @name_stack.any? { |set| set.include?(name) }
+    end
+  end
+
+end
+end

data/lib/adlint/{c → cc1}/mediator.rb

@@ -1,7 +1,7 @@
 # C interpreter mediator.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,16 +29,17 @@
 #
 #++
 
-require "adlint/c/type"
-require "adlint/c/object"
-require "adlint/c/enum"
-require "adlint/c/syntax"
+require "adlint/traits"
+require "adlint/cc1/type"
+require "adlint/cc1/object"
+require "adlint/cc1/enum"
+require "adlint/cc1/syntax"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   module TypeTableMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #type_table.
 
     include StandardTypeCatalogAccessor
 
@@ -46,7 +47,7 @@ module C #:nodoc:
 
     def_delegator :type_table, :lookup, :type_of
     def_delegator :type_table, :undeclared_type
-    def_delegator :type_table, :wchar_type
+    def_delegator :type_table, :wchar_t
     def_delegator :type_table, :array_type
     def_delegator :type_table, :function_type
     def_delegator :type_table, :bitfield_type
@@ -57,49 +58,38 @@ module C #:nodoc:
     def standard_type_catalog
       type_table.standard_type_catalog
     end
-
-    def type_table
-      # NOTE: Host class must respond to #type_table.
-      subclass_responsibility
-    end
   end
 
   module MemoryPoolMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #memory_pool.
 
     extend Forwardable
 
     def_delegator :memory_pool, :lookup, :memory_at
 
-    def pointee_of(pointer)
+    def pointee_of(ptr)
       # FIXME: This method should return multiple objects, because domain of
       #        the pointer_value may have multiple address values.
       #
-      # pointer.value.to_enum.map { |address|
-      #   memory = memory_at(address) ? memory.binding.object : nil
+      # ptr.value.to_enum.map { |addr|
+      #   mem = memory_at(addr) ? mem.binding.object : nil
       # }.compact
 
-      pointer.value.to_enum.each do |address|
-        if memory = memory_at(address)
-          object = memory.binding.object
-          if object.variable? or
-              object.function? && pointer.type.unqualify.base_type.function?
-            return object
+      ptr.value.to_enum.each do |addr|
+        if mem = memory_at(addr)
+          obj = mem.binding.object
+          if obj.variable? or
+              obj.function? && ptr.type.unqualify.base_type.function?
+            return obj
           end
         end
       end
       nil
     end
-
-    private
-    def memory_pool
-      # NOTE: Host class must respond to #memory_pool.
-      subclass_responsibility
-    end
   end
 
   module VariableTableMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #variable_table.
 
     extend Forwardable
 
@@ -109,80 +99,64 @@ module C #:nodoc:
     def_delegator :variable_table, :storage_duration_of
 
     def local_variables
-      variable_table.all_named_variables.select { |variable|
-        variable.scope.local?
-      }
+      variable_table.all_named_variables.select { |var| var.scope.local? }
     end
 
-    def create_tempvar(type = undeclared_type, value = type.undefined_value)
-      variable_table.define_temporary(type, value)
-    end
-
-    private
-    def variable_table
-      # NOTE: Host class must respond to #variable_table.
-      subclass_responsibility
+    def create_tmpvar(type = undeclared_type, val = type.undefined_value)
+      variable_table.define_temporary(type, val)
     end
   end
 
   module FunctionTableMediator
     # NOTE: The host class of this module must include TypeTableMediator.
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #function_table.
 
     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)
-      define_function(ExplicitFunction.new(function_declaration_or_definition))
+    def declare_explicit_function(fun_dcl)
+      function_table.declare_explicitly(fun_dcl)
+    end
+
+    def declare_implicit_function(name)
+      function_table.declare_implicitly(
+        ImplicitFunction.new(default_function_type, name))
     end
 
-    def define_implicit_function(name)
-      define_function(ImplicitFunction.new(default_function_type, name))
+    def define_explicit_function(fun_dcl_or_def)
+      function_table.define(ExplicitFunction.new(fun_dcl_or_def))
     end
 
     def define_anonymous_function(type)
-      define_function(AnonymousFunction.new(type))
+      function_table.define(AnonymousFunction.new(type))
     end
 
     private
     def default_function_type
-      function_type(int_type, [])
-    end
-
-    def function_table
-      # NOTE: Host class must respond to #function_table.
-      subclass_responsibility
+      function_type(int_t, [])
     end
   end
 
   module EnumeratorTableMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #enumerator_table.
 
     extend Forwardable
 
     def_delegator :enumerator_table, :lookup, :enumerator_named
     def_delegator :enumerator_table, :define, :define_enumerator
-
-    private
-    def enumerator_table
-      # NOTE: Host class must respond to #enumerator_table.
-      subclass_responsibility
-    end
   end
 
   module NotifierMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #interpreter.
 
     extend Forwardable
 
     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_function_defined
+    def_delegator :interpreter, :notify_explicit_function_declared
+    def_delegator :interpreter, :notify_explicit_function_defined
     def_delegator :interpreter, :notify_struct_declared
     def_delegator :interpreter, :notify_union_declared
     def_delegator :interpreter, :notify_enum_declared
@@ -195,6 +169,7 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_variable_value_referred
     def_delegator :interpreter, :notify_variable_value_updated
     def_delegator :interpreter, :notify_function_referred
+    def_delegator :interpreter, :notify_implicit_function_declared
     def_delegator :interpreter, :notify_sizeof_expr_evaled
     def_delegator :interpreter, :notify_sizeof_type_expr_evaled
     def_delegator :interpreter, :notify_explicit_conv_performed
@@ -252,25 +227,20 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_translation_unit_started
     def_delegator :interpreter, :notify_translation_unit_ended
     def_delegator :interpreter, :notify_sequence_point_reached
-
-    private
-    def interpreter
-      # NOTE: Host class must respond to #interpreter.
-      subclass_responsibility
-    end
   end
 
   module InterpreterMediator
-    # NOTE: This module works like a CRTP base entity in C++.
+    # NOTE: Host class must respond to #interpreter.
 
     include TypeTableMediator
     include MemoryPoolMediator
     include VariableTableMediator
     include FunctionTableMediator
     include EnumeratorTableMediator
+    include ArithmeticAccessor
 
-    def interpret(node, *options)
-      interpreter.execute(node, *options)
+    def interpret(node, *opts)
+      interpreter.execute(node, *opts)
     end
 
     def reset_environment
@@ -283,6 +253,22 @@ module C #:nodoc:
     def_delegator :interpreter, :value_of
     def_delegator :interpreter, :pointer_value_of
 
+    def scalar_value_of(numeric)
+      ScalarValue.of(numeric, logical_right_shift?)
+    end
+
+    def scalar_value_of_true
+      ScalarValue.of_true(logical_right_shift?)
+    end
+
+    def scalar_value_of_false
+      ScalarValue.of_false(logical_right_shift?)
+    end
+
+    def scalar_value_of_arbitrary
+      ScalarValue.of_arbitrary(logical_right_shift?)
+    end
+
     private
     def scoped_eval(&block)
       environment.enter_scope
@@ -291,10 +277,10 @@ module C #:nodoc:
       environment.leave_scope
     end
 
-    def branched_eval(expression = nil, *options, &block)
-      current_branch = environment.enter_branch(*options)
+    def branched_eval(expr = nil, *opts, &block)
+      current_branch = environment.enter_branch(*opts)
       interpreter.notify_branch_started(current_branch)
-      current_branch.execute(interpreter, expression, &block)
+      current_branch.execute(interpreter, expr, &block)
     ensure
       interpreter.notify_branch_ended(current_branch)
       environment.leave_branch_group if current_branch.final?
@@ -307,18 +293,26 @@ module C #:nodoc:
 
     extend Forwardable
 
-    def_delegator :interpreter, :environment
-
     def_delegator :environment, :type_table
+    private :type_table
+
     def_delegator :environment, :memory_pool
+    private :memory_pool
+
     def_delegator :environment, :variable_table
+    private :variable_table
+
     def_delegator :environment, :function_table
+    private :function_table
+
     def_delegator :environment, :enumerator_table
+    private :enumerator_table
 
-    def interpreter
-      # NOTE: Host class must respond to #interpreter.
-      subclass_responsibility
-    end
+    def_delegator :interpreter, :environment
+    private :environment
+
+    def_delegator :interpreter, :traits
+    private :traits
   end
 
 end