Mxx_ru 1.2.1 → 1.3.0

data/NEWS

@@ -1,5 +1,43 @@
 Changes in Mxx_ru
 
+1.3.0 version (2006.05.15)
+
+  New command line argument --mxx-rebuild.
+
+  Added support for RuCodeGen 0.2.0.
+
+  New methods Mxx_ru::BinaryTarget#lib_static, Mxx_ru::BinaryTarget#lib_shared.
+  For now, they only make sense for Unix and GCC toolsets.
+
+  New method QtGen#uic_result_subdir for specifying custom path to store
+  uic results.
+
+  Qt support improvement: Now, during a building of *.cpp file from *.ui,
+  short form of *.hpp file name is specified in '-i' argument in order to get
+  correct include definition.
+  (e.g. 'some_header.hpp' instead of 'src/module/some_header.hpp').
+
+  Task 'test' is added into Rakefile for unit test automation. Some tests
+  converted into unit-tests. Special mix-in TestWithCompilation (in
+  tests/test_with_compilation.rb) added for this purpose.
+
+  New Methods BinaryTarget#lib_path, BinaryTarget#lib_paths.
+
+  Improvement: under mswin no longer necessary to specify library name with
+  '.lib' extension. This extension automatically added by Visual C++ toolset
+  if needed.
+
+  Method Mxx_ru::Cpp::Target#target_ext and possibility for changing default
+  target extension added.
+
+  Added 'option extraction mode' for C/C++ targets (command-line argument
+  '--mxx-cpp-extract-options' and its processing in Mxx_ru::Cpp::Target).
+
+  New class for controlling ObjPlacement for C/C++ targets
+  Mxx_ru::Cpp::CustomSubdirObjPlacement added.
+
+  Refactoring: names of all classes converted into standard Ruby convention.
+
 1.2.0 version (2006.04.15)
 
   Added command-line arguments --mxx-brief-show, --mxx-brief-hide and

data/Rakefile

@@ -2,13 +2,14 @@ require 'rubygems'
 Gem::manage_gems
 
 require 'rake/gempackagetask'
+require 'rake/testtask'
 
 PKG_NAME = 
-PKG_VERSION = '1.2.1'
+RKG_VERSION = '1.3.0'
 
 spec = Gem::Specification.new do |s|
   s.name = "Mxx_ru"
-  s.version = PKG_VERSION
+  s.version = "1.3.0"
   s.author = "The Mxx_ru Project"
   s.email = "eao197@yahoo.com"
   s.homepage = "http://www.rubyforge.com/projects/mxx-ru"
@@ -29,4 +30,30 @@ gem = Rake::GemPackageTask.new( spec ) do |pkg|
   pkg.need_tar = true
 end
 
+test = Rake::TestTask.new do |t|
+  test_files = FileList[ 'tests/**/{tc,ts}*.rb' ]
+
+  # Visual C++ 8.0 specific files must be excluded when working with
+  # another compiler.
+  test_files = test_files.delete_if { |n| /\/vc8/ =~ n } unless
+      /(mxx_ru\/cpp\/toolsets\/){0,1}vc8/ =~ ENV[ 'MXX_RU_CPP_TOOLSET' ]
+
+  # Visual C++ specific files must be excluded when working with
+  # another compiler.
+  test_files = test_files.delete_if { |n| /\/vc/ =~ n } unless
+      /(mxx_ru\/cpp\/toolsets\/){0,1}vc\d/ =~ ENV[ 'MXX_RU_CPP_TOOLSET' ]
+
+  # MSWin specific files must be excluded if not Windows platform.
+  test_files = test_files.delete_if { |n| /mswin/ =~ n } unless 
+      /^mswin/ =~ Config::CONFIG[ 'host_os' ]
+
+  # Unix specific files must be excluded on Windows platform.
+  test_files = test_files.delete_if { |n| /unix/ =~ n } if
+      /^mswin/ =~ Config::CONFIG[ 'host_os' ]
+
+  t.test_files = test_files
+  t.verbose = true
+end
+
 task :default => [ gem.package_dir + "/" + gem.name + "-" + gem.version.version + ".gem" ]
+

data/examples/exe_dll_lib_2/build.rb

@@ -1,7 +1,10 @@
 require 'mxx_ru/cpp'
 
-Mxx_ru::Cpp::composite_target( Mxx_ru::BUILD_ROOT ) {
+MxxRu::Cpp::composite_target( Mxx_ru::BUILD_ROOT ) {
   required_prj( "main/prj.rb" )
 
   global_include_path( "." )
+
+  global_obj_placement(
+    Mxx_ru::Cpp::CustomSubdirObjPlacement.new( 'bin', 'tmp/output' ) )
 }

data/examples/exe_dll_lib_2/inout/prj.rb

@@ -1,6 +1,6 @@
 require 'mxx_ru/cpp'
 
-Mxx_ru::Cpp::dll_target( "inout/prj.rb" ) {
+MxxRu::Cpp::dll_target {
   target( "inout" )
   implib_path( "lib" )
 

data/examples/exe_dll_lib_2/main/prj.rb

@@ -1,6 +1,6 @@
 require 'mxx_ru/cpp'
 
-Mxx_ru::Cpp::exe_target( "main/prj.rb" ) {
+MxxRu::Cpp::exe_target {
   target( "exe_dll_lib" )
 
   required_prj( "inout/prj.rb" )

data/examples/exe_dll_lib_2/say/prj.rb

@@ -1,6 +1,6 @@
 require 'mxx_ru/cpp'
 
-Mxx_ru::Cpp::lib_target( "say/prj.rb" ) {
+Mxx_ru::Cpp::lib_target {
   target_root( "lib" )
   target( "say" )
 

data/lib/mxx_ru/abstract_target.rb

@@ -30,13 +30,13 @@ require 'mxx_ru/ex'
 
 require 'mxx_ru/util'
 
-module Mxx_ru
+module MxxRu
 
   # File name of root project file.
   BUILD_ROOT = "build.rb"
 
   # Target status description.
-  class Target_state
+  class TargetState
     # Target is absent or rebuild is required.
     ABSENT = 0
     # Target was rebuilt.
@@ -51,22 +51,22 @@ module Mxx_ru
     end
 
     # Detect target status.
-    # Target_state object returned.
+    # TargetState object returned.
     #
     # [_name_] Target name.
     # [_depends_] Dependencies list. Array of String.
-    def Target_state.detect( name, depends )
+    def TargetState.detect( name, depends )
 
       state = ABSENT
 
       # In dry-run mode we always return that target is absent.
-      if !Mxx_ru::Util::Mode.instance.is_dry_run
+      if !MxxRu::Util::Mode.instance.is_dry_run
         if FileTest.exists?( name )
           # It's necessary to detect time of target and it's dependencies.
           target_mtime = File.mtime( name )
           if nil != depends.find { |d|
               if !FileTest.exists?( d )
-                raise Mxx_ru::Missing_depend_file_ex.new( d, name )
+                raise MxxRu::MissingDependFileEx.new( d, name )
               end
               depend_mtime = File.mtime( d )
               target_mtime < depend_mtime
@@ -80,10 +80,13 @@ module Mxx_ru
         end
       end
 
-      return Target_state.new( state )
+      return TargetState.new( state )
     end
 
-  end # Class Target_state
+  end # Class TargetState
+
+  # For compatibility with previous versions.
+  Target_state = TargetState
 
   # Map of targets loaded.
   # Key is target alias -- file name with definition of a target.
@@ -93,13 +96,13 @@ module Mxx_ru
   # This target will be used in setup_target function to start building process.
   @@first_target_alias = nil
 
-  def Mxx_ru.try_set_first_target_alias( a_alias )
+  def MxxRu.try_set_first_target_alias( a_alias )
     if nil == @@first_target_alias
       @@first_target_alias = a_alias.clone
     end
   end
 
-  def Mxx_ru.setup_target( target, build_enabled = true )
+  def MxxRu.setup_target( target, build_enabled = true )
     begin
       if !( target_defined_for?( target.prj_alias ) )
         @@defined_targets[ target.prj_alias ] = target;
@@ -109,65 +112,71 @@ module Mxx_ru
         @@first_target_alias == target.prj_alias
         # It is a root project, required to build.
 
-        # If this project is not root project file and root project file exists,
-        # then we will load root project file and start build process after that.
+        # If this project is not root project file and root project file
+        # exists, then we will load root project file and start build process
+        # after that.
         if BUILD_ROOT != target.prj_alias
           if FileTest.exists?( BUILD_ROOT )
             require BUILD_ROOT
           end
         end
 
-        if Mxx_ru::Util::Mode.instance.is_clean
-          target.clean
-        else
-          Mxx_ru::Util::build_call_wrapper( target )
-        end
+        target.clean if MxxRu::Util::Mode.instance.is_clean or
+            MxxRu::Util::Mode.instance.is_rebuild
+
+        target.reset if MxxRu::Util::Mode.instance.is_rebuild
+
+        MxxRu::Util::build_call_wrapper( target ) if
+            !MxxRu::Util::Mode.instance.is_clean
       end
 
       return target
-    rescue Mxx_ru::Ex => ex
+    rescue MxxRu::Ex => ex
       $stderr.print "<<<[#{ex.class.name}]\t#{ex}>>>\n"
       exit( -2 )
     end
   end
 
-  def Mxx_ru.query_target( prj_alias, mandatory )
+  def MxxRu.query_target( prj_alias, mandatory )
     target = @@defined_targets[ prj_alias ]
 
     # If target was required, we already should found it.
     # Build should be stopper otherwise.
     if target.nil? && mandatory
-      raise Target_unknown_ex.new( prj_alias )
+      raise TargetUnknownEx.new( prj_alias )
     end
 
     return target
   end
 
-  def Mxx_ru.target_defined_for?(prj_alias)
+  def MxxRu.target_defined_for?(prj_alias)
     return true if @@defined_targets.has_key?( prj_alias )
     return false
   end
 
   # Base class for all source code generators.
-  class Abstract_generator
+  class AbstractGenerator
     # This method is called to generate source code required.
     # Should be redefined in a child class.
     #
     # [_target_] Target, generator belongs to.
     def build( target )
-      raise Abstract_method_ex.new( "Mxx_ru::Abstract_generator::build" )
+      raise AbstractMethodEx.new( "MxxRu::AbstractGenerator::build" )
     end
 
     # This method is called to cleanup of generated source code files.
     #
     # [_target_] Target, generator belongs to.
     def clean( target )
-      raise Abstract_method_ex.new( "Mxx_ru::Abstract_generator::clean" )
+      raise AbstractMethodEx.new( "MxxRu::AbstractGenerator::clean" )
     end
   end
 
+  # For compatibility with previous versions.
+  Abstract_generator = AbstractGenerator
+
   # Base class for all targets.
-  class Abstract_target
+  class AbstractTarget
     # List of full file names, created during a build of the target.
     # It may be an empty array if target doesn't create any files.
     # For example, if target is a composite or unittest.
@@ -190,7 +199,7 @@ module Mxx_ru
     #   required_prjs( items )
     #   cpp_sources( items )
     #
-    def Abstract_target.define_plural_form_method( singular_method )
+    def AbstractTarget.define_plural_form_method( singular_method )
       class_eval %Q{
         def #{singular_method}s(a)
           a.each { |e| #{singular_method}( e ) }
@@ -204,7 +213,7 @@ module Mxx_ru
       @mxx_required_prjs = Array.new
       @mxx_generators = Array.new
 
-      Mxx_ru.try_set_first_target_alias( a_prj_alias )
+      MxxRu.try_set_first_target_alias( a_prj_alias )
     end
 
     # Add one more file, created during a target build.
@@ -223,11 +232,11 @@ module Mxx_ru
       # If project is not loaded yet, loding it.
       # Then adding created target object to the list ofd subordinated projects.
       # If no target will be created, exception would be thrown.
-      if !Mxx_ru::target_defined_for?( a_prj )
+      if !MxxRu::target_defined_for?( a_prj )
         require a_prj
       end
 
-      target = Mxx_ru::query_target( a_prj, true )
+      target = MxxRu::query_target( a_prj, true )
       @mxx_required_prjs << target
 
       return target
@@ -248,37 +257,43 @@ module Mxx_ru
     end
 
     # Child classes should redefine this method.
-    # Target_state object is returned.
+    # TargetState object is returned.
     def build
-      raise Abstract_method_ex.new( "Abstract_target::build" )
+      raise AbstractMethodEx.new( "AbstractTarget::build" )
     end
 
     # Child classes should redefine this method.
     def clean
-      raise Abstract_method_ex.new( "Abstract_target::clean" )
+      raise AbstractMethodEx.new( "AbstractTarget::clean" )
+    end
+
+    # Child classes should redefine this method.
+    # Base class does not implement it.
+    def reset
     end
 
     # Executing command line given.
     #
     # [a_cmd_lines] Array of String
-    # [a_to_destroy_on_fail] Files required to be cleaned up if any of given command fail.
-    # [brief_desc] Brief description of command (will be shown if --mxx-brief-desc
-    #              specified in command line)
-    def Abstract_target.run( a_cmd_lines, a_to_destroy_on_fail, brief_desc = nil )
+    # [a_to_destroy_on_fail] Files required to be cleaned up if any of given
+    #                        command fail.
+    # [brief_desc] Brief description of command (will be shown if
+    #              --mxx-brief-show specified in command line)
+    def AbstractTarget.run(
+        a_cmd_lines, a_to_destroy_on_fail, brief_desc = nil )
 
-      puts "#{brief_desc.capitalize} ..." \
-          if Mxx_ru::Util::Mode.instance.is_brief_desc and nil != brief_desc
+      MxxRu.show_brief( brief_desc )
 
       a_cmd_lines.each { |c|
           puts "<<< #{c} >>>" \
-              if Mxx_ru::Util::Mode.instance.is_show_cmd
+              if MxxRu::Util::Mode.instance.is_show_cmd
 
           # Do not actually execute in dry-run mode.
-          if !Mxx_ru::Util::Mode.instance.is_dry_run
+          if !MxxRu::Util::Mode.instance.is_dry_run
             if !system( c )
               a_to_destroy_on_fail.each { |d|
-                Mxx_ru::Util::delete_file( d ) }
-              raise Build_ex.new( c, $? )
+                MxxRu::Util::delete_file( d ) }
+              raise BuildEx.new( c, $? )
             end
           end
         }
@@ -286,28 +301,35 @@ module Mxx_ru
 
   protected
     # Build of all projects required for the target.
-    # Returns Mxx_ru::Target_state.
+    # Returns MxxRu::TargetState.
     def build_required_projects
-      state = Mxx_ru::Target_state::EXISTS
+      state = MxxRu::TargetState::EXISTS
       @mxx_required_prjs.each { |p|
-          prj_state = Mxx_ru::Util::build_call_wrapper( p )
-          if Mxx_ru::Target_state::EXISTS != prj_state.state
+          prj_state = MxxRu::Util::build_call_wrapper( p )
+          if MxxRu::TargetState::EXISTS != prj_state.state
             state = prj_state.state
           end
         }
 
-      return Mxx_ru::Target_state.new( state )
+      return MxxRu::TargetState.new( state )
     end
 
     # Cleanup of all projects required for the target.
     # Executed only if dry-run mode is disabled.
     def clean_required_prjs
-      if !Mxx_ru::Util::Mode.instance.is_dry_run
+      if !MxxRu::Util::Mode.instance.is_dry_run
         @mxx_required_prjs.each { |p| p.clean }
       end
     end
 
+    # Reset build status for all projects required for the target.
+    def reset_required_projects
+      @mxx_required_prjs.each { |p| p.reset }
+    end
+
   end
 
-end
+  # For compatibility with previous versions.
+  Abstract_target = AbstractTarget
 
+end

data/lib/mxx_ru/binary_library.rb

@@ -0,0 +1,106 @@
+#--
+# 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'
+
+module MxxRu
+
+# Class for description of binary library required to be linked
+# with binary target.
+#
+# Since 1.3.0
+#
+# On Unix platform static and shared library can be specified to linker with
+# same name. For example to link libA.a or libA.so user must specify '-lA'
+# option. Linker selects appropriate library (static or shared version) by
+# it own rules (on most Linux platform ld first looks for shared version, than
+# for static version; this approach can be overriden by '-static' option for
+# gcc or '-Bstatic' for ld).
+#
+# In some cases user may wants to explicitly specify kind of library. For
+# example, if ld by default searches shared libraries than user can specify
+# sequence '-Bstatic -lA -Bdynamic' for ld (or '-Wl,-Bstatic,-lA,-Bdynamic'
+# for gcc). This forces linker for looking only static version of library.
+#
+# In version 1.3.0 Mxx_ru support for explicit static/shared library selection
+# was added. To implement this support required library description was
+# changed. Instead of storing names of required libraries as String they are
+# stored as BinaryLibrary objects.
+class BinaryLibrary
+  # Identifier for static library type.
+  STATIC = :static
+  # Identifier for shared library type.
+  SHARED = :shared
+  # Identifier for library which type if unknown yet (not explicitly specified).
+  ANY = :any
+
+  # Name of library.
+  attr_reader :name
+  # Type of library (STATIC/SHARED/ANY).
+  attr_reader :type
+
+  def initialize( name, type )
+    raise InvalidValueEx.new( "Unknown BinaryLibrary type: #{type}" ) unless
+        [ STATIC, SHARED, ANY ].member?( type )
+
+    @name = name
+    @type = type
+  end
+
+  def to_s
+    @name
+  end
+
+  def eql?( another )
+    @name.eql?( another.name ) and @type.eql?( another.type )
+  end
+
+  def ==( another )
+    self.eql?( another )
+  end
+
+  def <=>( another )
+    r = @name <=> another.name
+    r = @type <=> another.type if 0 == r
+    r
+  end
+
+end # class BinaryLibrary
+
+# Exception for the case where conflict of BinaryLibrary usage detected.
+#
+# Conflict detected if STATIC and SHARED library with same name specified
+# for one target.
+class BinaryLibraryTypeConflictEx < Ex
+  def initialize( target_name, library_name )
+    super( "Binary library conflict with library '#{library_name}' for " +
+        "target '#{target_name}'" )
+  end
+end
+
+end # module MxxRu

data/lib/mxx_ru/binary_target.rb

@@ -27,13 +27,17 @@
 #++
 
 require 'mxx_ru/abstract_target'
+require 'mxx_ru/binary_library'
 require 'mxx_ru/ex'
 
-# Base class for all targets, which are binary executables, binary shared libraries or
-# binary static libraries.
-module Mxx_ru
+# Base class for all targets, which are binary executables, binary shared
+# libraries or binary static libraries.
+#
+# In version v.1.3 extended by methods lib_path, lib_paths which are
+# user-frendly synonyms for mxx_add_required_lib_path.
+module MxxRu
 
-  class Binary_target < Mxx_ru::Abstract_target
+  class BinaryTarget < MxxRu::AbstractTarget
     def initialize( a_prj_alias )
       super( a_prj_alias )
 
@@ -43,19 +47,59 @@ module Mxx_ru
       # dublicates should be removed.
       @mxx_required_libs_changed = true
       # Folder list, where libraries, encountered in mxx_required_libs, 
-      # should be searched for
+      # should be searched for. Also contain paths specified by
+      # lib_path, lib_paths methods.
       @mxx_required_lib_paths = Array.new
       # Attribute showing that before return from mxx_required_lib_paths
       # dublicates should be removed.
       @mxx_required_lib_paths_changed = true
     end
 
+    # Add the library required.
+    #
+    # Type of library must be detect implicitly.
+    #
+    # 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(
+          BinaryLibrary.new( a_library, BinaryLibrary::ANY ) )
+      if a_path
+        mxx_add_required_lib_path( a_path )
+      end
+    end
+
+    # Add static 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_static( a_library, a_path = nil )
+      mxx_add_required_lib(
+          BinaryLibrary.new( a_library, BinaryLibrary::STATIC ) )
+      if a_path
+        mxx_add_required_lib_path( a_path )
+      end
+    end
+
+    # Add shared 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_shared( a_library, a_path = nil )
+      mxx_add_required_lib(
+          BinaryLibrary.new( a_library, BinaryLibrary::SHARED ) )
+      if a_path
+        mxx_add_required_lib_path( a_path )
+      end
+    end
+
     # Get all libraries list, which are required to be linked to for
     # correct usage of given target.
     # Returns array of strings.
     def mxx_required_libs
       if @mxx_required_libs_changed
         @mxx_required_libs.flatten!
+        BinaryTarget.check_libraries_types( prj_alias, @mxx_required_libs )
         @mxx_required_libs_changed = false
       end
       return @mxx_required_libs
@@ -63,12 +107,18 @@ module Mxx_ru
 
     # Add library to list of requirements.
     def mxx_add_required_lib( a_lib )
+      a_lib = BinaryLibrary.new( a_lib, BinaryLibrary::ANY ) if
+          a_lib.kind_of?( String )
+
       @mxx_required_libs << a_lib
       @mxx_required_libs_changed = true
     end
 
-    # Get list of all paths to libraries, which should be used to search libraries,
-    # returned by mxx_required_libs method.
+    # Plural form of mxx_add_required_lib.
+    define_plural_form_method :mxx_add_required_lib
+
+    # Get list of all paths to libraries, which should be used to search
+    # libraries, returned by mxx_required_libs method.
     # Returns array of strings.
     def mxx_required_lib_paths
       if @mxx_required_lib_paths_changed
@@ -84,6 +134,40 @@ module Mxx_ru
       @mxx_required_lib_paths_changed = true
     end
 
+    # Plural form of mxx_add_required_lib_path.
+    define_plural_form_method :mxx_add_required_lib_path
+
+    alias_method :lib_path, :mxx_add_required_lib_path
+
+    # Plural form of lib_path.
+    define_plural_form_method :lib_path
+
+    # Checks types of libraries. Should not exists two instance of
+    # same library with STATIC and SHARED types at one time.
+    #
+    # Raises BinaryLibraryTypeConflictEx if conflict detected.
+    def BinaryTarget.check_libraries_types( prj_alias, libs )
+      if libs.size
+        names_and_types = Hash.new( BinaryLibrary::ANY )
+        libs.each { |l|
+          k = names_and_types[ l.name ]
+          if BinaryLibrary::ANY != l.type
+          
+            if BinaryLibrary::ANY != k
+              raise BinaryLibraryTypeConflictEx.new( prj_alias, l.name ) if
+                  k != l.type
+            else
+              names_and_types[ l.name ] = l.type
+            end
+
+          end
+        }
+      end
+    end
+
   end
 
+  # For compatilibily with previous versions.
+  Binary_target = BinaryTarget
+
 end