Mxx_ru 1.1.0

data/lib/mxx_ru/cpp/obj_placement.rb

@@ -0,0 +1,321 @@
+#--
+# 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  Mxx_ru
+
+  module Cpp
+
+    # Base class for a folder name generator.
+    # Results of compilation and linking would be located in that folder.
+    class Obj_placement
+      # Method, that returns the name of a folder, object file would be located in.
+      #
+      # [_source_path_name_] Folder name, where source file located is.
+      # [_toolset_] Current toolset.
+      # [_target_]  Current target.
+      def get_obj(
+        source_path_name,
+        toolset,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Obj_placement::get_obj" )
+      end
+
+      # Method, that returns the name of a folder, 
+      # compiled mswin-resource file would be located in.
+      #
+      # [_source_path_name_] Folder name, where source file located is.
+      # [_toolset_] Current toolset.
+      # [_target_]  Current target.
+      def get_mswin_res(
+        source_path_name,
+        toolset,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Obj_placement::get_mswin_res" )
+      end
+
+      # Method, that returns the name of a folder, 
+      # static library file would be located in.
+      #
+      # [_source_path_name_] Folder name, where source file located is.
+      # [_toolset_] Current toolset.
+      # [_target_]  Current target.
+      def get_lib(
+        source_path_name,
+        toolset,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Obj_placement::get_lib" )
+      end
+
+      # Method, that returns the name of a folder, 
+      # shared library file would be located in.
+      #
+      # [_source_path_name_] Folder name, where source file located is.
+      # [_toolset_] Current toolset.
+      # [_target_]  Current target.
+      def get_dll(
+        source_path_name,
+        toolset,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Obj_placement::get_dll" )
+      end
+
+      # Method, that returns the name of a folder, 
+      # executable file would be located in.
+      #
+      # [_source_path_name_] Folder name, where source file located is.
+      # [_toolset_] Current toolset.
+      # [_target_]  Current target.
+      def get_exe(
+        source_path_name,
+        toolset,
+        target )
+
+        raise Abstract_method_ex.new(
+          "Mxx_ru::Cpp::Obj_placement::get_exe" )
+      end
+    end # class Obj_placement
+
+    # The generator of folder name for an object file, 
+    # using a subfolder with a fixed name in a folder with source file.
+    # Folder for lib, dll and exe files are not modified.
+    # get_obj and get_mswin_res methods are checking if result folder exists.
+    # If it's not, they are trying to create it.
+    class Source_subdir_obj_placement < Obj_placement
+      attr  :subdir
+
+      def initialize( a_subdir = "o" )
+        # The name of subfolder, object files should be located in.
+        @subdir = a_subdir.clone
+      end
+
+      def get_obj(
+        source_path_name,
+        toolset,
+        target )
+
+        result = File.join( source_path_name, subdir )
+        Mxx_ru::Util.ensure_path_exists( result )
+
+        return result
+      end
+
+      def get_mswin_res(
+        source_path_name,
+        toolset,
+        target )
+
+        result = File.join( source_path_name, subdir )
+        Mxx_ru::Util.ensure_path_exists( result )
+
+        return result
+      end
+
+      def get_lib(
+        source_path_name,
+        toolset,
+        target )
+
+        return String.new( source_path_name )
+      end
+
+      def get_dll(
+        source_path_name,
+        toolset,
+        target )
+
+        return String.new( source_path_name )
+      end
+
+      def get_exe(
+        source_path_name,
+        toolset,
+        target )
+
+        return String.new( source_path_name )
+      end
+
+    end # class Source_subdir_obj_placement
+
+    # The generator of folder name for compilation results,
+    # building a hierarchy of subfolders in a special folder,
+    # which name is choosen based on runtime mode.
+    #
+    # For example, let src/lib/l.cpp and src/main/m.cpp files would be
+    # the sources of lib/l.lib library and m.exe application.
+    # If project is compiled in RELEASE mode, then following files
+    # would be created: release/src/lib/l.obj, release/src/main/m.obj,
+    # release/lib/l.lib and release/m.exe.
+    # Thus the presence of subfolders required will be supervised
+    # (for example, release/src/lib, release/src/main,...).
+    # If some subfolder doesn't exist, it will be created.
+    #
+    # An example of usage:
+    #
+    #  class  Build < Mxx_ru::Cpp::Composite_target
+    #    def initialize( a_alias = Mxx_ru::BUILD_ROOT )
+    #      global_obj_placement(
+    #        Mxx_ru::Cpp::Runtime_subdir_obj_placement.new(
+    #          "output" ) )
+    #
+    #      required_prj( "src/lib/prj.rb" )
+    #      required_prj( "src/main/prj.rb" )
+    #    end
+    #  end
+    #
+    class Runtime_subdir_obj_placement < Obj_placement
+      # Folder name, where subfolders for exact runtime-modes 
+      # will be created.
+      attr_reader :root_dir
+      # A name of subfolder, which will ve created in a root_dir
+      # for Mxx_ru::Cpp::RUNTIME_DEBUG mode.
+      attr_reader :debug_subdir
+      # A name of subfolder, which will ve created in a root_dir
+      # for Mxx_ru::Cpp::RUNTIME_DEFAULT mode.
+      attr_reader :default_subdir
+      # A name of subfolder, which will ve created in a root_dir
+      # for Mxx_ru::Cpp::RUNTIME_RELEASE mode.
+      attr_reader :release_subdir
+
+      # a_root_dir  A folder, where subfolders for exact runtime-modes
+      # will be created. If contains nil, subfolders are created in
+      # current folder.
+      #
+      # [_a_debug_subdir_] Subfolder name for Mxx_ru::Cpp::RUNTIME_DEBUG mode.
+      # [_a_default_subdir_] Subfolder name for Mxx_ru::Cpp::RUNTIME_DEFAULT mode.
+      # [_a_release_subdir_] Subfolder name for Mxx_ru::Cpp::RUNTIME_RELEASE mode.
+      def initialize(
+        a_root_dir = nil,
+        a_debug_subdir = "debug",
+        a_default_subdir = "default",
+        a_release_subdir = "release" )
+
+        if a_root_dir
+          @root_dir = a_root_dir
+        else
+          @root_dir = "./"
+        end
+
+        @debug_subdir = a_debug_subdir
+        @default_subdir = a_default_subdir
+        @release_subdir = a_release_subdir
+      end
+
+      # It's the only method running something.
+      def get_obj(
+        source_path_name,
+        toolset,
+        target )
+
+        if source_path_name &&
+          "" != source_path_name &&
+          "." != source_path_name
+          result = File.join( @root_dir, runtime_mode_path( target ),
+            source_path_name )
+        else
+          result = File.join( @root_dir, runtime_mode_path( target ) )
+        end
+
+        Mxx_ru::Util.ensure_path_exists( result )
+
+        return result
+      end
+
+      # Returns result of get_obj method.
+      def get_mswin_res(
+        source_path_name,
+        toolset,
+        target )
+
+        return get_obj( source_path_name, toolset, target )
+      end
+
+      # Returns result of get_obj method.
+      def get_lib(
+        source_path_name,
+        toolset,
+        target )
+
+        return get_obj( source_path_name, toolset, target )
+      end
+
+      # Returns result of get_obj method.
+      def get_dll(
+        source_path_name,
+        toolset,
+        target )
+
+        return get_obj( source_path_name, toolset, target )
+      end
+
+      # Returns result of get_obj method.
+      def get_exe(
+        source_path_name,
+        toolset,
+        target )
+
+        return get_obj( source_path_name, toolset, target )
+      end
+
+    protected
+      # Returns folder name, which is used for target's runtime mode.
+      #
+      # [_a_target_] Target, actions are performed for.
+      def runtime_mode_path( a_target )
+        case a_target.mxx_runtime_mode
+          when Mxx_ru::Cpp::RUNTIME_DEBUG
+            return @debug_subdir
+
+          when Mxx_ru::Cpp::RUNTIME_RELEASE
+            return @release_subdir
+
+          else
+            return @default_subdir
+        end
+      end
+
+    end # class Runtime_subdir_obj_placement
+
+    # Creation of obj_placement object, which should be used by default.
+    def Cpp.default_obj_placement
+      return Source_subdir_obj_placement.new
+    end
+
+  end # module Cpp
+
+end # module Mxx_ru
+

data/lib/mxx_ru/cpp/qt.rb

@@ -0,0 +1,333 @@
+#--
+# 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/cpp'
+
+module Mxx_ru
+module Cpp
+
+  # Files generator for Qt class.
+  #
+  # Main features:
+  #
+  # - building of moc-files using moc tool.
+  #   Generation from source and header files is supported.
+  # - building source files from ui-files using uic-compiler.
+  #   For all files generated this way moc tool executed automatically.
+  #
+  # Generated source files automatically added into
+  # cpp_source list of target.
+  #
+  # Local list defines is supported.
+  #
+  # If only pointer to the target passed into contructor,
+  # default list of defines is used. If it's required to change
+  # default list, new list should be passed through a second argument:
+  #
+  #  generator( Mxx_ru::Cpp::Qt_gen.new( self, [ "QT_THREAD_SUPPORT" ] ) )
+  #
+  class Qt_gen < Mxx_ru::Abstract_generator
+    # Default list of defines.
+    # QT_DLL, QT_THREAD_SUPPORT
+    DEFAULT_DEFINES = [ "QT_DLL", "QT_THREAD_SUPPORT" ]
+
+    # moc tool executable
+    # Default: moc
+    attr_accessor :moc_name 
+
+    # uic tool executable
+    # Default: uic.
+    attr_accessor :uic_name
+
+    # File extension for source files generated.
+    # Used in both moc and uic tools.
+    # Default: .cpp
+    attr_accessor :cpp_ext
+
+    # File extension for header files generated.
+    # Used in uic tool.
+    # Default: .hpp
+    attr_accessor :hpp_ext
+
+    # File extension for moc files generated.
+    # Used in moc tool.
+    # Default: .moc
+    attr_accessor :moc_ext
+
+    # Subfolder name where moc generated files would be located.
+    # If nil, generated files would be in the same folder
+    # where source files were.
+    # Default: nil
+    attr_accessor :moc_result_subdir
+
+    # Files list for generating moc files from header files.
+    #
+    # More exact: a.hpp -> moc_a.cpp. moc_a.cpp file is added
+    # to cpp_source list of a target.
+    attr_reader :qt_h2moc_files
+
+    # Files list for generating moc files from source files.
+    #
+    # More exact: a.cpp -> a.moc.
+    attr_reader :qt_cpp2moc_files
+
+    # Files list for generating hpp, cpp and moc files from ui files.
+    #
+    # More exact: a.ui -> a.hpp, a.cpp, moc_a.cpp. 
+    # a.cpp, moc_a.cpp files are added to cpp_source of a target.
+    attr_reader :qt_ui_files
+
+    # Target, generator is created for.
+    attr  :target
+
+    # Constructor.
+    def initialize( a_target, a_defines = DEFAULT_DEFINES )
+      @moc_name = "moc"
+      @uic_name = "uic"
+      @cpp_ext = ".cpp"
+      @hpp_ext = ".hpp"
+      @moc_ext = ".moc"
+      @moc_result_subdir = nil
+
+      @qt_h2moc_files = Array.new
+      @qt_cpp2moc_files = Array.new
+      @qt_ui_files = Array.new
+
+      defines_to_set = a_defines.flatten
+      defines_to_set.each { |d| a_target.define( d ) }
+
+      @target = a_target
+    end
+
+    # Add a file for hpp to moc generation.
+    def h2moc( a_file )
+      @qt_h2moc_files << @target.create_full_src_file_name( a_file )
+    end
+
+    # Add a file for cpp to moc generation.
+    def cpp2moc( a_file )
+      @qt_cpp2moc_files << @target.create_full_src_file_name( a_file )
+    end
+
+    # Add a file for ui to hpp, cpp and moc generation.
+    def ui( a_file )
+      @qt_ui_files << @target.create_full_src_file_name( a_file )
+    end
+
+    # Perform files generation.
+    def build( a_target )
+      build_from_ui( a_target )
+      build_from_h( a_target )
+      build_from_cpp( a_target )
+    end
+
+    # Perform generated files cleanup.
+    def clean( a_target )
+      clean_from_ui( a_target )
+      clean_from_h( a_target )
+      clean_from_cpp( a_target )
+    end
+
+  protected
+
+    # Perform generation from ui-files.
+    def build_from_ui( a_target )
+      @qt_ui_files.each { |ui|
+        files_from_ui = names_from_ui( ui, a_target )
+
+        # Full file path detection.
+        header_file = files_from_ui[ 0 ]
+        cpp_file = files_from_ui[ 1 ]
+
+        @qt_h2moc_files << header_file 
+        add_cpp_source( a_target, cpp_file )
+
+        # Checking what files are changed and running generation
+        # from them if necessary.
+        if Target_state::EXISTS != Target_state.detect(
+          header_file, [ ui ] ).state
+          Mxx_ru::Abstract_target::run(
+            [ "#{@uic_name} -o #{header_file} #{ui}" ],
+            [ header_file ] )
+        end
+        if Target_state::EXISTS != Target_state.detect(
+          cpp_file, [ ui, header_file ] ).state
+          Mxx_ru::Abstract_target::run(
+            [ "#{@uic_name} -i #{header_file} " +
+              "-o #{cpp_file} #{ui}" ],
+            [ cpp_file ] )
+        end
+      }
+    end
+
+    # Perform cleanup of files, generated from ui files.
+    def clean_from_ui( a_target )
+      @qt_ui_files.each { |ui|
+        files_from_ui = names_from_ui( ui, a_target )
+
+        files_from_ui.each { |f| Mxx_ru::Util::delete_file( f ) }
+
+        # To remove object files.
+        @qt_h2moc_files << files_from_ui[ 0 ]
+        add_cpp_source( a_target, files_from_ui[ 1 ] )
+      }
+    end
+
+    # Getting file names, generated by uic tool.
+    #
+    # Returns two elements array. First element -- hpp file name.
+    # Second element -- cpp file name.
+    def names_from_ui( a_ui_file, a_target )
+      full_ui_name = Mxx_ru::Util::remove_file_ext( a_ui_file )
+      result = [
+        full_ui_name + @hpp_ext,
+        full_ui_name + @cpp_ext
+      ]
+
+      return result
+    end
+
+    # Perform generation from hpp file using moc tool.
+    def build_from_h( a_target )
+      @qt_h2moc_files.each { |h|
+        moc = moc_from_h( h, a_target )
+
+        moc_full = moc
+        header_full = h
+
+        if Target_state::EXISTS != Target_state.detect(
+          moc_full, [ header_full ] ).state
+          Mxx_ru::Abstract_target::run(
+            [ "#{moc_name} -o #{moc_full} " + 
+              "#{header_full}" ],
+            [ moc_full ] )
+        end
+
+        add_cpp_source( a_target, moc )
+      }
+    end
+
+    # Perform cleanup of files produced by generation from hpp file.
+    def clean_from_h( a_target )
+      @qt_h2moc_files.each { |h|
+        moc = moc_from_h( h, a_target )
+
+        Mxx_ru::Util::delete_file( moc )
+
+        add_cpp_source( a_target, moc )
+      }
+    end
+
+    # Formatting file name, which is generated from hpp file by moc tool
+    def moc_from_h( a_h_file, a_target )
+      path = File.dirname( a_h_file )
+
+      # If path == ".", then Qt will generate wrong include directive
+      path = "" if path == "./"
+
+      if @moc_result_subdir
+        if path.length > 0
+          path = File.join( path, @moc_result_subdir )
+        else
+          path = @moc_result_subdir
+        end
+      end
+
+      if path.length > 0
+        # Ensure result folder is exist.
+        Mxx_ru::Util::ensure_path_exists( path )
+      end
+
+      r = File.join( path, "moc_" + File.basename(
+        Mxx_ru::Util::remove_file_ext( a_h_file ) ) + @cpp_ext )
+
+      return r
+    end
+
+    # Perform generation from cpp file using moc tool.
+    def build_from_cpp( a_target )
+      @qt_cpp2moc_files.each { |cpp|
+        moc = moc_from_cpp( cpp, a_target )
+
+        moc_full = moc
+        cpp_full = cpp
+
+        if Target_state::EXISTS != Target_state.detect(
+          moc_full, [ cpp_full ] ).state
+          Mxx_ru::Abstract_target::run(
+            [ "#{moc_name} -o #{moc_full} " + 
+              "#{cpp_full}" ],
+            [ moc_full ] )
+        end
+      }
+    end
+
+    # Perform cleanup of files produced by generation from cpp file.
+    def clean_from_cpp( a_target )
+      @qt_cpp2moc_files.each { |cpp|
+        moc = moc_from_cpp( cpp, a_target )
+
+        Mxx_ru::Util::delete_file( moc )
+      }
+    end
+
+    # Formatting file name, which is generated from cpp file by moc tool
+    def moc_from_cpp( a_cpp_file, a_target )
+      path = File.dirname( a_cpp_file )
+
+      if @moc_result_subdir
+        if path.length > 0
+          path = File.join( path, @moc_result_subdir )
+        else
+          path = @moc_result_subdir
+        end
+      end
+
+      if path.length > 0
+        # Ensure result folder is exist.
+        Mxx_ru::Util::ensure_path_exists( path )
+      end
+
+      r = File.join( path, File.basename(
+        Mxx_ru::Util::remove_file_ext( a_cpp_file ) ) + @moc_ext )
+
+      return r
+    end
+
+    # Setting C++ file name, ignoring current sources_root value.
+    def add_cpp_source( a_target, a_file )
+      old_root = a_target.sources_root( "" )
+      a_target.cpp_source( a_file )
+      a_target.sources_root( old_root )
+    end
+
+  end # class Qt_gen
+
+end
+end
+