adlint 3.0.4 → 3.0.8

data/lib/adlint/ld/typedef.rb

@@ -57,7 +57,7 @@ module Ld #:nodoc:
     end
   end
 
-  class TypedefMapping
+  class TypedefMap
     def initialize
       @name_index = Hash.new { |hash, key| hash[key] = Set.new }
       @composing_fpaths = Set.new
@@ -83,10 +83,10 @@ module Ld #:nodoc:
 
   class TypedefMapper
     def initialize
-      @result = TypedefMapping.new
+      @map = TypedefMap.new
     end
 
-    attr_reader :result
+    attr_reader :map
 
     def execute(met_fpath)
       sma_wd = Pathname.pwd
@@ -96,15 +96,15 @@ module Ld #:nodoc:
         when rec.version?
           sma_wd = Pathname.new(rec.exec_working_directory)
         when rec.typedef_declaration?
-          @result.add(Typedef.new(rec.type_name, rec.location))
+          @map.add(Typedef.new(rec.type_name, rec.location))
         end
       end
     end
   end
 
   class TypedefTraversal
-    def initialize(typedef_mapping)
-      @typedef_mapping = typedef_mapping
+    def initialize(typedef_map)
+      @map = typedef_map
     end
 
     extend Pluggable
@@ -112,7 +112,7 @@ module Ld #:nodoc:
     def_plugin :on_declaration
 
     def execute
-      @typedef_mapping.all_typedefs.each { |tdef| on_declaration.invoke(tdef) }
+      @map.all_typedefs.each { |tdef| on_declaration.invoke(tdef) }
     end
   end
 

data/lib/adlint/ld/util.rb

@@ -39,21 +39,25 @@ module Ld #:nodoc:
         map_fname = Pathname.new("#{proj_name}.map")
         map_fpath = map_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-        mapping = phase_ctxt[:ld_function_mapping]
-        call_graph = phase_ctxt[:ld_function_call_graph]
-        return unless mapping && call_graph
+        map = phase_ctxt[:ld_function_map]
+        call_graph = phase_ctxt[:ld_call_graph]
+        return unless map && call_graph
 
         File.open(map_fpath, "w") do |io|
           io.puts("-- Function Call Graph --")
-          mapping.all_functions.each do |callee|
+          map.all_functions.each do |callee|
             io.puts("DC of #{callee.signature}")
-            call_graph.direct_callers_of(callee).each do |fun|
-              io.puts(" #{fun.signature}")
+            call_graph.direct_callers_of(callee).each do |ref|
+              if fun = ref.function
+                io.puts(" #{fun.signature}")
+              end
             end
             io.puts
             io.puts("IC of #{callee.signature}")
-            call_graph.indirect_callers_of(callee).each do |fun|
-              io.puts(" #{fun.signature}")
+            call_graph.indirect_callers_of(callee).each do |ref|
+              if fun = ref.function
+                io.puts(" #{fun.signature}")
+              end
             end
             io.puts
           end
@@ -68,21 +72,25 @@ module Ld #:nodoc:
         map_fname = Pathname.new("#{proj_name}.map")
         map_fpath = map_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-        mapping = phase_ctxt[:ld_variable_mapping]
-        ref_graph = phase_ctxt[:ld_variable_reference_graph]
-        return unless mapping && ref_graph
+        map = phase_ctxt[:ld_variable_map]
+        ref_graph = phase_ctxt[:ld_xref_graph]
+        return unless map && ref_graph
 
         File.open(map_fpath, "a") do |io|
           io.puts("-- Variable Reference Graph --")
-          mapping.all_variables.each do |accessee|
+          map.all_variables.each do |accessee|
             io.puts("DR of #{accessee.name}")
-            ref_graph.direct_referrers_of(accessee).each do |fun|
-              io.puts(" #{fun.signature}")
+            ref_graph.direct_referrers_of(accessee).each do |ref|
+              if fun = ref.function
+                io.puts(" #{fun.signature}")
+              end
             end
             io.puts
-            io.puts("IR or #{accessee.signature}")
-            ref_graph.indirect_referrers_of(accessee).each do |fun|
-              io.puts(" #{fun.signature}")
+            io.puts("IR or #{accessee.name}")
+            ref_graph.indirect_referrers_of(accessee).each do |ref|
+              if fun = ref.function
+                io.puts(" #{fun.signature}")
+              end
             end
             io.puts
           end

data/lib/adlint/location.rb

@@ -69,7 +69,12 @@ module AdLint #:nodoc:
         false
       end
     end
-    memoize :in_analysis_target?
+    # NOTE: Value of #in_analysis_target? depends on the `traits' parameter.
+    #       But the `traits' parameter always points the same object in an
+    #       AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :in_analysis_target?, force_nullary: true
 
     def ==(rhs)
       self.to_a == rhs.to_a

data/lib/adlint/memo.rb

@@ -32,20 +32,29 @@
 module AdLint #:nodoc:
 
   module Memoizable
-    def memoize(name, *key_indices)
-      if instance_method(name).arity == 0
-        memoize_noarg_method(name)
+    def memoize(name, *opts)
+      force_nullary, key_indices = extract_memoize_options(opts)
+      case
+      when instance_method(name).arity == 0 || force_nullary
+        memoize_nullary_method(name)
+      when instance_method(name).arity == 1 || key_indices.size == 1
+        memoize_unary_method(name, key_indices.first || 0)
       else
-        memoize_ordinary_method(name, key_indices)
+        memoize_polynomial_method(name, key_indices)
       end
     end
 
     private
-    def memoize_noarg_method(name)
+    def extract_memoize_options(opts)
+      hash = opts.first || {}
+      [hash[:force_nullary], hash[:key_indices] || []]
+    end
+
+    def memoize_nullary_method(name)
       save_memoizing_method(name)
-      prepare_noarg_method_cache(name)
+      prepare_nullary_method_cache(name)
       class_eval <<-EOS
-        define_method(:#{name}) do
+        define_method(:#{name}) do |*args|
           if #{cache_name_of(name)}_initialized ||= false
             #{cache_name_of(name)}_forbidden = false
             #{cache_name_of(name)}
@@ -55,16 +64,43 @@ module AdLint #:nodoc:
               #{org_name_of(name)}
             else
               #{cache_name_of(name)}_initialized = true
-              #{cache_name_of(name)} = #{org_name_of(name)}
+              #{cache_name_of(name)} = #{org_name_of(name)}(*args)
+            end
+          end
+        end
+      EOS
+    end
+
+    def memoize_unary_method(name, key_index)
+      save_memoizing_method(name)
+      prepare_unary_method_cache(name, key_index)
+      class_eval <<-EOS
+        define_method(:#{name}) do |*args|
+          key = args[#{key_index}]
+          if #{cache_name_of(name)}_initialized ||= false
+            #{cache_name_of(name)}_forbidden = false
+            if #{cache_name_of(name)}.include?(key)
+              #{cache_name_of(name)}[key]
+            else
+              #{cache_name_of(name)}[key] = #{org_name_of(name)}(*args)
+            end
+          else
+            if #{cache_name_of(name)}_forbidden ||= false
+              #{cache_name_of(name)}_forbidden = false
+              #{org_name_of(name)}(*args)
+            else
+              #{cache_name_of(name)}_initialized = true
+              #{cache_name_of(name)} = {}
+              #{cache_name_of(name)}[key] = #{org_name_of(name)}(*args)
             end
           end
         end
       EOS
     end
 
-    def memoize_ordinary_method(name, key_indices)
+    def memoize_polynomial_method(name, key_indices)
       save_memoizing_method(name)
-      prepare_ordinary_method_cache(name, key_indices)
+      prepare_polynomial_method_cache(name, key_indices)
       class_eval <<-EOS
         define_method(:#{name}) do |*args|
           key = __key_for_#{name}(*args)
@@ -89,7 +125,7 @@ module AdLint #:nodoc:
       EOS
     end
 
-    def prepare_noarg_method_cache(name)
+    def prepare_nullary_method_cache(name)
       class_eval <<-EOS
         define_method(:forbid_once_memo_of__#{name}) do
           #{cache_name_of(name)}_forbidden = true
@@ -104,7 +140,24 @@ module AdLint #:nodoc:
       EOS
     end
 
-    def prepare_ordinary_method_cache(name, key_indices)
+    def prepare_unary_method_cache(name, key_index)
+      class_eval <<-EOS
+        define_method(:forbid_once_memo_of__#{name}) do
+          #{cache_name_of(name)}_forbidden = true
+        end
+        define_method(:clear_memo_of__#{name}) do
+          #{cache_name_of(name)} = nil
+          #{cache_name_of(name)}_initialized = false
+        end
+        define_method(:forget_memo_of__#{name}) do |*args|
+          if #{cache_name_of(name)}_initialized
+            #{cache_name_of(name)}.delete(args[#{key_index}])
+          end
+        end
+      EOS
+    end
+
+    def prepare_polynomial_method_cache(name, key_indices)
       define_key_generator(name, key_indices)
       class_eval <<-EOS
         define_method(:forbid_once_memo_of__#{name}) do
@@ -147,7 +200,7 @@ module AdLint #:nodoc:
     end
 
     def cache_name_of(name)
-      "@__cache_of__#{name.to_s.sub("?", "Q")}"
+      "@__cache_of__#{name.to_s.sub("?", "P")}"
     end
 
     def org_name_of(name)

data/lib/adlint/prelude.rb

@@ -327,9 +327,9 @@ end
 #         string_item: "foo${VAR}baz"
 #
 class Psych::TreeBuilder < Psych::Handler
-  alias :_orig_scalar :scalar
+  alias :_org_scalar :scalar
   def scalar(value, anchor, tag, plain, quoted, style)
-    _orig_scalar(substitute_environment_variables(value),
+    _org_scalar(substitute_environment_variables(value),
                  anchor, tag, plain, quoted, style)
   end
 

data/lib/adlint/report.rb

@@ -248,7 +248,7 @@ module AdLint #:nodoc:
     # Writes a function declaration information on the report.
     #
     # Abbreviation below is available.
-    #  write_funcdcl(...) => FUNCDCL(...)
+    #  write_fundcl(...) => FUNDCL(...)
     #
     # === PARAMETER
     # _loc_:: Location -- Location where the declaration appears.
@@ -259,11 +259,10 @@ module AdLint #:nodoc:
     #
     # === RETURN VALUE
     # None.
-    def write_funcdcl(loc, linkage, scope_type, dcl_type, fun_id)
-      write_code_struct(FuncDcl.new(loc, linkage, scope_type, dcl_type,
-                                    fun_id))
+    def write_fundcl(loc, linkage, scope_type, dcl_type, fun_id)
+      write_code_struct(FunDcl.new(loc, linkage, scope_type, dcl_type, fun_id))
     end
-    alias :FUNCDCL :write_funcdcl
+    alias :FUNDCL :write_fundcl
 
     # === DESCRIPTION
     # Writes a variable definition information on the report.
@@ -291,7 +290,7 @@ module AdLint #:nodoc:
     # Writes a function definition information on the report.
     #
     # Abbreviation below is available.
-    #  write_funcdef(...) => FUNCDEF(...)
+    #  write_fundef(...) => FUNDEF(...)
     #
     # === PARAMETER
     # _loc_:: Location -- Location where the definition appears.
@@ -302,10 +301,10 @@ module AdLint #:nodoc:
     #
     # === RETURN VALUE
     # None.
-    def write_funcdef(loc, linkage, scope_type, fun_id, lines)
-      write_code_struct(FuncDef.new(loc, linkage, scope_type, fun_id, lines))
+    def write_fundef(loc, linkage, scope_type, fun_id, lines)
+      write_code_struct(FunDef.new(loc, linkage, scope_type, fun_id, lines))
     end
-    alias :FUNCDEF :write_funcdef
+    alias :FUNDEF :write_fundef
 
     # === DESCRIPTION
     # Writes a macro definition information on the report.
@@ -399,16 +398,16 @@ module AdLint #:nodoc:
     # Writes a function call information on the report.
     #
     # Abbreviation below is available.
-    #  write_call(...) => CALL(...)
+    #  write_funcall(...) => FUNCALL(...)
     #
     # === PARAMETER
     # _loc_:: Location -- Location where the function call appears.
     # _caller_fun_:: FunctionId -- Calling function identifier.
     # _callee_fun_:: FunctionId -- Called function identifier.
-    def write_call(loc, caller_fun, callee_fun)
-      write_code_struct(Call.new(loc, caller_fun, callee_fun))
+    def write_funcall(loc, caller_fun, callee_fun)
+      write_code_struct(Funcall.new(loc, caller_fun, callee_fun))
     end
-    alias :CALL :write_call
+    alias :FUNCALL :write_funcall
 
     # === DESCRIPTION
     # Writes a variable cross reference information on the report.
@@ -444,7 +443,7 @@ module AdLint #:nodoc:
     # === RETURN VALUE
     # None.
     def write_xref_function(loc, referrer, ref_type, fun)
-      write_code_struct(XRefFunc.new(loc, referrer, ref_type, fun))
+      write_code_struct(XRefFun.new(loc, referrer, ref_type, fun))
     end
     alias :XREF_FUNC :write_xref_function
 

data/lib/adlint/util.rb

@@ -517,7 +517,7 @@ if $0 == __FILE__
       p "foo"
     end
 
-    extend ::AdLint::Pluggable
+    extend AdLint::Pluggable
 
     def_plugin :on_initialization
 

data/lib/adlint/version.rb

@@ -33,8 +33,8 @@ module AdLint #:nodoc:
 
   MAJOR_VERSION = 3
   MINOR_VERSION = 0
-  PATCH_VERSION = 4
-  RELEASE_DATE  = "2013-04-12"
+  PATCH_VERSION = 8
+  RELEASE_DATE  = "2013-05-31"
 
   TRAITS_SCHEMA_VERSION = "3.0.0"
 

data/share/doc/Makefile

@@ -1,6 +1,7 @@
 MAKEINFO = makeinfo
+DOT = dot
 
-.SUFFIXES : .texi .html .txt
+.SUFFIXES : .texi .html .txt .dot .pdf
 
 .texi.html :
 	$(MAKEINFO) --html --no-split --css-include=texinfo.css -o $@ $<
@@ -8,7 +9,10 @@ MAKEINFO = makeinfo
 .texi.txt :
 	$(MAKEINFO) --plaintext -o $@ $<
 
-TARGET = users_guide_ja.html users_guide_en.html developers_guide_ja.html
+.dot.pdf :
+	$(DOT) -Tpdf -o $@ $<
+
+TARGET = users_guide_ja.html users_guide_en.html developers_guide_ja.html c99gram.pdf
 
 all : $(TARGET)