Mxx_ru 1.1.0

data/lib/mxx_ru/cpp/toolset.rb

@@ -0,0 +1,1029 @@
+#--
+# Copyright (c) 1996-2004, Yauheni Akhotnikau
+# Copyright (c) 2004-2006, JSC Intervale
+# Copyright (c) 2006, The Mxx_ru Project
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'mxx_ru/ex'
+require 'mxx_ru/util'
+
+module  Mxx_ru
+  module  Cpp
+
+    # Class, describing object file.
+    class Obj_info
+      # The name of object file.
+      attr_reader :name
+      # The name of source file.
+      attr_reader :source
+      # The list of additional compiler options for that file.
+      # Array of String.
+      attr_reader :options
+
+      def initialize( a_name, a_source, a_options )
+        @name = a_name
+        @source = a_source
+        @options = a_options
+      end
+    end # class Obj_info
+
+    # Base class for any target for which full path must be calculated.
+    class Target_with_full_path
+      def initialize( name, path )
+        @target_path = path
+        @target_name = name
+      end
+
+      def full_name
+        @full_name = File.join( @target_path, @target_name ) unless @full_name
+        @full_name
+      end
+    end
+
+    # Class, describing mswin-res-����.
+    class Mswin_res_info < Target_with_full_path
+      attr_reader :file_name
+      attr_reader :path
+
+      def initialize( a_file_name, a_path )
+        super( a_file_name, a_path )
+
+        # File name of mswin-res-file without a folder.
+        @file_name = a_file_name
+        # Folder where mswin-res-file should be.
+        @path = a_path
+      end
+    end # class Mswin_res_info
+
+    # Class, describing a library.
+    class Lib_info < Target_with_full_path
+      attr_reader :file_name
+      attr_reader :path
+      attr_reader :link_name
+
+      def initialize( a_file_name, a_path, a_link_name )
+        super( a_file_name, a_path )
+
+        # File name of library file without a folder.
+        @file_name = a_file_name
+        # Folder where library file should be.
+        @path = a_path
+        # The name should be passed to the linker.
+        @link_name = a_link_name
+      end
+    end # class Lib_info
+
+    # Class, describing EXE-file.
+    class Exe_info < Target_with_full_path
+      attr_reader :file_name
+      attr_reader :path
+
+      def initialize( a_file_name, a_path )
+        super( a_file_name, a_path )
+
+        # File name of exe file without a folder.
+        @file_name = a_file_name
+        # Folder where exe file should be.
+        @path = a_path
+      end
+    end # class Exe_info
+
+    # Class, describing a shared library.
+    class Dll_info < Target_with_full_path
+      # File name of dll file without a folder.
+      attr_reader :dll_file_name
+      # Folder where dll file should be.
+      attr_reader :dll_path
+      # The name should be passed to the linker. (import library name)
+      # It may be nil if inport library isn't used.
+      attr_reader :link_name
+      # The folder name, where linker should look for import library.
+      # It may be nil if inport library isn't used.
+      attr_reader :link_path
+
+      def initialize(
+          a_dll_file_name,
+          a_dll_path,
+          a_link_name,
+          a_link_path )
+
+        super( a_dll_file_name, a_dll_path )
+
+        @dll_file_name = a_dll_file_name
+        @dll_path = a_dll_path
+        @link_name = a_link_name
+        @link_path = a_link_path
+      end
+    end # class Dll_info
+
+
+    # Class, incapsulating all lists required for linker.
+    class Linker_lists
+      # Object files.
+      attr_reader :objs
+      # Compiled resources.
+      attr_reader :resources
+      # Libraries required.
+      attr_reader :libs
+      # Search paths for libraries.
+      attr_reader :lib_paths
+      # Linker options.
+      attr_reader :linker_options
+
+      def initialize
+        @objs = Array.new
+        @resources = Array.new
+        @libs = Array.new
+        @lib_paths = Array.new
+        @linker_options = Array.new
+      end
+
+      def add_objs( a_objs )
+        push_to( @objs, a_objs )
+      end
+
+      def add_resources( a_resources )
+        push_to( @resources, a_resources )
+      end
+
+      def add_libs( a_libs )
+        push_to( @libs, a_libs )
+      end
+
+      def add_lib_paths( a_lib_paths )
+        push_to( @lib_paths, a_lib_paths )
+      end
+
+      def add_linker_options( a_linker_options )
+        push_to( @linker_options, a_linker_options )
+      end
+
+    protected
+      def push_to( to, what )
+        to << what
+        to.flatten!
+        to.uniq!
+      end
+    end # class Linker_lists
+
+    # Class, incapsulating DLL dependencies.
+    #
+    # When someone is linking to the DLL on mswin platform, then it
+    # depends only from import library of that DLL.
+    # But when someone is linking to the DLL on unix platform, then it
+    # depends from all libraries DLL depends to.
+    # Exact details knows concrete toolset implementation only.
+    # Therefore, after DLL building base toolset class addresses to it's
+    # derivative with requirement to build all dependencies lists.
+    # These lists are returned as an object of Dll_requirements type.
+    class Dll_requirements
+      # Required libraries list.
+      attr_reader :libs
+      # Libraries search paths.
+      attr_reader :lib_paths
+
+      def initialize
+        @libs = Array.new
+        @lib_paths = Array.new
+      end
+
+      def add_libs( a_libs )
+        push_to( @libs, a_libs )
+      end
+
+      def add_lib_paths( a_lib_paths )
+        push_to( @lib_paths, a_lib_paths )
+      end
+
+    protected
+      def push_to( to, what )
+        to << what
+        to.flatten!
+      end # Dll_requirements
+    end
+
+    # Base toolset class.
+    # Toolset is a compiler and tool set for compiling an application.
+    class Toolset
+
+      # Exception, thrown in case of unknown toolset tag value.
+      class Unknown_tag_ex < Mxx_ru::Ex
+        def initialize( a_tag_name )
+          super( "Unknown or missing toolset tag: '#{a_tag_name}" )
+        end
+      end
+
+    private
+      # Toolset name.
+      @name = nil
+      # Tag map. Key and value are the String objects.
+      @tags = nil
+
+    public
+      # Constructor.
+      #
+      # [_a_name_] Toolset name.
+      def initialize( a_name )
+        @name = a_name
+        @tags = Hash.new
+      end
+
+      # Set tag value.
+      # Previous value is changed to the new one.
+      #
+      # [_a_name_] Tag name.
+      # [_a_value_] Value. Should be a string.
+      def setup_tag( a_name, a_value )
+        @tags[ a_name ] = a_value
+      end
+
+      # Get tag value.
+      # If tag wasn't found in a tag map, a_default value is returned.
+      # If a_default == nil, then exception is thrown in a case of missing tag.
+      def tag( a_name, a_default = nil )
+        if !@tags.key?( a_name )
+          if nil == a_default
+            raise Unknown_tag_ex.new( a_name )
+          end
+
+          return a_default
+        end
+        return @tags[ a_name ]
+      end
+
+      # Set all compiler, linker, archiver, etc options required,
+      # taking all current modes, such as runtime_mode, rtl_mode,
+      # rtti_mode, threading_mode etc into account.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      #
+      # Throws Abstract_method_ex exception in a base class.
+      #
+      def setup_mandatory_options( target )
+        raise Abstract_method_ex.new( "Mxx_ru::Cpp::Toolset::setup_mandatory_options" )
+      end
+
+      # Perform C++ files compilation.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def make_objs( target )
+        # Creating all object file names.
+        c_objs = make_obj_names( target.mxx_c_files, target )
+        cpp_objs = make_obj_names( target.mxx_cpp_files, target )
+
+        # Defining object files, which is necessary to build or rebuild.
+        c_objs_to_build = detect_objs_to_rebuild( c_objs )
+        cpp_objs_to_build = detect_objs_to_rebuild( cpp_objs )
+
+        # Performing a compilation, if it's required.
+        if c_objs_to_build.size
+          build_objs( c_objs_to_build, target,
+            target.mxx_all_c_compiler_options,
+            :make_c_obj_command_lines )
+        end
+        if cpp_objs_to_build.size
+          build_objs( cpp_objs_to_build, target,
+            target.mxx_all_cpp_compiler_options,
+            :make_cpp_obj_command_lines )
+        end
+
+        # It's required to store all object file names back to the target,
+        # because they are required for linking.
+        c_objs.each { |o| target.obj_file( o.name ) }
+        cpp_objs.each { |o| target.obj_file( o.name ) }
+
+        # Also informing if some object files were rebuilt.
+        state = Target_state::EXISTS
+        state = Target_state::REBUILT if ( c_objs_to_build.size() ||
+          cpp_objs_to_build.size() )
+
+        return Target_state.new( state )
+      end
+
+      # Remove object files.
+      def clean_objs( target )
+        # Creating all object file names.
+        c_objs = make_obj_names( target.mxx_c_files, target )
+        cpp_objs = make_obj_names( target.mxx_cpp_files, target )
+
+        c_objs.each { |o| Mxx_ru::Util::delete_file( o.name ) }
+        cpp_objs.each { |o| Mxx_ru::Util::delete_file( o.name ) }
+      end
+
+      # Perform resource files compilation.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def make_mswin_res( target )
+        # Creating the name of res file and storing it in the target.
+        res_info = make_mswin_res_name(
+          target.mxx_mswin_rc_file.name, target )
+
+        full_name = res_info.full_name
+
+        target.mswin_res_file( full_name )
+
+        # Determining it's status.
+        state = Target_state::detect( full_name,
+          [ target.mxx_mswin_rc_file.name ] +
+          target.mxx_mswin_rc_file.depends )
+        if state.state != Target_state::EXISTS
+          cmd_lines = make_mswin_res_command_lines(
+            full_name, target.mxx_mswin_rc_file.name,
+            target.mxx_all_mswin_rc_options, target )
+
+          Mxx_ru::Abstract_target::run( cmd_lines, [ full_name ] )
+
+          state = Mxx_ru::Target_state.new( Mxx_ru::Target_state::REBUILT )
+        end
+
+        return state
+      end
+
+      # Remove resource files compilation results.
+      def clean_mswin_res( target )
+        # Creating the name of res file.
+        res_info = make_mswin_res_name(
+          target.mxx_mswin_rc_file.name, target )
+
+        full_name = res_info.full_name
+
+        Mxx_ru::Util::delete_file( full_name )
+
+        clean_mswin_res_specific_files( full_name, res_info, target )
+      end
+
+      # Perform cleanup of files specific for mswin-res.
+      # Does nothing in a base class.
+      #
+      # [_a_res_file_]  Full name of mswin-res-file.
+      # [_a_res_info_]  Formatted information for res-file.
+      # [_a_target_]  Target, for which mswin-res-file is defined.
+      def clean_mswin_res_specific_files(
+        a_res_file,
+        a_res_info,
+        a_target )
+      end
+
+      # Perform static library build.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def make_lib( target )
+        # Creating result file name. Also determining in which folder
+        # lib should be. The name of that folder should be included in
+        # libraries search paths of given target.
+        lib_info = make_lib_name( target.mxx_target_name, target )
+
+        # Determining target status.
+        lib_file = lib_info.full_name
+
+        lib_state = Mxx_ru::Target_state::detect(
+          lib_file, target.mxx_obj_files )
+        if Mxx_ru::Target_state::EXISTS != lib_state.state
+          # File should be rebuilt.
+          cmd_lines = make_lib_command_lines(
+            lib_file, target.mxx_obj_files,
+            target.mxx_all_librarian_options, target )
+
+          Mxx_ru::Abstract_target::run( cmd_lines, [ lib_file ] )
+
+          lib_state = Mxx_ru::Target_state.new( Mxx_ru::Target_state::REBUILT )
+        end
+
+        # Full library file name should be included in files list, created by
+        # given target.
+        target.mxx_add_full_target_name( lib_file )
+
+        # For a library, in a dependency list the library itself may be included.
+        target.mxx_add_required_lib( lib_info.link_name )
+        target.mxx_add_required_lib_path( lib_info.path )
+
+        # And all libraries and folders from all subordinated projects.
+        target.mxx_required_prjs.each { |d|
+          if d.kind_of?( Mxx_ru::Binary_target )
+            d.mxx_required_libs.each { |l|
+              target.mxx_add_required_lib( l )
+            }
+            d.mxx_required_lib_paths.each { |p|
+              target.mxx_add_required_lib_path( p )
+            }
+          end
+        }
+
+        return lib_state
+      end
+
+      # Perform cleanup of static library.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def clean_lib( target )
+        # Creating result file name. Also determining in which folder
+        # lib should be. 
+        lib_info = make_lib_name( target.mxx_target_name, target )
+
+        lib_file = lib_info.full_name
+
+        Mxx_ru::Util::delete_file( lib_file )
+
+        clean_lib_specific_files( lib_file, lib_info, target )
+      end
+
+      # Perform a cleanup of auxiliary files, specific for static library
+      # on given platform. Does nothing in a base class, but may be redefined
+      # by a child class.
+      #
+      # [_a_lib_file_]  Full name of library file.
+      # [_a_lib_info_]  Lib_info, created for the file.
+      # [_a_target_]  Target, library is created for.
+      def clean_lib_specific_files(
+        a_lib_file,
+        a_lib_info,
+        a_target )
+      end
+
+      # Perform dynamic library build.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def make_dll( target )
+        # Creating result file name.
+        dll_info = make_dll_name( target.mxx_target_name, target )
+
+        # Creating dependencies list.
+        all_depend_files = create_executable_depend_list( target )
+
+        # This values will be required later during a calculation of
+        # dependencies of that DLL.
+        link_lists = prepare_linker_lists( target )
+
+        dll_file = dll_info.full_name
+
+        dll_state = Mxx_ru::Target_state::detect(
+          dll_file, all_depend_files )
+        if Mxx_ru::Target_state::EXISTS != dll_state.state
+          # Target should be rebuilt.
+
+          cmd_lines = make_dll_command_lines(
+            dll_file, dll_info, link_lists, target )
+
+          Mxx_ru::Abstract_target::run( cmd_lines, [ dll_file ] )
+
+          dll_state = Mxx_ru::Target_state.new( Mxx_ru::Target_state::REBUILT )
+        end
+
+        # Full library file name should be included in files list, created by
+        # given target.
+        target.mxx_add_full_target_name( dll_file )
+
+        # Determining dependencies list for all who will link this DLL.
+        dll_requirements = make_dll_requirements(
+          dll_file, dll_info, link_lists, target )
+
+        dll_requirements.libs.each { |l|
+            target.mxx_add_required_lib( l ) }
+        dll_requirements.lib_paths.each { |p|
+            target.mxx_add_required_lib_path( p ) }
+
+        return dll_state
+      end
+
+      # Perform dynamic library cleanup.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def clean_dll( target )
+        # Creating result file name.
+        dll_info = make_dll_name( target.mxx_target_name, target )
+
+        dll_file = dll_info.full_name
+
+        Mxx_ru::Util::delete_file( dll_file )
+
+        clean_dll_specific_files( dll_file, dll_info, target )
+      end
+
+      # Perform a cleanup of auxiliary files, specific for static library
+      # on given platform. Does nothing in a base class, but may be redefined
+      # by a child class if import library may be created on given platform.
+      #
+      # [_a_dll_file_]  Full library file name.
+      # [_a_dll_info_]  Dll_info, created for the file.
+      # [_a_target_]  Target, the library is created for.
+      def clean_dll_specific_files(
+        a_dll_file,
+        a_dll_info,
+        a_target )
+      end
+
+      # Perform executable file build.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def make_exe( target )
+        # Creating result file name.
+        exe_info = make_exe_name( target.mxx_target_name, target )
+
+        # Creating dependencies list.
+        all_depend_files = create_executable_depend_list( target )
+
+        exe_file = exe_info.full_name
+
+        exe_state = Mxx_ru::Target_state::detect(
+          exe_file, all_depend_files )
+        if Mxx_ru::Target_state::EXISTS != exe_state.state
+          # Target should be rebuilt.
+
+          link_lists = prepare_linker_lists( target )
+          cmd_lines = make_exe_command_lines(
+            exe_file, exe_info, link_lists, target )
+
+          Mxx_ru::Abstract_target::run( cmd_lines, [ exe_file ] )
+
+          exe_state = Mxx_ru::Target_state.new( Mxx_ru::Target_state::REBUILT )
+        end
+
+        # Full library file name should be included in files list, created by
+        # given target.
+        target.mxx_add_full_target_name( exe_file )
+
+        return exe_state
+      end
+
+      # Perform executable file cleanup.
+      # Target parameter should be an object of a class, inherited from
+      # Mxx_ru::Cpp::Target.
+      def clean_exe( target )
+        # Creating result file name.
+        exe_info = make_exe_name( target.mxx_target_name, target )
+
+        exe_file = exe_info.full_name
+
+        Mxx_ru::Util::delete_file( exe_file )
+
+        clean_exe_specific_files( exe_file, exe_info, target )
+      end
+
+      # Perform a cleanup of auxiliary files, specific for static library
+      # on given platform. Does nothing in a base class, but may be redefined
+      # by a child class.
+      #
+      # [_a_exe_file_]  Full file name.
+      # [_a_exe_info_]  Exe_info, created for the file.
+      # [_a_target_]  Target, the file is created for.
+      def clean_exe_specific_files(
+        a_exe_file,
+        a_exe_info,
+        a_target )
+      end
+
+      # Get file extension for an object file.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      def obj_file_ext()
+        raise Abstract_method_ex.new( "Mxx_ru::Cpp::Toolset::obj_file_ext" )
+      end
+
+      # Create command line for C file compilation.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_obj_name_]  Object file name.
+      # [_source_name_] Source file name.
+      # [_compiler_options_]  Compiler options list. Array of String.
+      # [_target_] Target, which contains object file given.
+      def make_c_obj_command_lines(
+        obj_name,
+        source_name,
+        compiler_options,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_c_obj_command_lines" )
+      end
+
+      # Create command line for C++ file compilation.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_obj_name_]  Object file name.
+      # [_source_name_] Source file name.
+      # [_compiler_options_]  Compiler options list. Array of String.
+      # [_target_] Target, which contains object file given.
+      def make_cpp_obj_command_lines(
+        obj_name,
+        source_name,
+        compiler_options,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_c_obj_command_lines" )
+      end
+
+      # Create command line for resource file compilation.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_res_name_]  Full file name of resulting res file.
+      # [_rc_file_] Source resource file.
+      # [_rc_options_]  Resource compiler options.
+      # [_target_]  Target, resources are required for.
+      def make_mswin_res_command_lines(
+        res_name,
+        rc_file,
+        rc_options,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_mswin_res_command_lines" )
+      end
+
+      # Get static library file name.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      def lib_file_name( source_name )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::lib_file_name" )
+      end
+
+      # Get static library name, which should be passed to the linker.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      def lib_link_name( source_name )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::lib_link_name" )
+      end
+
+      # Create command line for static library build.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_lib_name_]  Result library file name.
+      # [_obj_files_] Object file names, which should be included in the library.
+      # [_librarian_options_] Archiver options list. Array of String.
+      # [_target_]  Target, the library is created for.
+      def make_lib_command_lines(
+        lib_name,
+        obj_files,
+        librarian_options,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_lib_command_lines" )
+      end
+
+      # Get shared library file name.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      def dll_file_name( source_name )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::dll_file_name" )
+      end
+
+      # Get shared library name, which should be passed to the linker.
+      # May return nil if no import library defined.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_dll_real_name_] The name, returned on previous reference to
+      #                   dll_file_name.
+      # [_target_]  Target, the library is created for.
+      def implib_link_name(
+        dll_real_name,
+        target )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::implib_link_name" )
+      end
+
+      # Get folder name containing import library, which should be passed
+      # to the linker.
+      # Executed only if previous implib_link_name returned other then nil value.
+      # May return nil, if no import library defined.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_dll_real_name_] The name, returned on previous reference to
+      #                   dll_file_name.
+      # [_dll_real_path_] Folder name, DLL will be in.
+      # [_target_]  Target, the library is created for.
+      def implib_link_path(
+        dll_real_name,
+        dll_real_path,
+        target )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::implib_link_path" )
+      end
+
+      # Create command line for DLL build.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_a_dll_name_]  DLL result file name.
+      # [_a_dll_info_]  DLL description.
+      # [_a_linker_lists_]  Lists required for linker.
+      # [_a_target_]  Target, the library is created for.
+      def make_dll_command_lines(
+        a_dll_name,
+        a_dll_info,
+        a_linker_lists,
+        a_target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_dll_command_lines" )
+      end
+
+      # Create dependencies list from DLL given.
+      # Returns Dll_requirements object.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_a_dll_name_]  DLL result file name.
+      # [_a_dll_info_]  DLL description.
+      # [_a_linker_lists_]  Lists required for linker.
+      # [_a_target_]  Target, the library is created for.
+      def make_dll_requirements(
+        a_dll_name,
+        a_dll_info,
+        a_linker_lists,
+        a_target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_dll_requirements" )
+      end
+
+      # Get executable file name.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      def exe_file_name( source_name )
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::exe_file_name" )
+      end
+
+      # Create command line for EXE build.
+      # Returns Array of String with command lines.
+      # Should be redefined in a child class.
+      #
+      # Abstract_method_ex exception is thrown in a base class.
+      #
+      # [_a_exe_name_]  EXE result file name.
+      # [_a_exe_info_]  EXE description.
+      # [_a_linker_lists_]  Lists required for linker.
+      # [_a_target_]  Target, the executable is created for.
+      def make_exe_command_lines(
+        a_exe_name,
+        a_exe_info,
+        a_linker_lists,
+        a_target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Toolset::make_exe_command_lines" )
+      end
+
+      # toolset name accessor.
+      def name
+        return @name
+      end
+
+    protected
+      # Creating object file names.
+      # Returns array of Obj_info objects.
+      def make_obj_names( sources, target )
+        obj_names = Array.new
+        sources.each { |s|
+            # Get file name with extension.
+            only_name = File::basename( s.name )
+            # Get file name without extension.
+            only_name = Mxx_ru::Util::remove_file_ext( only_name )
+
+            # Get source folder name.
+            source_path = File::dirname( s.name )
+            # Get target folder name for object file.
+            dest_path = target.mxx_obj_placement.get_obj(
+              source_path, self, target )
+            # Object file name creation.
+            obj_names.push( Obj_info.new(
+              File::join( dest_path, only_name + obj_file_ext() ),
+              s,
+              s.compiler_options ) )
+          }
+        return obj_names
+      end
+
+      # Definition of object files, required to build (if absent) 
+      # or rebuild (if outdated).
+      # Returns array of Obj_info objects.
+      #
+      # [_objs_]  Array of Obj_info
+      def detect_objs_to_rebuild( objs )
+
+        obj_names = Array.new
+        objs.each { |o|
+            obj_state = Mxx_ru::Target_state::detect(
+              o.name, [ o.source.name ] + o.source.depends )
+            if Mxx_ru::Target_state::EXISTS != obj_state.state
+              # File should be rebuilt.
+              obj_names << o
+            end
+          }
+
+        return obj_names
+      end
+
+      # Compilation of object files given.
+      #
+      # [_objs_to_build_] Array of Obj_info.
+      # [_target_]  Target object, contatining these object files.
+      # [_lang_specific_options_] C or C++ specific compiler options. Array of String.
+      # [_a_method_name_] Method name, which should be executed for command line build
+      #                   of source file compilation.
+      def build_objs(
+        objs_to_build,
+        target,
+        lang_specific_options,
+        a_method_name )
+
+        all_files_options = target.mxx_all_compiler_options +
+          lang_specific_options;
+        all_files_options.flatten!
+        all_files_options.uniq!
+
+        objs_to_build.each { |o|
+            # Creating command line to execute compiler.
+            compiler_options =  all_files_options + o.options;
+            compiler_options.flatten!
+            compiler_options.uniq!
+
+            cmd_lines = self.send( a_method_name,
+              o.name, o.source.name,
+              compiler_options,
+              target )
+
+            # Executing.
+            Mxx_ru::Abstract_target::run( cmd_lines, [ o.name ] )
+          }
+
+      end
+
+      # Creating file name for compiled resources.
+      # Returns Mswin_res_info object.
+      def make_mswin_res_name( rc_file, target )
+        source_name = Mxx_ru::Util::remove_file_ext(
+          File::basename( rc_file ) )
+        source_path = File::dirname( rc_file )
+
+        real_name = mswin_res_file_name( source_name )
+        dest_path = target.mxx_obj_placement.get_mswin_res(
+          source_path, self, target )
+
+        return Mswin_res_info.new( real_name, dest_path )
+      end
+
+      # Creating static library file name.
+      # Returns Lib_info object.
+      def make_lib_name( lib_name, target )
+        source_name = File::basename( lib_name )
+        source_path = File::dirname( lib_name )
+
+        real_name = lib_file_name( source_name )
+        link_name = lib_link_name( source_name )
+        dest_path = target.mxx_obj_placement.get_lib(
+          source_path, self, target )
+
+        return Lib_info.new(
+          real_name, dest_path, link_name )
+      end
+
+      # Creating shared library file name.
+      # Returns Dll_info object.
+      def make_dll_name( dll_name, target )
+        source_name = File::basename( dll_name )
+        source_path = File::dirname( dll_name )
+
+        dll_real_name = dll_file_name( source_name )
+        dll_dest_path = target.mxx_obj_placement.get_dll(
+          source_path, self, target )
+
+        link_name = implib_link_name( dll_real_name, target )
+        link_path = nil
+        if nil != link_name
+          link_path = implib_link_path(
+            dll_real_name, dll_dest_path, target )
+        end
+
+        return Dll_info.new(
+          dll_real_name, dll_dest_path, link_name, link_path )
+      end
+
+      # Creating executable file name.
+      # Returns Exe_info object.
+      def make_exe_name( exe_name, target )
+        source_name = File::basename( exe_name )
+        source_path = File::dirname( exe_name )
+
+        real_name = exe_file_name( source_name )
+        dest_path = target.mxx_obj_placement.get_exe(
+          source_path, self, target )
+
+        return Exe_info.new(
+          real_name, dest_path )
+      end
+
+      # Creating full dependencies file list for resulting EXE or DLL file.
+      def create_executable_depend_list( target )
+        all_depend_files = Array.new
+        target.mxx_required_prjs.each { |d|
+            depends = d.mxx_full_targets_names
+            if nil != depends
+              all_depend_files << depends
+            end
+          }
+        all_depend_files << target.mxx_obj_files
+
+        if target.mxx_mswin_res_file
+          all_depend_files << target.mxx_mswin_res_file
+        end
+
+        all_depend_files.flatten!
+
+        return all_depend_files
+      end
+
+      # Creating all lists required for linker.
+      # Returns Linker_lists object.
+      def prepare_linker_lists( target )
+        result = Linker_lists.new
+
+        result.add_objs( target.mxx_obj_files )
+        result.add_resources( target.mxx_mswin_res_file )
+        result.add_libs( target.mxx_required_libs )
+        result.add_lib_paths( target.mxx_required_lib_paths )
+
+        target.mxx_required_prjs.each { |d|
+          if d.kind_of?( Mxx_ru::Binary_target )
+            result.add_libs( d.mxx_required_libs )
+            result.add_lib_paths( d.mxx_required_lib_paths )
+          end
+        }
+
+        result.add_linker_options( target.mxx_all_linker_options )
+
+        return result
+      end
+
+    end # class Toolset
+
+    # Current toolset.
+    @@current_toolset = nil
+
+    # Set current toolset.
+    def Cpp.setup_toolset( toolset )
+      raise Mxx_ru.Invalid_cast_ex.new(
+        'Expected Mxx_ru::Cpp::Toolset' ) if
+          !( toolset.kind_of?( Mxx_ru::Cpp::Toolset ) )
+
+      @@current_toolset = toolset
+    end
+
+    # Get current toolset.
+    def Cpp.toolset
+      return @@current_toolset
+    end
+
+  end # module Cpp
+
+end # module Mxx_ru
+