Mxx_ru 1.1.0

data/lib/mxx_ru/cpp/target.rb

@@ -0,0 +1,1371 @@
+#--
+# 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/binary_target'
+require 'mxx_ru/cpp/mode'
+require 'mxx_ru/cpp/source_file'
+require 'mxx_ru/cpp/obj_placement'
+require 'mxx_ru/cpp/analyzer'
+
+# Base class for all targets of C/C++ projects.
+module Mxx_ru
+
+  module Cpp
+    # Runtime mode types.
+
+    # Default mode.
+    # Nor debug information nor optimization options are set.
+    RUNTIME_DEFAULT = "default"
+    # Release mode. Optimization is turned on.
+    RUNTIME_RELEASE = "release"
+    # Debug mode. Debug information is generated.
+    RUNTIME_DEBUG = "debug"
+
+    # RTTI mode types.
+
+    # Default RTTI mode. No RTTI options are passed to compiler.
+    RTTI_DEFAULT = "default"
+    # RTTI mode should be enabled.
+    RTTI_ENABLED = "enabled"
+    # RTTI mode should be disabled.
+    RTTI_DISABLED = "disabled"
+
+    # RTL mode types.
+
+    # Default compiler libraries are used.
+    RTL_DEFAULT = "default"
+    # Use shared runtime library.
+    RTL_SHARED = "shared"
+    # Use static runtime library.
+    RTL_STATIC = "static"
+
+    # Threading mode types.
+
+    # Default compiler threading mode.
+    THREADING_DEFAULT = "default"
+    # Multithreading is used.
+    THREADING_MULTI = "multi"
+    # Multithreading is not used.
+    THREADING_SINGLE = "single"
+
+    # Screen mode types.
+
+    # Console application.
+    SCREEN_CONSOLE = "console"
+    # Windowed application.
+    SCREEN_WINDOW = "window"
+
+    # Optimization modes.
+
+    # Optimization by size.
+    OPTIM_SIZE = "size"
+    # Optimization by speed.
+    OPTIM_SPEED = "speed"
+
+    # Auxiliary class, intended to store objects like
+    # runtime_mode, rtl_mode, etc, with information about
+    # who has set this or that mode.
+    class Global_single_value_option
+      attr_reader :name
+      attr_reader :default_value
+      attr_reader :value
+      attr_reader :who
+
+      # [_a_name_] Name.
+      # [_a_default_value_] Default value.
+      # [_a_available_values_] Available values. Array of String.
+      def initialize(
+        a_name,
+        a_default_value,
+        a_available_values )
+
+        @name = a_name
+        @default_value = a_default_value
+        @default_value_changer = nil
+        @available_values = a_available_values
+        @value = @default_value
+        @who = "n/a"
+      end
+
+      # Change default value.
+      #
+      # Description of this change is printed to standard output.
+      #
+      # [_a_value_] new default value.
+      # [_a_who_] who tries to change value.
+      def change_default( a_value, a_who )
+        check_value( a_value, a_who )
+
+        if nil == @default_value_changer
+          need_change_current = ( @value == @default_value )
+          @default_value = a_value
+          @default_value_changer = a_who
+          @value = @default_value if need_change_current
+        elsif a_value != @default_value
+          puts "WARNING: ignoring change default value for '#{@name}' to " +
+            "'#{a_value}' by '#{a_who}'; default value already changed by " +
+            "'#{@default_value_changer}'"
+        end
+      end
+
+      # Value change.
+      # If new value is the same as default, value change try is ignored.
+      #
+      # [_a_value_] New value.
+      # [_a_who_] Who tries to change value.
+      def change(
+        a_value,
+        a_who )
+
+        if a_value != @default_value
+          check_value( a_value, a_who )
+
+          if @value == @default_value
+            # Value did not change till now.
+            @value = a_value
+            @who = a_who
+          else
+            # Value is already changed. It is necessary to be convinced,
+            # that values are the same. Otherwise there is a conflict.
+            if a_value != @value
+              raise Mxx_ru::Global_option_conflict_ex.new(
+                @name, @value, @who, a_value, a_who )
+            end
+          end
+        end
+      end
+
+    protected
+      # Search value in available values. Raise exceptions if value
+      # not found.
+      def check_value( value, who )
+        if !@available_values.include?( value )
+          raise Mxx_ru::Global_option_disallowed_value_ex.new(
+            @name, @available_values, value, who )
+        end
+      end
+    end # class Global_single_value_option
+
+    # Auxiliary class for a storage of options, which can be broken on 3 groups:
+    # global, local and upspread.
+    # Examples of such options are: defines, include_paths,
+    # compiler_options, linker_options, ...
+    class Spreadable_option
+      # A name of a method, which should be used for reception of all options.
+      ALL_OPT_METHOD = "all"
+      # A name of a method, which should be used for reception of all upspread options.
+      ALL_UPSPREAD_METHOD = "all_upspreads"
+
+      # The global tick counter which is used for check that cached values are still correct.
+      # Is increased at each reference to add.
+      @@last_change_time = 1
+      # Global hash, in which the time of last change of options with a concrete name is fixed.
+      @@cache_times = Hash.new
+
+      # Set new time of change of value of an option.
+      # This method is intended for use at change of global options, which are stored
+      # separately from spreadable-options, but which values are included 
+      # in values of spreadable-options.
+      def Spreadable_option.refresh_option_change_time( a_option_name )
+        @@last_change_time = @@last_change_time + 1
+        @@cache_times[ a_option_name ] = @@last_change_time
+      end 
+
+      # Constructor.
+      #
+      # [_a_option_name_] The name of an option, which serves the given object.
+      #                   This name will be used for fixation of time of caching
+      #                   in @@cache_times object.
+      def initialize( a_option_name )
+
+        @@cache_times[ a_option_name ] = 1
+
+        # Own name.
+        @name = a_option_name
+
+        # Own options.
+        @locals = Array.new
+        # Spreadable options.
+        @upspreads = Array.new
+
+        # Cached value of all method.
+        @all_cache_value = Array.new
+        # @@last_change_time value at caching moment in all method.
+        @all_cache_time = 0
+
+        # Cached value of all_upspread method.
+        @all_upspread_cache_value = Array.new
+        # @@last_change_time value at caching moment in all_upspread method.
+        @all_upspread_cache_time = 0
+
+      end
+
+      # Add option.
+      #
+      # [_a_option_] Added value.
+      # [_a_mode_] Local or upspread option.
+      #            Is set by values Mxx_ru::Cpp::Target::OPT_LOCAL,
+      #            Mxx_ru::Cpp::Target::OPT_UPSPEAD.
+      def add(
+        a_option,
+        a_mode = Mxx_ru::Cpp::Target::OPT_LOCAL )
+        add_unique_to( a_option, check_opt_mode( a_mode ) )
+      end
+
+      # To get only upspread options..
+      def upspeads_only
+        return @upspreads
+      end
+
+      # To generate the list of all options.
+      #
+      # [_a_globals_] The storage of global options, from which is necessary to take values.
+      # [_a_subprojects_] The list of all subordinated projects.
+      #                   Array of Mxx_ru::Abstract_target.
+      # [_a_upspreads_method_] The name of a method, which needs to be called from
+      #                        the subordinated project, to get it's list of all upspread options.
+      def all(
+        a_globals,
+        a_subprojects,
+        a_upspreads_method )
+
+        if @all_cache_time < @@cache_times[ @name ]
+          # It is necessary to calculate cache anew.
+          r = Array.new
+          r << a_globals << @locals
+
+          # At the same time it is possible to update cache of upspread-options.
+          if @all_upspread_cache_time < @@cache_times[ @name ]
+            u = Array.new
+            u << @upspreads
+            
+            a_subprojects.each { |p|
+              if p.kind_of?( Mxx_ru::Cpp::Target )
+                u << p.send( a_upspreads_method )
+              end
+            }
+
+            @all_upspread_cache_time = @@last_change_time
+            @all_upspread_cache_value = u.flatten.uniq
+          end
+
+          r << @all_upspread_cache_value
+            
+          @all_cache_value = r.flatten.uniq
+          @all_cache_time = @@last_change_time
+        end
+
+        return @all_cache_value
+      end
+
+      # To generate the list of all upspread options.
+      #
+      # [_a_subprojects_] The list of all subordinated projects.
+      #                   Array of Mxx_ru::Abstract_target.
+      # [_a_upspreads_method_] The name of a method, which needs to be called from
+      #                        the subordinated project, to get it's list of all upspread options.
+      def all_upspreads(
+        a_subprojects,
+        a_upspreads_method )
+
+        if @all_upspread_cache_time < @@cache_times[ @name ]
+          # It is necessary to calculate cache anew.
+          r = Array.new
+          r << @upspreads
+   
+          a_subprojects.each { |p|
+            if p.kind_of?( Mxx_ru::Cpp::Target )
+              r << p.send( a_upspreads_method )
+            end
+          }
+   
+          @all_upspread_cache_value = r.flatten.uniq
+          @all_upspread_cache_time = @@last_change_time
+        end
+
+        return @all_upspread_cache_value
+      end
+
+    protected
+      # Add value to Array, if that value is still is not present there.
+      def add_unique_to( what, to )
+        if !to.include?( what )
+          to.push( what )
+
+          Spreadable_option::refresh_option_change_time( @name )
+        end
+      end
+
+      # Check up value of a mode parameter on equality 
+      # either OPT_UPSPREAD, or OPT_LOCAL and return object of Array type,
+      # in which it is necessary to place value.
+      #
+      # [_a_mode_] mode parameter value for check.
+      def check_opt_mode(
+        a_mode )
+        if Mxx_ru::Cpp::Target::OPT_UPSPREAD == a_mode
+          return @upspreads
+        elsif Mxx_ru::Cpp::Target::OPT_LOCAL == a_mode
+          return @locals
+        else
+          raise Mxx_ru::Invalid_value_ex.new(
+            "invalid option mode #{a_mode}" )
+        end
+      end
+    end
+
+    # Target type (exe, lib, dll, unittest, composite etc.).
+    # The real type of the target is defined by a derivative class.
+    class Target_type
+      def name
+        raise Abstract_method_ex.new( "Mxx_ru::Cpp::Target_type::name" )
+      end
+    end
+
+    # Target type is application.
+    class Exe_target_type < Target_type
+      TYPE = "exe"
+
+      def name
+        return TYPE
+      end
+    end
+
+    # Target type is static library (lib).
+    class Lib_target_type < Target_type
+      TYPE = "lib"
+
+      def name
+        return TYPE
+      end
+    end
+
+    # Target type is shared library (dll).
+    class Dll_target_type < Target_type
+      TYPE = "dll"
+
+      def name
+        return TYPE
+      end
+    end
+
+    # Base class for all targets of C/C++ projects.
+    class Target < Mxx_ru::Binary_target
+      # Description of obj_placement object installed.
+      # Used to store global obj_placement.
+      class Global_obj_placement_info
+        # Global obj_placement.
+        attr_reader :placement
+        # Who was set obj_placement.
+        attr_reader :who
+
+        def initialize
+          @placement = nil
+          @who = nil
+        end
+
+        # Change option value.
+        # If placement already set, exception thrown.
+        def change( a_placement, a_who )
+          if nil != a_placement && nil != @placement
+            raise Mxx_ru::Global_option_conflict_ex.new(
+              "global_obj_placement",
+              @placement.class.name,
+              @who,
+              a_placement.class.name,
+              a_who )
+          end
+
+          @placement = a_placement
+          @who = a_who
+        end
+      end
+
+      # Action class to store option in Array.
+      class Global_option_inserter
+
+        # [_a_option_name_] Name of option served. It is necessary for
+        #                   referecne to 
+        #                   Spreadable_option.refresh_option_change_time
+        #                   method.
+        # [_a_receiver_] Where to add value.
+        def initialize(
+          a_option_name,
+          a_receiver )
+          @option_name = a_option_name
+          @receiver = a_receiver
+        end
+
+        def call( *args )
+          @receiver.push( *args )
+
+          Spreadable_option::refresh_option_change_time( @option_name )
+        end
+      end # class Global_option_inserter
+
+      # Action class to store option in Spreadable_option object.
+      class Spreadable_option_inserter
+
+        # [_a_receiver_] Where to add value.
+        def initialize(
+          a_receiver )
+          @receiver = a_receiver
+        end
+
+        def call( *args )
+          @receiver.send( "add", *args )
+        end
+      end # class Spreadable_option_inserter
+
+      # Action class to get all option values (local, global and upspread)
+      # from Spreadable_option object.
+      class Spreadable_option_all_extractor
+
+        # [_a_option_] In whom to call a "call" method.
+        # [_a_globals_] Whence to take values of global options.
+        # [_a_target_] The target, from which is necessary to take the list
+        #              of subordinated projects.
+        # [_a_upspreads_only_method_] A method which should be called on
+        #                             subordinated projects for extracting
+        #                             the values of their upspreadable options.
+        def initialize(
+          a_option,
+          a_globals,
+          a_target,
+          a_upspreads_only_method )
+
+          @option = a_option
+          @globals = a_globals
+          @target = a_target
+          @upspreads_only_method = a_upspreads_only_method
+        end
+
+        def call( *args )
+          return @option.all( @globals, @target.mxx_required_prjs,
+            @upspreads_only_method )
+        end
+      end # class Spreadable_option_all_extractor
+
+      # Action class to get upspreadable option values only
+      # from Spreadable_option object.
+      class Spreadable_option_upspread_extractor
+
+        # [_a_option_] In whom to call a "call" method.
+        # [_a_target_] The target, from which is necessary to take the list
+        #              of subordinated projects.
+        # [_a_upspreads_only_method_] A method which should be called on
+        #                             subordinated projects for extracting
+        #                             the values of their upspreadable options.
+        def initialize(
+          a_option,
+          a_target,
+          a_upspreads_only_method )
+
+          @option = a_option
+          @target = a_target
+          @upspreads_only_method = a_upspreads_only_method
+        end
+
+        def call( *args )
+          return @option.all_upspreads( @target.mxx_required_prjs,
+            @upspreads_only_method )
+        end
+      end # class Spreadable_option_all_extractor
+
+      # Runtime mode storage.
+      @@mxx_runtime_mode = Global_single_value_option.new(
+        "runtime_mode", RUNTIME_DEFAULT,
+        [ RUNTIME_RELEASE, RUNTIME_DEBUG ] )
+      # RTTI mode storage.
+      @@mxx_rtti_mode = Global_single_value_option.new(
+        "rtti_mode", RTTI_DEFAULT,
+        [ RTTI_ENABLED, RTTI_DISABLED ] )
+      # RTL mode storage.
+      @@mxx_rtl_mode = Global_single_value_option.new(
+        "rtl_mode", RTL_DEFAULT,
+        [ RTL_SHARED, RTL_STATIC ] )
+      # Threading mode storage.
+      @@mxx_threading_mode = Global_single_value_option.new(
+        "threading_mode", THREADING_DEFAULT,
+        [ THREADING_MULTI, THREADING_SINGLE ] )
+
+      # The storage of global description of obj_placement.
+      @@mxx_global_obj_placement = Global_obj_placement_info.new
+
+      # Global options storage.
+      # The key is a String, the value is Array of String.
+      @@mxx_globals = Hash.new
+
+      # Attribute that the option should be upspreadable.
+      OPT_UPSPREAD = "upspread"
+      # Attribute that the option should be local.
+      OPT_LOCAL = "local"
+
+      # Path, the name of result of a target is related to.
+      # If contains an empty value, target should be defined using a full path.
+      # Otherwise the value of mxx_target_root is concatenated with a given target name.
+      attr_reader :mxx_target_root
+      # Path, the names of source files are related to.
+      attr_reader :mxx_sources_root
+      # Screen mode. Console by default.
+      attr_reader :mxx_screen_mode
+      # The list of source C-files.
+      # Array of Mxx_ru::Cpp::Cpp_source_file objects.
+      attr_reader :mxx_c_files
+      # The list of source C++-files.
+      # Array of Mxx_ru::Cpp::Cpp_source_file objects.
+      attr_reader :mxx_cpp_files
+      # Object files list.
+      attr_reader :mxx_obj_files
+      # Name of mswin resource file.
+      # Should be object of Mxx-ru::Cpp::Mswin_rc_file type.
+      # May contain nil value, if resources are not used.
+      attr_reader :mxx_mswin_rc_file
+      # The name of compiled mswin resource file.
+      # Should be a string.
+      # May contain nil value, if resources are not used.
+      attr_reader :mxx_mswin_res_file
+      # Import library folder.
+      # May contain nil value.
+      attr_reader :mxx_implib_path
+      # The name to get target result.
+      # Should not contain file extension.
+      attr_reader :mxx_target_name
+      # Optimization mode. By default, speed optimization is used.
+      attr_reader :mxx_optimization
+
+      # Generator for methods to manipulation with 'runtime_mode',
+      # 'rtti_mode', 'rtl_mode', 'threading_mode' and so on.
+      #
+      # By default generates 3 methods:
+      #   # Setter
+      #   def <option>( value ); ...; end
+      #   # Setter for default value.
+      #   def default_<option>( value ); ...; end
+      #   # Getter
+      #   def mxx_<option>; ...; end
+      #
+      # If no_getter == :nogetter then getter method not generated.
+      def self.global_option_methods( option, getter = :withgetter )
+        class_eval %Q{
+          def #{option}( value )
+            @@mxx_#{option}.change( value, prj_alias )
+          end
+          def default_#{option}( value )
+            @@mxx_#{option}.change_default( value, prj_alias )
+          end
+        }
+        class_eval %Q{
+          def mxx_#{option}
+            @@mxx_#{option}.value
+          end
+        } unless getter == :nogetter
+      end
+
+      # Constructor
+      # [_a_prj_alias_] Project identifier.
+      def initialize( a_prj_alias )
+
+        super( a_prj_alias )
+
+        @mxx_target_root = ""
+
+        @mxx_sources_root = File.dirname( a_prj_alias )
+
+        @mxx_screen_mode = SCREEN_CONSOLE
+
+        @mxx_c_files = Array.new
+        @mxx_cpp_files = Array.new
+
+        @mxx_mswin_rc_file = nil
+        @mxx_mswin_res_file = nil
+
+        @mxx_obj_files = Array.new
+
+        # The storage of local options.
+        # The key is a String, the value is Spreadable_option.
+        @mxx_locals = Hash.new
+
+        @mxx_implib_path = nil
+
+        # Object, which defines accommodation of object files.
+        @mxx_obj_placement = nil
+
+        @mxx_target_name = nil
+
+        @mxx_optimization = OPTIM_SPEED
+
+        # Result of work of the previous reference to a build method.
+        # During a repeted calls of build method target build is not performed,
+        # and this value is returned.
+        @mxx_last_build_result = nil
+
+        # True if toolset has completely defined all compiler and linker options required.
+        @mxx_all_options_defined = false
+
+        # Action list for methods, which are implemented through 
+        # overloaded method_missing method.
+        @mxx_missing_actions = Hash.new
+
+        add_spreadable_option( "compiler_option" )
+        add_spreadable_option( "cpp_compiler_option" )
+        add_spreadable_option( "c_compiler_option" )
+        add_spreadable_option( "linker_option" )
+        add_spreadable_option( "librarian_option" )
+        add_spreadable_option( "define" )
+        add_spreadable_option( "include_path" )
+        add_spreadable_option( "mswin_rc_option" )
+        add_spreadable_option( "mswin_rc_include_path" )
+        add_spreadable_option( "mswin_rc_define" )
+        add_spreadable_option( "mswin_rlink_option" )
+
+      end
+
+      # Overloading standard reaction to absence of a method in a class.
+      # A number of methods are implemented with a help of that trick.
+      # Actions for such methods should be defined in @mxx_missing_actions.
+      def method_missing( a_meth_id, *args )
+        meth_name = a_meth_id.id2name
+        caller = @mxx_missing_actions[ meth_name ]
+        if caller
+          r = caller.call( *args )
+        else
+          super( a_meth_id, *args )
+        end
+      end
+
+      # A simple way to get access to the toolset.
+      # In a class, inherited from Mxx_ru::Cpp::Target is more convinient
+      # to call toolset method, instead of Mxx_ru::Cpp::toolset function.
+      # Just calling Mxx_ru::Cpp::toolset function.
+      def toolset()
+        return Mxx_ru::Cpp::toolset()
+      end
+
+      global_option_methods :runtime_mode, :nogetter
+
+      # runtime_mode accessor (custom implementation).
+      def mxx_runtime_mode
+        # If runtime_mode is set to RUNTIME_DEFAULT (i.e.
+        # wasn't changed in a projects), then check of command line options
+        # is required (--mxx-cpp-release, --mxx-cpp-debug).
+        result = @@mxx_runtime_mode.value
+        if @@mxx_runtime_mode.default_value == result
+          if Mxx_ru::Cpp::Mode.instance.is_release &&
+            Mxx_ru::Cpp::Mode.instance.is_debug
+            # This is an invalid combination of flags.
+            raise Mxx_ru::Invalid_value_ex.new(
+              "#{Mxx_ru::Cpp::MXXCPPARG_RELEASE} and " +
+              "#{Mxx_ru::Cpp::MXXCPPARG_DEBUG} cannot be used " +
+              "together" )
+          elsif Mxx_ru::Cpp::Mode.instance.is_release
+            result = RUNTIME_RELEASE
+          elsif Mxx_ru::Cpp::Mode.instance.is_debug
+            result = RUNTIME_DEBUG
+          end
+        end
+
+        return result
+      end
+
+      global_option_methods :rtti_mode
+      global_option_methods :rtl_mode
+      global_option_methods :threading_mode
+
+      # Set global obj_placement.
+      # If gloval obj_placement was already set before, exception is thrown.
+      def global_obj_placement( a_placement )
+        @@mxx_global_obj_placement.change( a_placement, prj_alias )
+      end
+
+      # Set local obj_placement.
+      # It's impossible to simultaneously set global and local obj_placement.
+      def obj_placement( a_placement )
+        @mxx_obj_placement = a_placement
+      end
+
+      # Get obj_placement object, which should be used.
+      #
+      # If both global and local obj_placement are set, exception is thrown.
+      #
+      # If global or local obj_placement is defined, it is returned.
+      #
+      # If nor global nor local obj_placement is set, local obj_placement is created
+      # with a help of Mxx_ru::Cpp::default_obj_placement function and it's returned.
+      def mxx_obj_placement
+        if nil != @mxx_obj_placement &&
+          nil != @@mxx_global_obj_placement.placement
+          raise Mxx_ru::Invalid_value_ex.new(
+            "Global and local obj_placement object exists! " +
+            "Global created by: #{@@mxx_global_obj_placement.who}. " +
+            "Local created by: #{prj_alias}" )
+        end
+
+        if nil != @@mxx_global_obj_placement.placement
+          return @@mxx_global_obj_placement.placement
+        end
+
+        if nil == @mxx_obj_placement
+          @mxx_obj_placement = Mxx_ru::Cpp::default_obj_placement
+        end
+
+        return @mxx_obj_placement
+      end
+
+      # Change path, the names of target results are related to.
+      #
+      # NOTE: This method should be called BEFORE target method!
+      #
+      # If target_root is called after target method,
+      # then _a_root_ given is added to the name already was set.
+      def target_root( a_root )
+        @mxx_target_root = a_root
+        if @mxx_target_name
+          @mxx_target_name = File.join(
+            [ @mxx_target_root, @mxx_target_name ] )
+        end
+      end
+
+      # Set a name from which target name would be created.
+      def target( a_target )
+        @mxx_target_name = create_full_target_file_name( a_target )
+      end
+
+      # Change source files path.
+      # If empty string is set, then full file names are required.
+      # If block is defined, then path is changed only during a block
+      # execution, then old path value is restored.
+      #
+      # Returns previous mxx_sources_root value. Is actual for a case,
+      # when method is called without block parameter.
+      def sources_root( a_root )
+        old_root = @mxx_sources_root.clone
+        if block_given?
+          @mxx_sources_root = File.join( [ @mxx_sources_root, a_root ] )
+          yield
+          @mxx_sources_root = old_root
+        else
+          @mxx_sources_root = a_root
+        end
+
+        return old_root
+      end
+
+      # Set screen mode.
+      def screen_mode( a_mode )
+        if SCREEN_CONSOLE == a_mode || SCREEN_WINDOW == a_mode
+          @mxx_screen_mode = a_mode
+        else
+          raise Mxx_ru::Unsupported_mode_ex.new(
+            "Unsupported screen mode: #{a_mode}" )
+        end
+      end
+
+      # Add one C-file to the target.
+      #
+      # [_a_file_name_] The name of a file added.
+      # [_a_options_] Optional list of a compiler options for that file.
+      #               When command line would be created, this options would
+      #               be concatenated with others.
+      def c_source( a_file_name, a_options = nil )
+        @mxx_c_files.push( Cpp_source_file.new(
+          create_full_src_file_name( a_file_name ), a_options ) )
+      end
+
+      # Add one C++-file to the target.
+      #
+      # [_a_file_name_] The name of a file added.
+      # [_a_options_] Optional list of a compiler options for that file.
+      #               When command line would be created, this options would
+      #               be concatenated with others.
+      def cpp_source( a_file_name, a_options = nil )
+        @mxx_cpp_files.push( Cpp_source_file.new(
+          create_full_src_file_name( a_file_name ), a_options ) )
+      end
+
+      # Set mswin resource file name.
+      #
+      # [_a_rc_file_] The name of rc-file.
+      # [_a_depends_] Optional dependencies list. Should be Array of String.
+      def mswin_rc_file(
+        a_rc_file,
+        a_depends =nil )
+
+        @mxx_mswin_rc_file = Mswin_rc_file.new( a_rc_file, a_depends )
+      end
+
+      # Set compiled mswin resource file name.
+      def mswin_res_file( a_res_file )
+        @mxx_mswin_res_file = String.new( a_res_file )
+      end
+
+      # Add object file to the target.
+      def obj_file( file_name )
+        @mxx_obj_files.push( String.new( file_name ) )
+      end
+
+      # Add the library required.
+      # If a_path is other then nil, then it's value is added to the list
+      # of a folders, the libraries should be searched in.
+      def lib( a_library, a_path = nil )
+        mxx_add_required_lib( a_library )
+        if a_path
+          mxx_add_required_lib_path( a_path )
+        end
+      end
+
+      # Set import library location.
+      def implib_path( name )
+        @mxx_implib_path = name.clone
+      end
+
+      # Set optimization mode required.
+      def optimization( a_mode )
+        if OPTIM_SIZE != a_mode && OPTIM_SPEED != a_mode
+          raise Mxx_ru::Invalid_value_ex.new(
+            "Unknown optimization mode: '#{a_mode}'" )
+        else
+          @mxx_optimization = a_mode.clone
+        end
+      end
+
+      # Perform build of the target.
+      def build
+        if nil == @mxx_last_build_result
+
+          if !@mxx_all_options_defined
+            # It's necessary, that toolset has defined all the options
+            # taking all current modes into account.
+            Mxx_ru::Cpp::toolset.setup_mandatory_options( self )
+            @mxx_all_options_defined = true
+          end
+
+          Mxx_ru::Cpp::Mode.instance.before_subprj_processing
+          # The build of subordinated projects performed automatically
+          # taking dry-run mode into account.
+          required_prjs_state = build_required_projects
+          Mxx_ru::Cpp::Mode.instance.after_subprj_processing
+
+          run_generators
+          if !Mxx_ru::Cpp::Mode.instance.is_no_depends_analyzer
+            run_depends_analyzer
+          end
+          objs_state = compile_sources
+
+          res_state = compile_resources
+
+          link_state = link_target(
+            required_prjs_state,
+            objs_state, res_state )
+
+          # The status of the target is determined by result of target linking.
+          @mxx_last_build_result = link_state
+        end
+
+        return @mxx_last_build_result
+      end
+
+      # Perform target's cleanup.
+      def clean
+        if nil == @mxx_last_build_result
+
+          if !@mxx_all_options_defined
+            # It's necessary, that toolset has defined all the options
+            # taking all current modes into account.
+            Mxx_ru::Cpp::toolset.setup_mandatory_options( self )
+            @mxx_all_options_defined = true
+          end
+
+          Mxx_ru::Cpp::Mode.instance.before_subprj_processing
+          # The cleanup of subordinated projects performed automatically
+          # taking dry-run mode into account.
+          clean_required_prjs
+          Mxx_ru::Cpp::Mode.instance.after_subprj_processing
+
+          clean_generators
+          clean_objs
+          clean_resources
+          clean_target
+
+          @mxx_last_build_result = Mxx_ru::Target_state.new(
+            Mxx_ru::Target_state::ABSENT )
+        end
+      end
+
+      # Get the target type.
+      # Should be overloaded in child classes.
+      # Object, inherited from Mxx_ru::Cpp::Target_type is returned.
+      def target_type
+        raise Abstract_method_ex.new( "Mxx_ru::Cpp::Target::target_type" )
+      end
+
+      # Creation of a complete name of a resulting file
+      # taking the value of mxx_target_root into account
+      def create_full_target_file_name( a_file_name )
+        if "" == mxx_target_root
+          return a_file_name
+        else
+          return File.join( [ mxx_target_root, a_file_name ] )
+        end
+      end
+
+      # Creation of a complete name of a source file
+      # taking the value of mxx_sources_root into account
+      def create_full_src_file_name( a_file_name )
+        if "" == mxx_sources_root
+          return a_file_name
+        else
+          return File.join( [ mxx_sources_root, a_file_name ] )
+        end
+      end
+
+    protected
+      # Start of all generators of source files.
+      def run_generators
+        mxx_generators.each { |g| g.build( self ) }
+      end
+
+      # Start of C++ dependencies analyzer.
+      def run_depends_analyzer
+        analyzer = Analyzer::Cpp_analyzer.instance
+
+        # We prepare the analyzer to start.
+        sources = Array.new
+        mxx_c_files.each { |s| sources << s.name }
+        mxx_cpp_files.each { |s| sources << s.name }
+        analyzer.add_sources( sources )
+
+        analyzer.add_include_paths( mxx_all_include_paths )
+
+        # Performing analisys.
+        analyzer.analyze
+
+        # Getting results of analysis.
+        mxx_c_files.each { |s|
+          depends = analyzer.get_depends_for( s.name )
+          s.depends << depends
+          s.depends.flatten!
+        }
+
+        mxx_cpp_files.each { |s|
+          depends = analyzer.get_depends_for( s.name )
+          s.depends << depends
+          s.depends.flatten!
+        }
+      end
+
+      # Start of source files compiler.
+      # Returns Mxx_ru::Target_state.
+      def compile_sources
+        return Mxx_ru::Cpp::toolset().make_objs( self )
+      end
+
+      # Start of resource files compiler.
+      # Returns nothing.
+      def compile_resources
+        # We proceed from the assumption, that on one platform
+        # some different types of resource files simultaneously can not be used.
+        if @mxx_mswin_rc_file
+          return Mxx_ru::Cpp::toolset().make_mswin_res( self )
+        end
+
+        return Mxx_ru::Target_state.new( Target_state::EXISTS )
+      end
+
+      # Start of target linking.
+      #
+      # [_required_prjs_state_] Build results of all subprojects required.
+      #                         Object of Mxx_ru::Target_state type.
+      # [_objs_state_] Compilation results of all object files
+      #                Object of Mxx_ru::Target_state type.
+      # [_res_state_] Compilation results of all resource files.
+      #               Object of Mxx_ru::Target_state type.
+      def link_target(
+        required_prjs_state,
+        objs_state,
+        res_state )
+
+        state = nil
+        toolset = Mxx_ru::Cpp::toolset
+        if nil == target_type
+          raise Mxx_ru::Unsupported_target_type_ex.new(
+            self.class.name, "nil" )
+        elsif target_type.name == Lib_target_type::TYPE
+          state = toolset.make_lib( self )
+        elsif target_type.name == Dll_target_type::TYPE
+          state = toolset.make_dll( self )
+        elsif target_type.name == Exe_target_type::TYPE
+          state = toolset.make_exe( self )
+        else
+          raise Mxx_ru::Unsupported_target_type_ex.new(
+            self.class.name, target_type.name )
+        end
+
+        return state
+      end
+
+      def clean_generators
+        mxx_generators.each { |g| g.clean( self ) }
+      end
+
+      def clean_objs
+        Mxx_ru::Cpp::toolset().clean_objs( self )
+      end
+
+      def clean_resources
+        if @mxx_mswin_rc_file
+          Mxx_ru::Cpp::toolset().clean_mswin_res( self )
+        end
+      end
+
+      def clean_target
+        toolset = Mxx_ru::Cpp::toolset
+        if nil == target_type
+          raise Mxx_ru::Unsupported_target_type_ex.new(
+            self.class.name, "nil" )
+        elsif target_type.name == Lib_target_type::TYPE
+          state = toolset.clean_lib( self )
+        elsif target_type.name == Dll_target_type::TYPE
+          state = toolset.clean_dll( self )
+        elsif target_type.name == Exe_target_type::TYPE
+          state = toolset.clean_exe( self )
+        else
+          raise Mxx_ru::Unsupported_target_type_ex.new(
+            self.class.name, target_type.name )
+        end
+      end
+
+      # Create the necessary description of an option, 
+      # which can have global, local and upspreadable value.
+      #
+      # [_a_option_desc_] The main component of a name of absent methods.
+      def add_spreadable_option(
+        a_option_desc )
+
+        globals = @@mxx_globals[ a_option_desc ]
+        if nil == globals
+          @@mxx_globals[ a_option_desc ] = globals = Array.new
+        end
+
+        locals = Spreadable_option.new( a_option_desc )
+        @mxx_locals[ a_option_desc ] = locals
+
+        meth_global = "global_#{a_option_desc}"
+        meth_local = a_option_desc
+        meth_all = "mxx_all_#{a_option_desc}s"
+        meth_upspreads = "mxx_upspread_#{a_option_desc}s"
+
+        @mxx_missing_actions[ meth_global ] =
+          Global_option_inserter.new( a_option_desc, globals )
+        @mxx_missing_actions[ meth_local ] =
+          Spreadable_option_inserter.new( locals )
+        @mxx_missing_actions[ meth_all ] =
+          Spreadable_option_all_extractor.new( locals,
+            globals, self, meth_upspreads )
+        @mxx_missing_actions[ meth_upspreads ] =
+          Spreadable_option_upspread_extractor.new(
+            locals, self, meth_upspreads )
+      end
+
+      def add_unique_to( what, to )
+        if !to.include?( what )
+          to.push( what )
+        end
+      end
+
+    end # class Target
+
+    # Base class for targets that may be lib or dll.
+    #
+    # In that cases for a project should be defined special target class.
+    # The class constructor should define two blocks:
+    # * one of them is called if developer wants to build target 
+    #   as a static library. Block is run during as_lib method call;
+    # * second is called if developer wants to build target
+    #   as a shared library. Block is run during as_dll method call;
+    #
+    # For example:
+    #
+    #  class Prj < Mxx_ru::Cpp::Lib_or_dll_target
+    #    TAG = "threads_1/prj.rb"
+    #    def initialize( a_alias = TAG )
+    #      super( a_alias, TAG )
+    # 
+    #      target( "threads.1.3" )
+    # 
+    #      threading_mode( Mxx_ru::Cpp::THREADING_MULTI )
+    # 
+    #      init_dll_block(
+    #        Proc.new {
+    #          rtl_mode( Mxx_ru::Cpp::RTL_SHARED )
+    #          implib_path( "lib" )
+    #          define( "THREADS_1__DLL", OPT_UPSPREAD )
+    #        })
+    # 
+    #      cpp_source( "threads.cpp" )
+    #      cpp_source( "micro_time.cpp" )
+    # 
+    #      if toolset.tag( "target_os" ) == "mswin"
+    #        define( "__WIN32__" )
+    #        cpp_source( "win32/os_thread.cpp" )
+    #      elsif toolset.tag( "target_os" ) == "unix"
+    #        cpp_source( "posix/os_thread.cpp" )
+    #      end
+    # 
+    #      define( "THREADS_1__PRJ" )
+    #    end
+    #  end
+    #
+    # After definition of such class for the target, project may allow
+    # to use itself by the other projects using two methods.
+    #
+    # == Manual execution of as_lib, as_dll methods
+    #
+    # If project defines one class only, inherited from Lib_or_dll_target,
+    # then all clients of that project should explicitly call as_lib or as_dll
+    # method during a reference to required_prj:
+    #
+    #  class My_prj < Mxx_ru::Cpp::Exe_target
+    #    def initialize( a_alias = "my_prj.rb" )
+    #      super( a_alias )
+    #      required_prj( "threads_1/prj.rb" ).as_dll( self )
+    #    end
+    #  end
+    #
+    # Such approach is not good because if in composite project several
+    # projects at the same time uses threads_1/prj.rb, then in one of them
+    # it's easy to forget to call as_dll. And it wouldn't be incorrect,
+    # because as_dll may be called by other projects in composite project.
+    #
+    # == Definition of auxiliary target classes
+    #
+    # To make usage of target that may be lib or dll easier, project may
+    # define two auxiliary classes, which would call methods as_lib and as_dll
+    # inside their constructors:
+    #
+    #  class Prj < Mxx_ru::Cpp::Lib_or_dll_target
+    #    def initialize( a_alias = "threads_1/prj.rb" )
+    #      super( a_alias, "threads_1" )
+    #      ...
+    #    end
+    #  end
+    #  class Lib < Prj
+    #    def super( a_alias = "threads_1/lib.rb" )
+    #      super( a_alias )
+    #      as_lib
+    #    end
+    #  end
+    #  class Dll < Prj
+    #    def super( a_alias = "threads_1/dll.rb" )
+    #      super( a_alias )
+    #      as_dll
+    #    end
+    #  end
+    #
+    # Then for using the target it would be enough to do that:
+    #  class My_prj < Mxx_ru::Cpp::Exe_target
+    #    def initialize( a_alias = "my_prj.rb" )
+    #      super( a_alias )
+    #      required_prj( "threads_1/dll.rb" )
+    #    end
+    #  end
+    #
+    class Lib_or_dll_target < Target
+      # Exception type, which is thrown if target type is undefined.
+      class Type_not_defined_ex < Mxx_ru::Ex
+        # [_a_prj_alias_] Project alias, for which target type should be defined.
+        def initialize( a_prj_alias )
+          super( "#{a_prj_alias}: type of target not defined yet" )
+        end
+      end
+
+      # Exception type, which is thrown if target type was already defined.
+      class Type_already_defined_ex < Mxx_ru::Ex
+        # [_a_prj_tag_] Target identifier, for which type is established.
+        # [_a_type_] Already defined target type.
+        def initialize( a_prj_alias, a_type )
+          super( "#{a_prj_alias}: type of target already defined " +
+            "as #{a_type}" )
+        end
+      end
+
+      # Map describing unique target identifiers and their types.
+      # Used to avoid conflicts, when the same target is inside composite project
+      # as both lib and dll.
+      @@mxx_tags = Hash.new
+
+      # Constructor.
+      #
+      # [_a_prj_alias_] Project alias.
+      # [_a_prj_tag_] Unique value, which identifies target given.
+      #               This value used to avoid conflicts in the next situations:
+      #  class Prj < Mxx_ru::Cpp::Lib_or_dll_target ... end
+      #  class Lib < Prj ... end
+      #  class Dll < Prj ... end
+      #  class My_exe < Mxx_ru::Cpp::Exe_target
+      #    def initialize( a_alias = "my_exe.rb" )
+      #      super( a_alias )
+      #      required_prj( "threads_1/dll.rb" )
+      #    end
+      #  end
+      #  class My_dll < Mxx_ru::Cpp::Dll_target
+      #    def initialize( a_alias = "my_dll.rb" )
+      #      super( a_alias )
+      #      required_prj( "threads_1/lib.rb" )
+      #    end
+      #  end
+      # If both My_exe and My_dll are used in one composite project,
+      # then it's a conflict of usage of threads_1/dll.rb and threads_1/lib.rb.
+      def initialize( a_prj_alias, a_prj_tag )
+        super( a_prj_alias )
+
+        @mxx_prj_tag = a_prj_tag
+
+        # Block, which is run if lib is a target.
+        @mxx_init_lib_block = nil
+        # Block, which is run if dll is a target.
+        @mxx_init_dll_block = nil
+        # Target type should be defined or by as_lib method, or by as_dll method.
+        @mxx_target_type = nil
+
+      end
+
+      # Set lib as target type.
+      def as_lib
+        if ensure_type_not_set_yet( Lib_target_type::TYPE )
+          @mxx_target_type = Lib_target_type.new
+          if nil != @mxx_init_lib_block
+            @mxx_init_lib_block.call
+          end
+        end
+      end
+
+      # Set dll as target type.
+      def as_dll
+        if ensure_type_not_set_yet( Dll_target_type::TYPE )
+          @mxx_target_type = Dll_target_type.new
+          if nil != @mxx_init_dll_block
+            @mxx_init_dll_block.call
+          end
+        end
+      end
+
+      # Return current value of mxx_target_type.
+      def target_type
+        if nil == @mxx_target_type
+          raise Type_not_defined_ex.new( prj_alias )
+        end
+
+        return @mxx_target_type
+      end
+
+    protected
+      # Set initialization block for lib.
+      # This block will be executed in as_lib method.
+      def init_lib_block( a_block )
+        @mxx_init_lib_block = a_block
+      end
+
+      # Set initialization block for dll.
+      # This block will be executed in as_dll method.
+      def init_dll_block( a_block )
+        @mxx_init_dll_block = a_block
+      end
+
+    private
+      # If someone already defined other target type, exception is thrown.
+      # If already defined target type is the same, false returned.
+      # If target type is not defined, true is returned.
+      #
+      # [_a_type_name_] Name of target type defined.
+      def ensure_type_not_set_yet( a_type_name )
+        if @@mxx_tags.key?( @mxx_prj_tag ) &&
+          @@mxx_tags[ @mxx_prj_tag ] != a_type_name
+          raise Type_already_defined_ex.new(
+            @mxx_prj_tag, a_type_name )
+        end
+
+        @@mxx_tags[ @mxx_prj_tag ] = a_type_name
+
+        return ( nil == @mxx_target_type )
+      end
+    end # class Lib_or_dll_target
+
+    # Lib is a target type.
+    class Lib_target < Lib_or_dll_target
+      def initialize( a_prj_alias, &block )
+        super( a_prj_alias, a_prj_alias )
+
+        as_lib
+
+        instance_eval( &block ) if block
+      end
+    end
+
+    # Dll is a target type.
+    class Dll_target < Lib_or_dll_target
+      def initialize( a_prj_alias, &block )
+        super( a_prj_alias, a_prj_alias )
+
+        as_dll
+
+        instance_eval( &block ) if block
+      end
+    end
+
+    # Exe is a target type.
+    class Exe_target < Target
+
+      def initialize( a_alias, &block )
+        super( a_alias )
+
+        instance_eval( &block ) if block
+      end
+
+      def target_type
+        return Exe_target_type.new
+      end
+    end
+
+    # Generator for generating method for simple way of describing targets.
+    def Cpp.generate_simple_target_method( target_type )
+      target_class_name = target_type.to_s.capitalize
+      class_eval %Q{
+        def Cpp.#{target_type}( prj_alias, &block )
+          Mxx_ru::setup_target #{target_class_name}.new( prj_alias, &block )
+        end
+      }
+    end
+
+    generate_simple_target_method :lib_target
+    generate_simple_target_method :dll_target
+    generate_simple_target_method :exe_target
+
+  end # module Cpp
+end # module Mxx_ru
+