Mxx_ru 1.1.0

data/lib/mxx_ru/makestyle_generator.rb

@@ -0,0 +1,138 @@
+#--
+# 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/abstract_target.rb'
+
+module Mxx_ru
+
+# A Generator, which allows to define simple make rules in a project.
+#
+# For example, if it's needed to get from ddl file two other files, 
+# cpp and hpp, using typegen program, it should be done like that:
+#  generator( Mxx_ru::Makestyle_generator.new(
+#    [ "myfile.cpp", "myfile.hpp" ],
+#    [ "myfile.ddl" ],
+#    [ "typegen --from myfile.ddl --cpp myfile.cpp --header myfile.hpp" ] ) )
+#
+# NOTE: For C++ projects current value of sources_root isn't taken into account.
+class Makestyle_generator < Abstract_generator
+  # File names list, which should be built by given generator.
+  attr_reader :target_files
+
+  # File names list, result files depends from.
+  attr_reader :dependencies
+
+  # Command list, which should be ran in a sequence to get result files.
+  attr_reader :build_cmds
+
+  # Command list, which should be ran in a sequence to remove result files.
+  #
+  # If this list is empty, removal of result files would occur on clean operation.
+  attr_reader :clean_cmds
+
+  # Constructor.
+  #
+  # [_a_target_files_] Result files list.
+  # [_a_dependencies_] Dependencies list.
+  # [_a_build_cmds_] Command list, which should be ran in a sequence to get result files.
+  # [_a_clean_cmds_] Command list, which should be ran in a sequence to remove result files.
+  #
+  # NOTE: Single values may be defined as a strings instead of vectors. For example:
+  #  Mxx_ru::Makestyle_generator.new( "myfile.cpp", "myfile.ddl",
+  #    [ "typegen --from myfile.ddl --to myfile.cpp" ] )
+  # It's the same as:
+  #  Mxx_ru::Makestyle_generator.new( [ "myfile.cpp" ], [ "myfile.ddl" ],
+  #    "typegen --from myfile.ddl --to myfile.cpp" )
+  #
+  def initialize(
+    a_target_files,
+    a_dependencies,
+    a_build_cmds,
+    a_clean_cmds = Array.new )
+
+    @target_files = make_array( a_target_files )
+    @dependencies = make_array( a_dependencies )
+    @build_cmds = make_array( a_build_cmds )
+    @clean_cmds = make_array( a_clean_cmds )
+  end
+
+  # Perform the build of result files.
+  #
+  # NOTE: _target_ argument is ignored.
+  def build( target )
+    need_build = false
+
+    # Checking all result files. If one of them is obsolete, performing rebuild.
+    index = 0
+    while !need_build && index != @target_files.size
+      if Target_state::EXISTS != Target_state.detect(
+        @target_files[ index ], @dependencies ).state
+        need_build = true
+      else
+        index += 1
+      end
+    end
+
+    if need_build
+      # It's required to run all commands to build target.
+      Abstract_target.run( @build_cmds, [] )
+    end
+  end
+
+  # Perform the cleanup of result files.
+  #
+  # NOTE: _target_ argument is ignored.
+  def clean( target )
+    # If cleanup commands weren't set, deleting result files.
+    # Otherwise, it's required to run all commands in a sequence,
+    # ignoring return codes.
+    if 0 != @clean_cmds.size
+      @clean_cmds.each do |c|
+        system( c )
+      end
+    else
+      @target_files.each do |f|
+        Util.delete_file( f )
+      end
+    end
+  end
+
+protected
+  # Conversion of single object into a vector, which contains that object.
+  # If source object is a vector, it's returned without any operations on it.
+  def make_array( a_object )
+    if a_object.instance_of? Array
+      return a_object
+    end
+
+    return [ a_object ]
+  end
+end
+
+end
+

data/lib/mxx_ru/textfile_unittest.rb

@@ -0,0 +1,284 @@
+#--
+# 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/abstract_target'
+
+module Mxx_ru
+
+# The class of a target, which is binary unit-test application, which create
+# one or many text files.
+# Given target performs a build of application, and then runs it and compares results
+# with files which contains correct results.
+#
+# The basic idea consists in the presence of project file, which controls the build
+# of unit-test application. In that project file, target object is created, inherited
+# from Mxx_ru::Binary_target.
+# To start unit-test it's necessary to create one more file, where target object of 
+# Mxx_ru::Textfile_unittest_target class is created. 
+# For example:
+#
+# Unit-test application build file:
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Cpp::Exe_target.new( "test/pack/prj.rb" ) {
+#      ...
+#    }
+#  )
+#
+# File to run unit-test:
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Textfile_unittest_target.new( 
+#      "test/pack/pack.ut.rb",
+#      "test/pack/prj.rb" ) {
+# 
+#      launch( "--loops 16 --out test/pack/out/16.txt",
+#        [ pair( "test/pack/out/16.txt",
+#            "test/pack/out/etalon/16.txt" ) ] )
+# 
+#      launch( "--loops 32 --out test/pack/out/32.txt",
+#        [ pair( "test/pack/out/32.txt",
+#            "test/pack/out/etalon/32.txt" ) ] )
+#    }
+#  )
+#
+# File which is using that unit-test.
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Cpp::Composite_target( Mxx_ru::BUILD_ROOT ) {
+#      required_prj( "some/project/prj.rb" )
+#      required_prj( "test/pack/prj.ut.rb" )
+#    }
+#  )
+#
+class Textfile_unittest_target < Abstract_target
+
+  # Exception, thrown if one subordinated project generated more
+  # than one result name.
+  class Must_be_one_target_name_ex < Ex
+    # [_a_names_] Names generated.
+    def initialize( a_names )
+      super( "Only one name expected in [#{a_names.join(';')}]" )
+    end
+  end
+
+  # Exception, thrown if files are not equal.
+  class File_mismatch_ex < Build_ex
+    # [_a_cmdline_] Command string of test application.
+    # [_a_produced_] Name of file generated.
+    # [_a_etalon_] Name of file containing correct results.
+    # [_a_line_num_] String number where first mismatch was detected.
+    # [_a_produced_line_] String of generated file. Nil if EOF is reached.
+    # [_a_etalon_line_] String of correct file. Nil if EOF is reached.
+    def initialize( a_cmdline,
+      a_produced, a_etalon,
+      a_line_num,
+      a_produced_line, a_etalon_line )
+      a_produced_line = "<EOF>" if !a_produced_line
+      a_etalon_line = "<EOF>" if !a_etalon_line
+
+      super( a_cmdline, "Mismatch found in line #{a_line_num}. " +
+        "Line in '#{a_produced}' is '#{a_produced_line}'. " +
+        "Line in '#{a_etalon}' is '#{a_etalon_line}'" )
+    end
+  end
+
+  # Description of single pair of values compared.
+  class Pair
+    # Name of file generated.
+    attr_reader :produced
+    # Name of correct file.
+    attr_reader :etalon
+
+    # Constructor.
+    def initialize( a_produced, a_etalon )
+      @produced = a_produced
+      @etalon = a_etalon
+    end
+  end
+
+  # A single run of test application description.
+  class Launch
+    # Command line parameters.
+    # Empty string if no parameters.
+    attr_reader :cmdline
+    # Files list to compare after application executed.
+    # Should be Array of Pair.
+    attr_reader :pairs
+
+    # Constructor.
+    def initialize( a_cmdline, a_pairs )
+      @cmdline = a_cmdline
+      @pairs = a_pairs
+    end
+  end
+
+  # Target, responsible for build of unit-test application.
+  attr_reader :mxx_target_project
+  # True if build method was already executed.
+  attr_reader :mxx_build_state
+  # Description of test application runs.
+  # Array of Launch.
+  attr_reader :mxx_launches
+
+  # Constructor.
+  #
+  # [_a_alias_] Self alias.
+  # [_a_target_project_] Project, responsible for build of unit-test application.
+  def initialize( a_alias, a_target_project, &block )
+    super( a_alias )
+
+    @mxx_build_state = nil
+
+    @mxx_target_project = required_prj( a_target_project )
+
+    @mxx_launches = Array.new
+
+    instance_eval( &block ) if block
+  end
+
+  # Create description of file pairs to compare.
+  #
+  # [_a_produced_] Name of generated file.
+  # [_a_etalon_] Name of correct file.
+  def pair( a_produced, a_etalon )
+    return Pair.new( a_produced, a_etalon )
+  end
+
+  # Add description of sequental run of test application.
+  #
+  # [_a_cmdline_] Command line parameters. May be empty string of nil 
+  #               if no parameters required.
+  # [_a_pairs_] A list of pairs of file names to compare. Should be Array of
+  #             values returned by pair() method.
+  #
+  # Comparation will be performed in order they are defined in _a_pairs_.
+  # Comparation is interrupted on first mismatch.
+  def launch( a_cmdline, a_pairs )
+    a_cmdline = "" if !a_cmdline
+    @mxx_launches << Launch.new( a_cmdline, a_pairs )
+  end
+
+  # Build subordinated project and run it.
+  #
+  # If unit-test application returns exit code not equal to 0, exception is thrown.
+  def build
+    if !@mxx_build_state
+      @mxx_target_project.build
+
+      # Determining the name of application, which should be run.
+      full_names = @mxx_target_project.mxx_full_targets_names
+      if 1 != full_names.size
+        raise Must_be_one_target_name_ex.new( full_names )
+      end
+
+      # No execution of commands in dry-run mode.
+      if !Mxx_ru::Util::Mode.instance.is_dry_run
+        puts "running unit test: #{full_names[0]}..."
+        do_all_launches( full_names[ 0 ] )
+      end
+
+      @mxx_build_state = Target_state.new( Target_state::REBUILT )
+    end
+
+    return @mxx_build_state
+  end
+
+  # Cleanup the project.
+  #
+  # Executes clean method from subordinated project.
+  # Deletes all files, defined as result files of unit-test application.
+  def clean
+    @mxx_target_project.clean
+
+    @mxx_launches.each { |launch|
+      launch.pairs.each { |pair|
+        Util.delete_file( pair.produced )
+      }
+    }
+  end
+
+protected
+  # Perform all defined runs of test application.
+  # This method should not be executed in dry-run mode.
+  def do_all_launches( a_file_to_exec )
+    # On mswin32 platform if file name is in unix format and
+    # redirection of input/output is set, some problems with
+    # execution would occur.
+    native_file_name = Util::native_pathname( a_file_to_exec )
+
+    @mxx_launches.each { |launch|
+      cmdline = native_file_name + " " + launch.cmdline 
+      puts "\tlaunching '#{cmdline}'..."
+      if !system( cmdline )
+        puts "\n\nunit test '#{cmdline}' FAILED! #{$?}"
+        raise Build_ex.new( cmdline, $? )
+      end
+
+      # Execution of application was successful.
+      # Let's compare files.
+      launch.pairs.each { |pair|
+        puts "\t\tcomparing '#{pair.produced}' and '#{pair.etalon}'"
+        do_file_compare( cmdline, pair.produced, pair.etalon )
+      }
+    }
+  end
+
+  # Perform comparation of two files.
+  # If they are not identical, File_mismatch_ex exception is thrown.
+  # If some system exceptions would occur (absence of file for example),
+  # Build_ex ewxception will be thrown.
+  def do_file_compare( a_cmdline, a_produced, a_etalon )
+    begin
+      produced_file = File.new( a_produced, "r" )
+      etalon_file = File.new( a_etalon, "r" )
+
+      line_num = 1
+      while true
+        l1 = produced_file.gets
+        l2 = etalon_file.gets
+
+        if l1 != l2
+          raise File_mismatch_ex.new( a_cmdline,
+            a_produced, a_etalon, line_num,
+            l1, l2 )
+        else
+          line_num += 1
+          if !l1
+            break
+          end
+        end
+      end
+
+    rescue Exception => ex
+      raise Build_ex.new( a_cmdline,
+        "Error during comparing files " +
+        "'#{a_produced}', '#{a_etalon}': #{ex}" )
+    end
+  end
+end
+
+end # module Mxx_ru

data/lib/mxx_ru/util.rb

@@ -0,0 +1,258 @@
+#--
+# 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 'rbconfig'
+require 'singleton'
+
+module Mxx_ru
+
+  module Util
+    # Regular expression to divide file name and it's extension.
+    MATCH_FILE_EXT_REGEX = Regexp.new( "^(.+)\\.([^\\./]+)$" )
+
+    # Ruby command line parameters, handled by Mxx_ru.
+    MXXARG_CLEAN = "--mxx-clean"
+    MXXARG_SHOW_CMD = "--mxx-show-cmd"
+    MXXARG_KEEP_TMPS = "--mxx-keep-tmps"
+    MXXARG_SHOW_TMPS = "--mxx-show-tmps"
+    MXXARG_DRY_RUN = "--mxx-dry-run"
+
+    # OS name, script is run on.
+    @@host_os = nil
+
+    # Class, which detects Mxx_ru current mode.
+    class Mode
+      include Singleton
+
+      attr_reader :is_clean
+      attr_reader :is_show_cmd
+      attr_reader :is_keep_tmps
+      attr_reader :is_show_tmps
+
+      # Constructor checks for special arguments in command line.
+      def initialize
+        @is_clean = ARGV.include?( MXXARG_CLEAN )
+        @is_show_cmd = ARGV.include?( MXXARG_SHOW_CMD )
+        @is_keep_tmps = ARGV.include?( MXXARG_KEEP_TMPS )
+        @is_show_tmps = ARGV.include?( MXXARG_SHOW_TMPS )
+        @is_dry_run = ARGV.include?( MXXARG_DRY_RUN )
+        @is_manual_dry_run = false
+      end
+
+      # Is dry-run mode set?
+      # Dry-run mode is set, if --mxx-dry-run command line parameter is set,
+      # or if it's manually set.
+      def is_dry_run
+        return ( @is_dry_run || @is_manual_dry_run )
+      end
+
+      # On/Off manual dry-run mode.
+      # In some cases it's efficient to turn it on for some time.
+      # For example, it's used to handle subprojects with --mxx-cpp-1 option set.
+      def manual_dry_run( a_is_manual_dry_run )
+        @is_manual_dry_run = a_is_manual_dry_run
+      end
+
+    end
+
+    # Returns file name without last extension.
+    def Util.remove_file_ext( a_name )
+      match_result = MATCH_FILE_EXT_REGEX.match( a_name )
+      if nil == match_result
+        # No extension was present.
+        return String.new( a_name )
+      end
+
+      return match_result[ 1 ]
+    end
+
+    # Returns filename with new last extension.
+    def Util.change_file_ext( name, ext )
+      remove_file_ext( name ) + ext
+    end
+
+    # Deleting file name without exception.
+    def Util.delete_file( a_name )
+      if FileTest.exists?( a_name )
+        File.delete( a_name )
+      end
+    end
+
+    # Class, responsible for creation and removal of temporary files.
+    # Temporary files are created in current folder.
+    # Temporary files are removed before application is exitted,
+    # if --mxx-keep-tmps option isn't set.
+    class Tmp_files
+      include Singleton
+
+      # Temporary file names.
+      @@names = Array.new
+
+      def initialize
+        if !Mode.instance.is_keep_tmps
+          ObjectSpace.define_finalizer( self, Proc.new{ Tmp_files.finalizer } )
+        end
+
+        # Counter to ensure unique file names.
+        @current = 0
+
+        # Indicies stack in @@names for push and pop methods.
+        @index_stack = Array.new
+      end
+
+      def Tmp_files.finalizer
+        @@names.each { |d|
+            begin
+              File.delete( d )
+            rescue Exception => e
+              puts e
+            end
+          }
+      end
+
+      # Temporary file creation.
+      # The string given is stored to the temporary file.
+      # The name of temporary file is returned.
+      #
+      # [_a_content_] Should be an object of String type.
+      def create( a_content )
+
+        current = (@current += 1)
+        file_name = "tmpmxx_ru.#{$$}.#{current}"
+        file = File.new( file_name, "w" )
+        @@names << file_name
+        file << a_content
+        file.close
+
+        if Mode.instance.is_show_tmps
+          puts "<<<[#{file_name}]\t #{a_content}>>>"
+        end
+
+        return file_name
+      end
+
+      # Storing current vector size to the indicies stack.
+      def push()
+        if !Mode.instance.is_keep_tmps
+          @index_stack.push( @@names.size() )
+        end
+      end
+
+      # Removing all files, which are stored in a file names vector
+      # starting from first element from @index_stack position.
+      def pop()
+        if !Mode.instance.is_keep_tmps
+          index = @index_stack.pop
+          while @@names.size > index
+            file_to_delete = @@names.pop
+            Mxx_ru::Util::delete_file( file_to_delete )
+          end
+        end
+      end
+
+    end # class Tmp_files
+
+    # Auxiliary function for correct execution of build method of target object.
+    # Before execution Tmp_files.push is executed, and after execution of build method
+    # Tmp_files.pop is called. This way we are removing temporary files
+    # created during a compilation of given target.
+    def Util.build_call_wrapper( a_target )
+      begin
+        Tmp_files.instance.push
+        state = a_target.build
+        return state
+      ensure
+        Tmp_files.instance.pop
+      end
+    end
+
+    # Create folder if it isn't exist.
+    #
+    # All chain of names is tracked. For example, if we trying to create
+    # output/release/lib folder, and only output is exists, then release/lib folders
+    # are created.
+    def Util.create_dir( a_name )
+      # Dividing the chain.
+      chain = Array.new
+      chain.unshift( a_name )
+
+      to_split = a_name.clone
+      while to_split != "."
+        r = File.split( to_split )
+        chain.unshift( to_split = r[ 0 ] )
+      end
+
+      chain.each { |d|
+        if !FileTest.exists?( d )
+          Dir.mkdir( d )
+        end
+      }
+    end
+
+    # To ensure folder is exist.
+    #
+    # If dry-run mode wasn't set, checking for existance.
+    # If it isn't exists, trying to create it.
+    #
+    # In a dry-run mode Mxx_ru always assumes folder is exists, even if it isn't.
+    def Util.ensure_path_exists( a_path_name )
+      if !Mxx_ru::Util::Mode.instance.is_dry_run
+        if !FileTest.exists?( a_path_name )
+          Mxx_ru::Util.create_dir( a_path_name )
+        end
+      end
+    end
+
+    # Get OS name where script is exeuted.
+    def Util.host_os
+      if !@@host_os
+        @@host_os = Config::CONFIG[ "host_os" ]
+      end
+
+      return @@host_os
+    end
+
+    # Transform separators in file names to correct ones on the given platform.
+    #
+    # For example on mswin32 we change "/" to "\".
+    #
+    # [_a_pathname_] Path to the file in unix style.
+    #
+    # *IMPORTANT! In current version only mswin32 platform is tracked!*
+    def Util.native_pathname( a_pathname )
+      if "mswin32" == Util::host_os
+        return a_pathname.gsub( "/", "\\" )
+      end
+
+      return a_pathname
+    end
+
+  end # module Util
+
+end # module Mxx_ru
+