adlint 1.0.0

data/lib/adlint/c/resolver.rb

@@ -0,0 +1,270 @@
+# C type resolver.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, 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-2012, 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/monitor"
+require "adlint/c/type"
+require "adlint/c/syntax"
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class TypeResolver < SyntaxTreeVisitor
+    include MonitorUtil
+
+    def initialize(type_table)
+      @type_table = type_table
+    end
+
+    attr_reader :type_table
+
+    def resolve(syntax_tree)
+      syntax_tree.accept(self)
+      @type_table
+    end
+
+    def visit_struct_type_declaration(node)
+      checkpoint(node.location)
+      node.struct_declarations.each { |decl| decl.accept(self) }
+
+      node.type = @type_table.install_struct_type(node)
+    end
+
+    def visit_union_type_declaration(node)
+      checkpoint(node.location)
+      node.struct_declarations.each { |decl| decl.accept(self) }
+
+      node.type = @type_table.install_union_type(node)
+    end
+
+    def visit_struct_declaration(node)
+      node.items.each { |item| item.accept(self) }
+    end
+
+    def visit_member_declaration(node)
+      checkpoint(node.location)
+      node.specifier_qualifier_list.accept(self)
+      node.struct_declarator.accept(self)
+
+      type_qualifiers = node.specifier_qualifier_list.type_qualifiers
+      type_specifiers = node.specifier_qualifier_list.type_specifiers
+      type = lookup_variable_type(type_qualifiers, type_specifiers,
+                                  node.struct_declarator.declarator)
+      type = @type_table.pointer_type(type) if type.function?
+
+      if node.struct_declarator.bitfield?
+        if bit_width = compute_bitfield_width(node.struct_declarator)
+          type = @type_table.bitfield_type(type, bit_width)
+        else
+          type = fallback_type
+        end
+      end
+
+      node.type = type
+    end
+
+    def visit_enum_type_declaration(node)
+      checkpoint(node.location)
+      type = @type_table.install_enum_type(node)
+      node.type = type
+    end
+
+    def visit_typedef_declaration(node)
+      checkpoint(node.location)
+      node.declaration_specifiers.accept(self)
+      node.init_declarator.accept(self)
+
+      type = @type_table.install_user_type(node)
+      node.type = type
+    end
+
+    def visit_function_declaration(node)
+      checkpoint(node.location)
+      node.declaration_specifiers.accept(self) if node.declaration_specifiers
+      node.init_declarator.accept(self)
+
+      if declaration_specifiers = node.declaration_specifiers
+        type_qualifiers = declaration_specifiers.type_qualifiers
+        type_specifiers = declaration_specifiers.type_specifiers
+      else
+        type_qualifiers = []
+        type_specifiers = []
+      end
+
+      node.type = lookup_variable_type(type_qualifiers, type_specifiers,
+                                       node.init_declarator.declarator)
+    end
+
+    def visit_variable_declaration(node)
+      checkpoint(node.location)
+      node.declaration_specifiers.accept(self) if node.declaration_specifiers
+      node.declarator.accept(self)
+
+      if declaration_specifiers = node.declaration_specifiers
+        type_qualifiers = declaration_specifiers.type_qualifiers
+        type_specifiers = declaration_specifiers.type_specifiers
+      else
+        type_qualifiers = []
+        type_specifiers = []
+      end
+
+      type = lookup_variable_type(type_qualifiers, type_specifiers,
+                                  node.declarator)
+
+      if type.function?
+        node.type = @type_table.pointer_type(type)
+      else
+        node.type = type
+      end
+    end
+
+    def visit_variable_definition(node)
+      checkpoint(node.location)
+      node.declaration_specifiers.accept(self) if node.declaration_specifiers
+      node.init_declarator.accept(self)
+
+      if declaration_specifiers = node.declaration_specifiers
+        type_qualifiers = declaration_specifiers.type_qualifiers
+        type_specifiers = declaration_specifiers.type_specifiers
+      else
+        type_qualifiers = []
+        type_specifiers = []
+      end
+
+      type = lookup_variable_type(type_qualifiers, type_specifiers,
+                                  node.init_declarator.declarator)
+
+      if type.function?
+        node.type = @type_table.pointer_type(type)
+      else
+        node.type = type
+      end
+    end
+
+    def visit_ansi_function_definition(node)
+      checkpoint(node.location)
+      super
+      node.type = lookup_function_type(node)
+    end
+
+    def visit_kandr_function_definition(node)
+      checkpoint(node.location)
+      super
+      node.type = lookup_function_type(node)
+    end
+
+    def visit_parameter_definition(node)
+      checkpoint(node.location)
+      node.declaration_specifiers.accept(self) if node.declaration_specifiers
+      node.declarator.accept(self) if node.declarator
+
+      type = @type_table.lookup_parameter_type(node, interpreter)
+      type = @type_table.pointer_type(type) if type.function?
+      node.type = type
+    end
+
+    def visit_type_name(node)
+      checkpoint(node.location)
+      super
+      type_qualifiers = node.specifier_qualifier_list.type_qualifiers
+      type_specifiers = node.specifier_qualifier_list.type_specifiers
+      node.type = lookup_variable_type(type_qualifiers, type_specifiers,
+                                       node.abstract_declarator)
+    end
+
+    def visit_compound_statement(node)
+      @type_table.enter_scope
+      super
+      @type_table.leave_scope
+    end
+
+    private
+    def lookup_variable_type(type_qualifiers, type_specifiers, declarator)
+      type = @type_table.lookup_or_install_type(type_qualifiers,
+                                                type_specifiers,
+                                                declarator, interpreter)
+      type ? type : fallback_type
+    end
+
+    def lookup_function_type(function_definition)
+      type = @type_table.lookup_function_type(function_definition)
+      type ? type : fallback_type
+    end
+
+    def compute_bitfield_width(struct_declarator)
+      return nil unless expression = struct_declarator.expression
+
+      if interpreter
+        object = interpreter.execute(expression)
+        if object.variable? && object.value.scalar?
+          return object.value.unique_sample
+        end
+      else
+        object = Interpreter.new(@type_table).execute(expression)
+        if object.variable? && object.value.scalar?
+          return object.value.unique_sample
+        end
+      end
+
+      nil
+    end
+  end
+
+  class StaticTypeResolver < TypeResolver
+    def initialize
+      super(TypeTable.new)
+    end
+
+    private
+    def interpreter
+      nil
+    end
+
+    def fallback_type
+      type_table.unresolved_type
+    end
+  end
+
+  class DynamicTypeResolver < TypeResolver
+    def initialize(type_table, interpreter)
+      super(type_table)
+      @interpreter = interpreter
+    end
+
+    attr_reader :interpreter
+
+    private
+    def fallback_type
+      type_table.undeclared_type
+    end
+  end
+
+end
+end

data/lib/adlint/c/scanner.rb

@@ -0,0 +1,248 @@
+# Scanner for C language.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, 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-2012, 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/>.
+#
+#++
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  # == DESCRIPTION
+  # Constants for scanning the C source code.
+  module ScannerConstants
+    # === DESCRIPTION
+    # C keywords table.
+    KEYWORDS = {
+      "sizeof" => :SIZEOF,
+      "typedef" => :TYPEDEF,
+      "extern" => :EXTERN,
+      "static" => :STATIC,
+      "auto" => :AUTO,
+      "register" => :REGISTER,
+      "inline" => :INLINE,
+      "restrict" => :RESTRICT,
+      "char" => :CHAR,
+      "short" => :SHORT,
+      "int" => :INT,
+      "long" => :LONG,
+      "signed" => :SIGNED,
+      "unsigned" => :UNSIGNED,
+      "float" => :FLOAT,
+      "double" => :DOUBLE,
+      "const" => :CONST,
+      "volatile" => :VOLATILE,
+      "void" => :VOID,
+      "_Bool" => :BOOL,
+      "_Complex" => :COMPLEX,
+      "_Imaginary" => :IMAGINARY,
+      "struct" => :STRUCT,
+      "union" => :UNION,
+      "enum" => :ENUM,
+      "case" => :CASE,
+      "default" => :DEFAULT,
+      "if" => :IF,
+      "else" => :ELSE,
+      "switch" => :SWITCH,
+      "while" => :WHILE,
+      "do" => :DO,
+      "for" => :FOR,
+      "goto" => :GOTO,
+      "continue" => :CONTINUE,
+      "break" => :BREAK,
+      "return" => :RETURN,
+      "__typeof__" => :TYPEOF,
+      "__alignof__" => :ALIGNOF
+    }.freeze
+
+    KEYWORD_VALUES = KEYWORDS.keys.to_set.freeze
+
+    # === DESCRIPTION
+    # C punctuators table.
+    PUNCTUATORS = [
+      "{", "}", "(", ")", "[", "]", ";", ",", "::", ":", "?", "||",
+      "|=", "|", "&&", "&=", "&", "^=", "^", "==", "=", "!=", "!",
+      "<<=", "<=", "<<", "<", ">>=", ">=", ">>", ">", "+=", "++", "+",
+      "->*", "->", "-=", "--", "-", "*=", "*", "/=", "/", "%=", "%",
+      "...", ".*", ".", "~",
+    ].to_set.freeze
+  end
+
+  # == DESCRIPTION
+  # Utility module for scanning the C source code.
+  module Scanner
+    include ScannerConstants
+
+    # === DESCRIPTION
+    # Scans C identifier.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C identifier string if found at head of the content.
+    def scan_identifier(content)
+      content.scan(/[a-z_][a-z_0-9]*\b/i)
+    end
+
+    KEYWORDS_RE = Regexp.new(KEYWORD_VALUES.map { |keyword|
+      "#{keyword}\\b"
+    }.join("|")).freeze
+    private_constant :KEYWORDS_RE
+
+    # === DESCRIPTION
+    # Scans C keyword.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C keyword string if found at head of the content.
+    def scan_keyword(content)
+      content.scan(KEYWORDS_RE)
+    end
+
+    PUNCTUATORS_RE = Regexp.new(PUNCTUATORS.sort { |l, r|
+      r.length <=> l.length
+    }.map { |punct|
+      punct.each_char.map { |ch| '\\' + ch }.join
+    }.join("|")).freeze
+    private_constant :PUNCTUATORS_RE
+
+    # === DESCRIPTION
+    # Scans C punctuator.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C punctuator string if found at head of the content.
+    def scan_punctuator(content)
+      content.scan(PUNCTUATORS_RE)
+    end
+
+    # === DESCRIPTION
+    # Scans C integer constant.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C integer constant string if found at head of the
+    # content.
+    def scan_integer_constant(content)
+      content.scan(/(?:0x[0-9a-f]+|0b[01]+|[0-9]+)[UL]*/i)
+    end
+
+    # === DESCRIPTION
+    # Scans C floating constant.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C floating constant string if found at head of the
+    # content.
+    def scan_floating_constant(content)
+      content.scan(
+        /(?:[0-9]*\.[0-9]*E[+-]?[0-9]+|[0-9]+\.?E[+-]?[0-9]+)[FL]*/i) ||
+      content.scan(/(?:[0-9]*\.[0-9]+|[0-9]+\.)[FL]*/i)
+    end
+
+    # === DESCRIPTION
+    # Scans C character constant.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C character constant string if found at head of the
+    # content.
+    def scan_char_constant(content)
+      scanned = content.scan(/L?'/i)
+      return nil unless scanned
+
+      until content.empty?
+        str = content.scan(/.*?(?=\\|')/m)
+        scanned << str if str
+        next if content.scan(/\\[ \t]*\n/)
+        case
+        when content.check(/\\/)
+          scanned << content.eat!(2)
+        when quote = content.scan(/'/)
+          scanned << quote
+          break
+        end
+      end
+
+      scanned
+    end
+
+    # === DESCRIPTION
+    # Scans C string literal.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C string literal string if found at head of the
+    # content.
+    def scan_string_literal(content)
+      scanned = content.scan(/L?"/i)
+      return nil unless scanned
+
+      until content.empty?
+        str = content.scan(/.*?(?=\\|")/m)
+        scanned << str if str
+        next if content.scan(/\\[ \t]*\n/)
+        case
+        when content.check(/\\/)
+          scanned << content.eat!(2)
+        when quote = content.scan(/"/)
+          scanned << quote
+          break
+        end
+      end
+
+      scanned
+    end
+
+    # === DESCRIPTION
+    # Scans C NULL constant.
+    #
+    # === PARAMETER
+    # _content_:: StringContent -- Scanning source.
+    #
+    # === RETURN VALUE
+    # String -- Returns C NULL constant string if found at head of the content.
+    def scan_null_constant(content)
+      content.scan(/NULL\b/)
+    end
+  end
+
+end
+end

data/lib/adlint/c/scope.rb

@@ -0,0 +1,74 @@
+# C runtime scope.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, 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-2012, 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/>.
+#
+#++
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class Scope
+    def initialize(depth)
+      @depth = depth
+    end
+
+    attr_reader :depth
+
+    def global?
+      @depth == 0
+    end
+
+    def local?
+      @depth > 0
+    end
+
+    def inner_scope
+      Scope.new(@depth + 1)
+    end
+
+    def outer_scope
+      Scope.new(@depth - 1)
+    end
+
+    def eql?(rhs)
+      @depth == rhs.depth
+    end
+
+    def hash
+      @depth.hash
+    end
+  end
+
+  class GlobalScope < Scope
+    def initialize
+      super(0)
+    end
+  end
+
+end
+end