cxxproject 0.6.30 → 0.6.31

data/README.md

@@ -3,6 +3,20 @@
 
 see documentation page: [cxxproject](http://marcmo.github.com/cxxproject)
 
+# teststrategy for plugins
+
+each plugin should have unit-tests and acceptance-tests.
+
+rake-task: spec
+unit-tests should be able to run from source without preinstalled gems (apart from rspec).
+
+rake-task: prepare_accept
+should prepare the current gemset with all gems needed. usually this should build cxxproject, cxx and a toolchain and install those gems.
+
+rake-task: accept
+this should run with the gems that are installed by prepare_accept. this can be a whole build.
+
+
 ## Change History:
 
 0.6.28 => 0.6.29

data/lib/cxxproject.rb

@@ -18,9 +18,9 @@ require 'cxxproject/buildingblocks/building_blocks'
 require 'frazzle/frazzle'
 registry = Frazzle::Registry.new('cxxproject', '_', '')
 
-toolchain_plugins = registry.get_plugins('toolchain')
-toolchain_plugins.each do |toolchain_plugin|
-  registry.load_plugin(toolchain_plugin, Cxxproject::PluginContext.new(nil, nil, nil))
+plugins = registry.get_all_plugins
+plugins.each do |plugin|
+  registry.load_plugin(plugin, Cxxproject::PluginContext.create_no_args_context())
 end
 
 include Cxxproject::Toolchain

data/lib/cxxproject/buildingblocks/building_block.rb

@@ -4,6 +4,7 @@ require 'cxxproject/ext/rake'
 require 'cxxproject/ext/file'
 require 'cxxproject/ide_interface'
 require 'cxxproject/utils/printer'
+require 'rake/clean'
 
 # no deprecated warning for rake >= 0.9.x
 include Rake::DSL if defined?(Rake::DSL)
@@ -12,6 +13,32 @@ module Cxxproject
   # stores all defined buildingblocks by name (the name should be unique)
   ALL_BUILDING_BLOCKS = {}
 
+  def self.sorted_building_blocks
+    todo = ALL_BUILDING_BLOCKS.keys.dup
+    res = []
+    while not todo.empty?
+      bb = resolve_by_name(todo.pop)
+      add_unique(res, bb)
+      todo += bb.dependencies
+    end
+    return res.reverse
+  end
+
+  def self.resolve_by_name(name)
+    res = ALL_BUILDING_BLOCKS[name]
+    raise "BuildingBlock #{name} not defined" unless res
+    res
+  end
+
+  def self.add_unique(res, bb)
+    res.delete(bb)
+    res.push(bb)
+  end
+
+  def self.find_by_tag(tag)
+    ALL_BUILDING_BLOCKS.values.find_all{|o|o.tags.include?(tag)}
+  end
+
   trap("INT") do
     Rake.application.idei.set_abort(true)
   end
@@ -27,6 +54,7 @@ module Cxxproject
     attr_accessor :output_dir
     attr_accessor :pre_step
     attr_reader :output_dir_abs
+    attr_accessor :tags
 
     def set_name(x)
       @name = x
@@ -164,10 +192,10 @@ module Cxxproject
 
     def printCmd(cmd, alternate, showPath)
       @lastCommand = cmd
-      if showPath or RakeFileUtils.verbose or (alternate.nil? and not Rake::application.options.silent)
+      if showPath or (RakeFileUtils.verbose == true) or (alternate.nil? and not Rake::application.options.silent)
         @printedCmdAlternate = false
         exedIn = ""
-        exedIn = " (executed in '#{@project_dir}')" if (showPath or RakeFileUtils.verbose)
+        exedIn = " (executed in '#{@project_dir}')" if (showPath or (RakeFileUtils.verbose == true))
         puts "" if Rake::application.addEmptyLine
         if cmd.is_a?(Array)
           puts cmd.join(' ') + exedIn
@@ -214,12 +242,11 @@ module Cxxproject
       end
     end
 
-    def typed_file_task(type, *args, &block)
-      t = file *args do
+    def typed_file_task(type, hash, &block)
+      t = file hash do
         block.call
       end
       t.type = type
-      t.progress_count = 1
       return t
     end
 
@@ -249,6 +276,9 @@ module Cxxproject
       end
     end
 
-  end
+    def additional_path_components
+      []
+    end
+  end # class BuildingBlock
 
 end

data/lib/cxxproject/buildingblocks/building_blocks.rb

@@ -1,19 +1,10 @@
-require 'cxxproject/buildingblocks/binary_library'
 require 'cxxproject/buildingblocks/building_block'
-require 'cxxproject/buildingblocks/executable'
-require 'cxxproject/buildingblocks/source_library'
 require 'cxxproject/buildingblocks/module'
+require 'cxxproject/buildingblocks/makefile'
+require 'cxxproject/buildingblocks/linkable'
+require 'cxxproject/buildingblocks/static_library'
+require 'cxxproject/buildingblocks/single_source'
+require 'cxxproject/buildingblocks/binary_library'
 require 'cxxproject/buildingblocks/custom_building_block'
-=begin
-  -rw-rw-r-- 2 ckoestlin ckoestlin  2027 Jul 10 15:12 command_line.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin   688 Jul 10 15:12 custom_building_block.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin  7241 Jul 18 11:51 executable.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin  2047 Jul 10 15:12 has_dependencies_mixin.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin   297 Jul 10 15:12 has_includes_mixin.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin   792 Jul 10 15:12 has_libraries_mixin.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin 10084 Jul 18 12:24 has_sources_mixin.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin  4034 Jul 10 15:12 makefile.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin   775 Jul 10 15:12 module.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin   811 Jul 10 15:12 single_source.rb
-  -rw-rw-r-- 2 ckoestlin ckoestlin  3582 Jul 18 12:23 source_library.rb
-=end
+require 'cxxproject/buildingblocks/command_line'
+

data/lib/cxxproject/buildingblocks/command_line.rb

@@ -47,7 +47,7 @@ module Cxxproject
         Dir.chdir(@project_dir) do
           check_config_file
           cmd = get_command_line
-          puts cmd + (RakeFileUtils.verbose ? " (executed in '#{@project_dir}')" : "")
+          puts cmd + ((RakeFileUtils.verbose == true) ? " (executed in '#{@project_dir}')" : "")
           cmd_result = false
           begin
             cmd_result = ProcessHelper.spawnProcess(cmd + " 2>&1")
@@ -62,7 +62,7 @@ module Cxxproject
               err_res.message = "Command \"#{get_command_line}\" failed"
               Rake.application.idei.set_errors([err_res])
             end
-            Printer.printError "Error: command \"#{get_command_line}\" failed" + (RakeFileUtils.verbose ? "" : " (executed in '#{@project_dir}')")
+            Printer.printError "Error: command \"#{get_command_line}\" failed" + ((RakeFileUtils.verbose == true) ? "" : " (executed in '#{@project_dir}')")
             raise SystemCommandFailed.new
           end
         end

data/lib/cxxproject/buildingblocks/has_sources_mixin.rb

@@ -85,7 +85,7 @@ module Cxxproject
           if BinaryLibrary === d
             @incArray.concat(d.includes)
           else
-            prefix = File.rel_from_to_project(@project_dir,d.project_dir)
+            prefix = File.rel_from_to_project(@project_dir, d.project_dir)
             next if not prefix
             @incArray.concat(d.includes.map {|inc| File.add_prefix(prefix,inc)})
           end
@@ -189,7 +189,8 @@ module Cxxproject
       end
     end
 
-    def create_object_file_tasks()
+    # returns a hash from all sources to the toolchain that should be used for a source
+    def collect_sources_and_toolchains
       sources_to_build = {}
 
       exclude_files = Set.new
@@ -217,26 +218,33 @@ module Cxxproject
         end
         add_to_sources_to_build(sources_to_build, exclude_files, globRes, tcs4source(p))
       end
+      return sources_to_build
+    end
 
-      ordered = sources_to_build.keys.sort()
-
-      no_sources_found() if sources_to_build.empty?
-
-      dirs = []
+    # calcs a map from unique directories to array of sources within this dir
+    def calc_dirs_with_files(sources)
       filemap = {}
-      ordered.reverse.each do |o|
+      sources.keys.sort.reverse.each do |o|
         d = File.dirname(o)
         if filemap.include?(d)
           filemap[d] << o
         else
           filemap[d] = [o]
-          dirs << d
         end
       end
+      return filemap
+    end
+
+    def create_object_file_tasks()
+      sources_to_build = collect_sources_and_toolchains()
+      no_sources_found() if sources_to_build.empty?
+
+      dirs_with_files = calc_dirs_with_files(sources_to_build)
 
       obj_tasks = []
-      dirs.each do |d|
-        filemap[d].reverse.each do |f|
+      @objects = []
+      dirs_with_files.each do |dir, files|
+        files.reverse.each do |f|
           obj_task = create_object_file_task(f, sources_to_build[f])
           obj_tasks << obj_task unless obj_task.nil?
         end
@@ -244,73 +252,83 @@ module Cxxproject
       obj_tasks
     end
 
-    def create_object_file_task(sourceRel, the_tcs)
-      if !File.exists?(sourceRel)
-        raise "File '#{sourceRel}' not found"
+    def calc_command_line_for_source(source, toolchain)
+      if !File.exists?(source)
+        raise "File '#{source}' not found"
       end
-
-      if File.is_absolute?(sourceRel)
-        sourceRel = File.rel_from_to_project(@project_dir, sourceRel, false)
+      if File.is_absolute?(source)
+        source = File.rel_from_to_project(@project_dir, source, false)
       end
 
-      type = get_source_type(sourceRel)
-      raise "Unknown filetype for #{sourceRel}" unless type
+      type = get_source_type(source)
+      raise "Unknown filetype for #{source}" unless type
+
+      object = get_object_file(source)
+      object_path = File.expand_path(object)
+      source_path = File.expand_path(source)
 
-      objectRel = get_object_file(sourceRel)
-      @objects << objectRel
-      object = File.expand_path(objectRel)
-      source = File.expand_path(sourceRel)
+      @objects << object
 
       depStr = ""
       dep_file = nil
       if type != :ASM
-        dep_file = get_dep_file(objectRel)
+        dep_file = get_dep_file(object)
         dep_file = "\""+dep_file+"\"" if dep_file.include?(" ")
-        depStr = the_tcs[:COMPILER][type][:DEP_FLAGS]
+        depStr = toolchain[:COMPILER][type][:DEP_FLAGS]
       end
 
-      res = typed_file_task Rake::Task::OBJECT, object => source do
-        compiler = the_tcs[:COMPILER][type]
+      compiler = toolchain[:COMPILER][type]
+      i_array = toolchain == @tcs ? @include_string[type] : get_include_string(toolchain, type)
+      d_array = toolchain == @tcs ? @define_string[type] : get_define_string(toolchain, type)
 
-        if Rake::application.preproFlags and compiler[:PREPRO_FLAGS] == ""
-          Printer.printInfo("Info: No preprocessor option available for " + sourceRel)
+      cmd = [compiler[:COMMAND]].flatten
+      cmd += compiler[:COMPILE_FLAGS].split(" ")
+      if dep_file
+        cmd += depStr.split(" ")
+        if toolchain[:COMPILER][type][:DEP_FLAGS_SPACE]
+          cmd << dep_file
         else
+          cmd[cmd.length-1] << dep_file
+        end
+      end
+      cmd += compiler[:FLAGS]
+      cmd += additional_object_file_flags
+      cmd += i_array
+      cmd += d_array
+      cmd += (compiler[:OBJECT_FILE_FLAG] + object).split(" ")
+      cmd += compiler[:PREPRO_FLAGS].split(" ") if Rake::application.preproFlags
+      cmd << source
+      return [cmd, source_path, object, object_path, compiler, type]
+    end
 
-          i_array = the_tcs == @tcs ? @include_string[type] : get_include_string(the_tcs, type)
-          d_array = the_tcs == @tcs ? @define_string[type] : get_define_string(the_tcs, type)
+    def additional_object_file_flags
+      []
+    end
 
-          cmd = [compiler[:COMMAND]]
-          cmd += compiler[:COMPILE_FLAGS].split(" ")
-          if dep_file
-            cmd += depStr.split(" ")
-            if the_tcs[:COMPILER][type][:DEP_FLAGS_SPACE]
-              cmd << dep_file
-            else
-              cmd[cmd.length-1] << dep_file
-            end
-          end
-          cmd += compiler[:FLAGS]
-          cmd += i_array
-          cmd += d_array
-          cmd += (compiler[:OBJECT_FILE_FLAG] + objectRel).split(" ")
-          cmd += compiler[:PREPRO_FLAGS].split(" ") if Rake::application.preproFlags
-          cmd << sourceRel
-
-          rd, wr = IO.pipe
-          cmd << {
-            :err=>wr,
-            :out=>wr
-          }
-          sp = spawn(*cmd)
-          cmd.pop
-          consoleOutput = ProcessHelper.readOutput(sp, rd, wr)
-
-          process_result(cmd, consoleOutput, compiler[:ERROR_PARSER], "Compiling #{sourceRel}")
-
-          convert_depfile(dep_file) if dep_file
-
-          check_config_file()
-        end
+    def create_object_file_task(sourceRel, the_tcs)
+      cmd, source, object, object_path, compiler, type = calc_command_line_for_source(sourceRel, the_tcs)
+      depStr = ""
+      dep_file = nil
+      if type != :ASM
+        dep_file = get_dep_file(object)
+        dep_file = "\""+dep_file+"\"" if dep_file.include?(" ")
+        depStr = compiler[:DEP_FLAGS]
+      end
+      res = typed_file_task Rake::Task::OBJECT, object_path=> source do
+        rd, wr = IO.pipe
+        cmd << {
+          :err=>wr,
+          :out=>wr
+        }
+        sp = spawn(*cmd)
+        cmd.pop
+        consoleOutput = ProcessHelper.readOutput(sp, rd, wr)
+
+        process_result(cmd, consoleOutput, compiler[:ERROR_PARSER], "Compiling #{sourceRel}")
+
+        convert_depfile(dep_file) if dep_file
+
+        check_config_file()
       end
       enhance_with_additional_files(res)
       add_output_dir_dependency(object, res, false)

data/lib/cxxproject/buildingblocks/linkable.rb

@@ -0,0 +1,395 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/buildingblocks/has_sources_mixin'
+require 'cxxproject/buildingblocks/has_includes_mixin'
+require 'cxxproject/utils/process'
+require 'cxxproject/utils/utils'
+require 'cxxproject/ext/stdout'
+
+require 'tmpdir'
+require 'set'
+require 'etc'
+
+module Cxxproject
+
+  class Linkable < BuildingBlock
+    include HasLibraries
+    include HasSources
+    include HasIncludes
+
+    def set_linker_script(x)
+      @linker_script = x
+      self
+    end
+
+    def set_mapfile(x)
+      @mapfile = x
+      self
+    end
+
+    def initialize(name)
+      super(name)
+      @linker_script = nil
+      @mapfile = nil
+    end
+
+    def set_executable_name(name) # ensure it's relative
+      @exe_name = name
+    end
+
+    def get_output_name(linker)
+      prefix = get_output_prefix(linker)
+      suffix = get_output_suffix(linker)
+      return "#{prefix}#{name}#{suffix}"
+    end
+    def executable_name() # relative path OK
+      return @exe_name if @exe_name
+
+      parts = [@output_dir]
+
+      if @output_dir_abs
+        parts = [@output_dir_relPath] if @output_dir_relPath
+        parts += additional_path_components()
+      end
+      linker = @tcs[:LINKER]
+      parts << get_output_name(linker)
+
+      @exe_name = File.join(parts)
+      @exe_name
+    end
+
+    def get_task_name() # full path
+      @project_dir + "/" + executable_name # OK
+    end
+
+    def collect_unique(array, set)
+      ret = []
+      array.each do |v|
+        if set.add?(v)
+          ret << v
+        end
+      end
+      ret
+    end
+
+    def adapt_path(v, d, prefix)
+      tmp = nil
+      if File.is_absolute?(v)
+        tmp = v
+      else
+        prefix ||= File.rel_from_to_project(@project_dir, d.project_dir)
+        tmp = File.add_prefix(prefix, v)
+      end
+      [tmp, prefix]
+    end
+
+    def deps # OK
+      if @deps == nil
+        @deps = collect_dependencies
+      end
+      @deps
+    end
+
+    def cmd_lib_string(target_os)
+      libraries=''
+      deps.each do |d|
+        if HasLibraries === d
+          d.lib_elements.each do |elem|
+            case elem[0]
+            when HasLibraries::SEARCH_PATH
+              tmp, prefix = adapt_path(elem[1], d, prefix)
+              libraries << tmp
+              libraries << File::PATH_SEPARATOR
+            end
+          end
+        end
+      end
+      libraries
+    end
+
+    def linker_lib_string(target_os, linker)
+      lib_path_set = Set.new
+      res = []
+      deps.each do |d|
+        handle_whole_archive(d, res, linker, linker[:START_OF_WHOLE_ARCHIVE][target_os])
+        if HasLibraries === d and d != self #OK
+          d.lib_elements.each do |elem|
+            case elem[0]
+            when HasLibraries::LIB
+              if not is_whole_archive(d)
+                res.push("#{linker[:LIB_FLAG]}#{elem[1]}")
+              end
+            when HasLibraries::USERLIB
+              res.push("#{linker[:USER_LIB_FLAG]}#{elem[1]}")
+            when HasLibraries::LIB_WITH_PATH
+              if is_whole_archive(d)
+                res.push(d.get_archive_name)
+              else
+                tmp, prefix = adapt_path(elem[1], d, prefix)
+                res.push(tmp)
+              end
+            when HasLibraries::SEARCH_PATH
+              if is_whole_archive(d)
+                res.push(d.get_archive_name)
+              else
+                tmp, prefix = adapt_path(elem[1], d, prefix)
+                if not lib_path_set.include?(tmp)
+                  lib_path_set << tmp
+                  res.push("#{linker[:LIB_PATH_FLAG]}#{tmp}")
+                end
+              end
+            end
+          end
+        end
+        handle_whole_archive(d, res, linker, linker[:END_OF_WHOLE_ARCHIVE][target_os])
+      end
+      res
+    end
+
+    # res the array with command line arguments that is used as result
+    # linker the linker hash
+    # sym the symbol that is used to fish out a value from the linker
+    def handle_whole_archive(building_block, res, linker, flag)
+      if is_whole_archive(building_block)
+        res.push(flag) if flag and !flag.empty?
+      end
+    end
+
+    def is_whole_archive(building_block)
+      return building_block.instance_of?(StaticLibrary) && building_block.whole_archive
+    end
+
+    def calc_command_line
+      linker = @tcs[:LINKER]
+      cmd = [linker[:COMMAND]] # g++
+      cmd += linker[:MUST_FLAGS].split(" ")
+      cmd += linker[:FLAGS]
+      cmd += get_flags_for_output(linker)
+      cmd << executable_name() # debug/x.exe # OK
+      cmd += @objects
+      cmd << linker[:SCRIPT] if @linker_script # -T
+      cmd << @linker_script if @linker_script # xy/xy.dld
+      cmd << linker[:MAP_FILE_FLAG] if @mapfile # -Wl,-m6
+      cmd += linker[:LIB_PREFIX_FLAGS].split(" ") # TODO ... is this still needed e.g. for diab
+      cmd += linker_lib_string(target_os(), @tcs[:LINKER])
+      cmd += linker[:LIB_POSTFIX_FLAGS].split(" ") # TODO ... is this still needed e.g. for diab
+      cmd
+    end
+
+    # create a task that will link an executable from a set of object files
+    #
+    def convert_to_rake()
+      object_multitask = prepare_tasks_for_objects()
+
+      res = typed_file_task get_rake_task_type(), get_task_name => object_multitask do
+        cmd = calc_command_line
+        Dir.chdir(@project_dir) do
+          mapfileStr = @mapfile ? " >#{@mapfile}" : ""
+          rd, wr = IO.pipe
+          cmdLinePrint = cmd
+          printCmd(cmdLinePrint, "Linking #{executable_name}", false) #OK
+          cmd << {
+            :out=> @mapfile ? "#{@mapfile}" : wr, # > xy.map
+            :err=>wr
+          }
+          sp = spawn(*cmd)
+          cmd.pop
+          # for console print
+          cmd << " >#{@mapfile}" if @mapfile
+          consoleOutput = ProcessHelper.readOutput(sp, rd, wr)
+
+          process_result(cmdLinePrint, consoleOutput, @tcs[:LINKER][:ERROR_PARSER], nil)
+          check_config_file()
+          post_link_hook(@tcs[:LINKER])
+        end
+      end
+      res.tags = tags
+      res.immediate_output = true
+      res.enhance(@config_files)
+      res.enhance([@project_dir + "/" + @linker_script]) if @linker_script
+
+      add_output_dir_dependency(get_task_name, res, true)
+      add_grouping_tasks(get_task_name)
+      setup_rake_dependencies(res, object_multitask)
+
+      # check that all source libs are checked even if they are not a real rake dependency (can happen if "build this project only")
+      begin
+        libChecker = task get_task_name+"LibChecker" do
+          if File.exists?(get_task_name) # otherwise the task will be executed anyway
+            all_dependencies.each do |bb|
+              if bb and StaticLibrary === bb
+                f = bb.get_task_name # = abs path of library
+                if not File.exists?(f) or File.mtime(f) > File.mtime(get_task_name)
+                  def res.needed?
+                    true
+                  end
+                  break
+                end
+              end
+            end
+          end
+        end
+      rescue
+        def res.needed?
+          true
+        end
+      end
+      libChecker.transparent_timestamp = true
+      res.enhance([libChecker])
+
+      return res
+    end
+
+    def create_run_task(executable, name)
+      namespace 'run' do
+        desc "run executable #{executable}"
+        res = task name => executable do |t|
+          lib_var = @tcs[:ENV][:LIB_VAR][@tcs[:TARGET_OS]]
+          if lib_var != ''
+            ENV[lib_var] = cmd_lib_string(@tcs[:TARGET_OS])
+          end
+          sh ["\"#{executable}\"", ENV['args']].compact.join(' ')
+        end
+        res.type = Rake::Task::RUN
+        res
+      end
+    end
+
+    def get_temp_filename
+      Dir.tmpdir + "/lake.tmp"
+    end
+
+    def no_sources_found()
+    end
+
+    def target_os
+      @tcs[:TARGET_OS]
+    end
+  end
+
+  class Executable < Linkable
+    def get_flags_for_output(linker)
+      [linker[:OUTPUT_FLAG]]
+    end
+    def get_output_prefix(linker)
+      ""
+    end
+    def get_output_suffix(linker)
+      linker[:OUTPUT_SUFFIX][:EXECUTABLE][target_os()]
+    end
+    def get_rake_task_type
+      Rake::Task::EXECUTABLE
+    end
+    def additional_object_file_flags
+      []
+    end
+    def add_grouping_tasks(executable)
+      namespace 'exe' do
+        desc executable
+        task @name => executable
+      end
+      create_run_task(executable, @name)
+    end
+
+    def post_link_hook(linker)
+    end
+  end
+
+  class SharedLibrary < Linkable
+    attr_accessor :major
+    attr_accessor :minor
+    attr_accessor :compatibility
+
+    def complete_init()
+      if @output_dir_abs
+        add_lib_element(HasLibraries::LIB, @name, true)
+        add_lib_element(HasLibraries::SEARCH_PATH, File.join(@output_dir, 'libs'), true)
+      else
+        add_lib_element(HasLibraries::LIB_WITH_PATH, File.join(@output_dir,"lib#{@name}.a"), true)
+      end
+      super
+    end
+
+    def get_flags_for_output(linker)
+      [linker[:SHARED_FLAG]] + additional_linker_commands(linker) + [linker[:OUTPUT_FLAG]]
+    end
+
+    def get_output_prefix(linker)
+      linker[:OUTPUT_PREFIX][:SHARED_LIBRARY][target_os()]
+    end
+
+    def get_output_suffix(linker)
+      h = linker[:ADDITIONAL_COMMANDS][target_os()]
+      "#{(h ? h.get_version_suffix(linker, self) : "")}#{shared_suffix linker}"
+    end
+
+    def additional_path_components()
+      ['libs']
+    end
+
+    def get_rake_task_type
+      Rake::Task::SHARED_LIBRARY
+    end
+
+    def additional_object_file_flags
+      linker = @tcs[:LINKER]
+      linker[:ADDITIONAL_OBJECT_FILE_FLAGS][target_os()]
+    end
+
+    def add_grouping_tasks(shared_lib)
+      namespace 'shared' do
+        desc shared_lib
+        task @name => shared_lib
+      end
+    end
+
+    def shared_suffix(linker)
+      linker[:OUTPUT_SUFFIX][:SHARED_LIBRARY][target_os()]
+    end
+
+    private
+
+    # Some symbolic links
+    # ln -s libfoo.so libfoo.1.2.so
+    # ln -s libfoo.1.so libfoo.1.2.so
+    def post_link_hook(linker)
+      basic_name = get_basic_name(linker)
+      soname = get_soname(linker)
+      symlink_lib_to basic_name
+      symlink_lib_to soname
+    end
+
+    def symlink_lib_to(link)
+      file = File.basename(executable_name)
+      if file !=link
+        cd "#{@output_dir}/libs" do
+          symlink(file, link)
+        end
+      end
+    end
+
+    def major_suffix()
+      "#{major ? "." + major : ''}"
+    end
+
+    def major_minor_suffix()
+      "#{major_suffix}#{(major and minor ? '.' : '')}#{(minor ? minor : '')}"
+    end
+
+    def post_link_hook(linker)
+      linker = @tcs[:LINKER]
+      os_linker_helper=linker[:ADDITIONAL_COMMANDS][target_os()]
+      os_linker_helper.post_link_hook(linker, self)
+    end
+    private
+
+    def additional_linker_commands(linker)
+      h = linker[:ADDITIONAL_COMMANDS][target_os()]
+      if h
+        h.calc(linker, self)
+      else
+        []
+      end
+    end
+  end
+end