rscons 1.9.3 → 1.10.0

data/lib/rscons/builders/library.rb

@@ -2,6 +2,7 @@ module Rscons
   module Builders
     # A default Rscons builder that produces a static library archive.
     class Library < Builder
+
       # Return default construction variables for the builder.
       #
       # @param env [Environment] The Environment using the builder.
@@ -16,28 +17,48 @@ module Rscons
         }
       end
 
+      # Set up a build operation using this builder.
+      #
+      # @param options [Hash] Builder setup options.
+      #
+      # @return [Object]
+      #   Any object that the builder author wishes to be saved and passed back
+      #   in to the {#run} method.
+      def setup(options)
+        target, sources, env, vars = options.values_at(:target, :sources, :env, :vars)
+        suffixes = env.expand_varref(["${OBJSUFFIX}", "${LIBSUFFIX}"], vars)
+        # Register builders to build each source to an object file or library.
+        env.register_builds(target, sources, suffixes, vars)
+      end
+
       # Run the builder to produce a build target.
       #
-      # @param target [String] Target file name.
-      # @param sources [Array<String>] Source file name(s).
-      # @param cache [Cache] The Cache object.
-      # @param env [Environment] The Environment executing the builder.
-      # @param vars [Hash,VarSet] Extra construction variables.
+      # @param options [Hash] Builder run options.
       #
       # @return [String,false]
       #   Name of the target file on success or false on failure.
-      def run(target, sources, cache, env, vars)
-        # build sources to linkable objects
-        objects = env.build_sources(sources, env.expand_varref(["${OBJSUFFIX}", "${LIBSUFFIX}"], vars).flatten, cache, vars)
-        if objects
-          vars = vars.merge({
-            '_TARGET' => target,
-            '_SOURCES' => objects,
-          })
-          command = env.build_command("${ARCMD}", vars)
-          standard_build("AR #{target}", target, command, objects, env, cache)
-        end
+      def run(options)
+        target, sources, cache, env, vars, objects = options.values_at(:target, :sources, :cache, :env, :vars, :setup_info)
+        vars = vars.merge({
+          '_TARGET' => target,
+          '_SOURCES' => objects,
+        })
+        options[:sources] = objects
+        command = env.build_command("${ARCMD}", vars)
+        standard_threaded_build("AR #{target}", target, command, objects, env, cache)
       end
+
+      # Finalize a build.
+      #
+      # @param options [Hash]
+      #   Finalize options.
+      #
+      # @return [String, nil]
+      #   The target name on success or nil on failure.
+      def finalize(options)
+        standard_finalize(options)
+      end
+
     end
   end
 end

data/lib/rscons/builders/object.rb

@@ -3,6 +3,7 @@ module Rscons
     # A default Rscons builder which knows how to produce an object file from
     # various types of source files.
     class Object < Builder
+
       # Mapping of known sources from which to build object files.
       KNOWN_SUFFIXES = {
         "AS" => "ASSUFFIX",
@@ -61,54 +62,66 @@ module Rscons
       # Return whether this builder object is capable of producing a given target
       # file name from a given source file name.
       #
-      # @param target [String] The target file name.
-      # @param source [String] The source file name.
-      # @param env [Environment] The Environment.
+      # @param target [String]
+      #   The target file name.
+      # @param source [String]
+      #   The source file name.
+      # @param env [Environment]
+      #   The Environment.
       #
       # @return [Boolean]
       #   Whether this builder object is capable of producing a given target
       #   file name from a given source file name.
       def produces?(target, source, env)
-        target.end_with?(*env['OBJSUFFIX']) and KNOWN_SUFFIXES.find do |compiler, suffix_var|
-          source.end_with?(*env[suffix_var])
-        end
+        target.end_with?(*env['OBJSUFFIX']) and
+          KNOWN_SUFFIXES.find do |compiler, suffix_var|
+            source.end_with?(*env[suffix_var])
+          end
       end
 
       # Run the builder to produce a build target.
       #
-      # @param target [String] Target file name.
-      # @param sources [Array<String>] Source file name(s).
-      # @param cache [Cache] The Cache object.
-      # @param env [Environment] The Environment executing the builder.
-      # @param vars [Hash,VarSet] Extra construction variables.
+      # @param options [Hash] Builder run options.
       #
-      # @return [String,false]
-      #   Name of the target file on success or false on failure.
-      def run(target, sources, cache, env, vars)
+      # @return [String, ThreadedCommand]
+      #   Target file name if target is up to date or a {ThreadedCommand}
+      #   to execute to build the target.
+      def run(options)
+        target, sources, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
         vars = vars.merge({
           '_TARGET' => target,
           '_SOURCES' => sources,
           '_DEPFILE' => Rscons.set_suffix(target, env.expand_varref("${DEPFILESUFFIX}", vars)),
         })
         com_prefix = KNOWN_SUFFIXES.find do |compiler, suffix_var|
-          sources.first.end_with?(*env.expand_varref("${#{suffix_var}}"))
+          sources.first.end_with?(*env.expand_varref("${#{suffix_var}}", vars))
         end.tap do |v|
           v.nil? and raise "Error: unknown input file type: #{sources.first.inspect}"
         end.first
         command = env.build_command("${#{com_prefix}CMD}", vars)
-        unless cache.up_to_date?(target, command, sources, env)
-          cache.mkdir_p(File.dirname(target))
-          FileUtils.rm_f(target)
-          return false unless env.execute("#{com_prefix} #{target}", command)
-          deps = sources
+        # Store vars back into options so new keys are accessible in #finalize.
+        options[:vars] = vars
+        standard_threaded_build("#{com_prefix} #{target}", target, command, sources, env, cache)
+      end
+
+      # Finalize the build operation.
+      #
+      # @param options [Hash] Builder finalize options.
+      #
+      # @return [String, nil]
+      #   Name of the target file on success or nil on failure.
+      def finalize(options)
+        if options[:command_status]
+          target, deps, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
           if File.exists?(vars['_DEPFILE'])
             deps += Environment.parse_makefile_deps(vars['_DEPFILE'], target)
             FileUtils.rm_f(vars['_DEPFILE'])
           end
-          cache.register_build(target, command, deps.uniq, env)
+          cache.register_build(target, options[:tc].command, deps.uniq, env)
+          target
         end
-        target
       end
+
     end
   end
 end

data/lib/rscons/builders/preprocess.rb

@@ -20,15 +20,13 @@ module Rscons
 
       # Run the builder to produce a build target.
       #
-      # @param target [String] Target file name.
-      # @param sources [Array<String>] Source file name(s).
-      # @param cache [Cache] The Cache object.
-      # @param env [Environment] The Environment executing the builder.
-      # @param vars [Hash,VarSet] Extra construction variables.
+      # @param options [Hash] Builder run options.
       #
-      # @return [String,false]
-      #   Name of the target file on success or false on failure.
-      def run(target, sources, cache, env, vars)
+      # @return [String, ThreadedCommand]
+      #   Target file name if target is up to date or a {ThreadedCommand}
+      #   to execute to build the target.
+      def run(options)
+        target, sources, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
         if sources.find {|s| s.end_with?(*env.expand_varref("${CXXSUFFIX}", vars))}
           pp_cc = "${CXX}"
           depgen = "${CXXDEPGEN}"
@@ -42,17 +40,27 @@ module Rscons
                           "_SOURCES" => sources,
                           "_DEPFILE" => Rscons.set_suffix(target, env.expand_varref("${DEPFILESUFFIX}", vars)))
         command = env.build_command("${CPP_CMD}", vars)
-        unless cache.up_to_date?(target, command, sources, env)
-          cache.mkdir_p(File.dirname(target))
-          return false unless env.execute("Preprocess #{target}", command)
-          deps = sources
-          if File.exists?(vars["_DEPFILE"])
-            deps += Environment.parse_makefile_deps(vars["_DEPFILE"], nil)
-            FileUtils.rm_f(vars["_DEPFILE"])
+        # Store vars back into options so new keys are accessible in #finalize.
+        options[:vars] = vars
+        standard_threaded_build("#{name} #{target}", target, command, sources, env, cache)
+      end
+
+      # Finalize the build operation.
+      #
+      # @param options [Hash] Builder finalize options.
+      #
+      # @return [String, nil]
+      #   Name of the target file on success or nil on failure.
+      def finalize(options)
+        if options[:command_status]
+          target, deps, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
+          if File.exists?(vars['_DEPFILE'])
+            deps += Environment.parse_makefile_deps(vars['_DEPFILE'], nil)
+            FileUtils.rm_f(vars['_DEPFILE'])
           end
-          cache.register_build(target, command, deps.uniq, env)
+          cache.register_build(target, options[:tc].command, deps.uniq, env)
+          target
         end
-        target
       end
 
     end

data/lib/rscons/builders/program.rb

@@ -3,6 +3,7 @@ module Rscons
     # A default Rscons builder that knows how to link object files into an
     # executable program.
     class Program < Builder
+
       # Return default construction variables for the builder.
       #
       # @param env [Environment] The Environment using the builder.
@@ -38,27 +39,36 @@ module Rscons
       #
       # @return [BuildTarget]
       def create_build_target(options)
+        env, target, vars = options.values_at(:env, :target, :vars)
         my_options = options.dup
-        unless my_options[:target] =~ /\./
-          my_options[:target] += options[:env].expand_varref("${PROGSUFFIX}")
+        unless File.basename(target)["."]
+          my_options[:target] += env.expand_varref("${PROGSUFFIX}", vars)
         end
         super(my_options)
       end
 
+      # Set up a build operation using this builder.
+      #
+      # @param options [Hash] Builder setup options.
+      #
+      # @return [Object]
+      #   Any object that the builder author wishes to be saved and passed back
+      #   in to the {#run} method.
+      def setup(options)
+        target, sources, env, vars = options.values_at(:target, :sources, :env, :vars)
+        suffixes = env.expand_varref(["${OBJSUFFIX}", "${LIBSUFFIX}"], vars)
+        # Register builders to build each source to an object file or library.
+        env.register_builds(target, sources, suffixes, vars)
+      end
+
       # Run the builder to produce a build target.
       #
-      # @param target [String] Target file name.
-      # @param sources [Array<String>] Source file name(s).
-      # @param cache [Cache] The Cache object.
-      # @param env [Environment] The Environment executing the builder.
-      # @param vars [Hash,VarSet] Extra construction variables.
+      # @param options [Hash] Builder run options.
       #
       # @return [String,false]
       #   Name of the target file on success or false on failure.
-      def run(target, sources, cache, env, vars)
-        # build sources to linkable objects
-        objects = env.build_sources(sources, env.expand_varref(["${OBJSUFFIX}", "${LIBSUFFIX}"], vars).flatten, cache, vars)
-        return false unless objects
+      def run(options)
+        target, sources, cache, env, vars, objects = options.values_at(:target, :sources, :cache, :env, :vars, :setup_info)
         ld = env.expand_varref("${LD}", vars)
         ld = if ld != ""
                ld
@@ -74,9 +84,22 @@ module Rscons
           '_SOURCES' => objects,
           'LD' => ld,
         })
+        options[:sources] = objects
         command = env.build_command("${LDCMD}", vars)
-        standard_build("LD #{target}", target, command, objects, env, cache)
+        standard_threaded_build("LD #{target}", target, command, objects, env, cache)
       end
+
+      # Finalize a build.
+      #
+      # @param options [Hash]
+      #   Finalize options.
+      #
+      # @return [String, nil]
+      #   The target name on success or nil on failure.
+      def finalize(options)
+        standard_finalize(options)
+      end
+
     end
   end
 end

data/lib/rscons/builders/shared_library.rb

@@ -0,0 +1,116 @@
+module Rscons
+  module Builders
+    # A default Rscons builder that knows how to link object files into a
+    # shared library.
+    class SharedLibrary < Builder
+
+      # Return default construction variables for the builder.
+      #
+      # @param env [Environment] The Environment using the builder.
+      #
+      # @return [Hash] Default construction variables for the builder.
+      def default_variables(env)
+        {
+          'SHLIBPREFIX' => (RUBY_PLATFORM =~ /mingw/ ? '' : 'lib'),
+          'SHLIBSUFFIX' => (RUBY_PLATFORM =~ /mingw/ ? '.dll' : '.so'),
+          'SHLDFLAGS' => ['${LDFLAGS}', '-shared'],
+          'SHLD' => nil,
+          'SHLIBDIRPREFIX' => '-L',
+          'SHLIBLINKPREFIX' => '-l',
+          'SHLDCMD' => ['${SHLD}', '-o', '${_TARGET}', '${SHLDFLAGS}', '${_SOURCES}', '${SHLIBDIRPREFIX}${LIBPATH}', '${SHLIBLINKPREFIX}${LIBS}']
+        }
+      end
+
+      # Return a set of build features that this builder provides.
+      #
+      # @return [Array<String>]
+      #   Set of build features that this builder provides.
+      def features
+        %w[shared]
+      end
+
+      # Create a BuildTarget object for this build target.
+      #
+      # The build target filename is given a platform-dependent suffix if no
+      # other suffix is given.
+      #
+      # @param options [Hash]
+      #   Options to create the BuildTarget with.
+      # @option options [Environment] :env
+      #   The Environment.
+      # @option options [String] :target
+      #   The user-supplied target name.
+      # @option options [Array<String>] :sources
+      #   The user-supplied source file name(s).
+      #
+      # @return [BuildTarget]
+      def create_build_target(options)
+        env, target, vars = options.values_at(:env, :target, :vars)
+        my_options = options.dup
+        libprefix = env.expand_varref("${SHLIBPREFIX}", vars)
+        unless File.basename(target).start_with?(libprefix)
+          my_options[:target].sub!(%r{^(.*/)?([^/]+)$}, "\\1#{libprefix}\\2")
+        end
+        unless File.basename(target)["."]
+          my_options[:target] += env.expand_varref("${SHLIBSUFFIX}", vars)
+        end
+        super(my_options)
+      end
+
+      # Set up a build operation using this builder.
+      #
+      # @param options [Hash] Builder setup options.
+      #
+      # @return [Object]
+      #   Any object that the builder author wishes to be saved and passed back
+      #   in to the {#run} method.
+      def setup(options)
+        target, sources, env, vars = options.values_at(:target, :sources, :env, :vars)
+        suffixes = env.expand_varref(["${OBJSUFFIX}", "${LIBSUFFIX}"], vars)
+        # Register builders to build each source to an object file or library.
+        env.register_builds(target, sources, suffixes, vars,
+                            features: %w[shared])
+      end
+
+      # Run the builder to produce a build target.
+      #
+      # @param options [Hash] Builder run options.
+      #
+      # @return [String,false]
+      #   Name of the target file on success or false on failure.
+      def run(options)
+        target, sources, cache, env, vars, objects = options.values_at(:target, :sources, :cache, :env, :vars, :setup_info)
+        ld = env.expand_varref("${SHLD}", vars)
+        ld = if ld != ""
+               ld
+             elsif sources.find {|s| s.end_with?(*env.expand_varref("${DSUFFIX}", vars))}
+               "${SHDC}"
+             elsif sources.find {|s| s.end_with?(*env.expand_varref("${CXXSUFFIX}", vars))}
+               "${SHCXX}"
+             else
+               "${SHCC}"
+             end
+        vars = vars.merge({
+          '_TARGET' => target,
+          '_SOURCES' => objects,
+          'SHLD' => ld,
+        })
+        options[:sources] = objects
+        command = env.build_command("${SHLDCMD}", vars)
+        standard_threaded_build("SHLD #{target}", target, command, objects, env, cache)
+      end
+
+      # Finalize a build.
+      #
+      # @param options [Hash]
+      #   Finalize options.
+      #
+      # @return [String, nil]
+      #   The target name on success or nil on failure.
+      def finalize(options)
+        standard_finalize(options)
+      end
+
+    end
+  end
+end

data/lib/rscons/builders/shared_object.rb

@@ -0,0 +1,113 @@
+module Rscons
+  module Builders
+    # A default Rscons builder which knows how to produce an object file which
+    # is capable of being linked into a shared library from various types of
+    # source files.
+    class SharedObject < Builder
+
+      # Mapping of known sources from which to build object files.
+      KNOWN_SUFFIXES = {
+        "AS" => "ASSUFFIX",
+        "SHCC" => "CSUFFIX",
+        "SHCXX" => "CXXSUFFIX",
+        "SHDC" => "DSUFFIX",
+      }
+
+      # Return default construction variables for the builder.
+      #
+      # @param env [Environment] The Environment using the builder.
+      #
+      # @return [Hash] Default construction variables for the builder.
+      def default_variables(env)
+        pic_flags = (RUBY_PLATFORM =~ /mingw/ ? [] : ['-fPIC'])
+        {
+          'SHCCFLAGS' => ['${CCFLAGS}'] + pic_flags,
+
+          'SHCC' => '${CC}',
+          'SHCFLAGS' => [],
+          'SHCCCMD' => ['${SHCC}', '-c', '-o', '${_TARGET}', '${CCDEPGEN}', '${INCPREFIX}${CPPPATH}', '${CPPFLAGS}', '${SHCFLAGS}', '${SHCCFLAGS}', '${_SOURCES}'],
+
+          'SHCXX' => '${CXX}',
+          'SHCXXFLAGS' => [],
+          'SHCXXCMD' => ['${SHCXX}', '-c', '-o', '${_TARGET}', '${CXXDEPGEN}', '${INCPREFIX}${CPPPATH}', '${CPPFLAGS}', '${SHCXXFLAGS}', '${SHCCFLAGS}', '${_SOURCES}'],
+
+          'SHDC' => 'gdc',
+          'SHDFLAGS' => ['${DFLAGS}'] + pic_flags,
+          'SHDCCMD' => ['${SHDC}', '-c', '-o', '${_TARGET}', '${INCPREFIX}${D_IMPORT_PATH}', '${SHDFLAGS}', '${_SOURCES}'],
+        }
+      end
+
+      # Return a set of build features that this builder provides.
+      #
+      # @return [Array<String>]
+      #   Set of build features that this builder provides.
+      def features
+        %w[shared]
+      end
+
+      # Return whether this builder object is capable of producing a given target
+      # file name from a given source file name.
+      #
+      # @param target [String]
+      #   The target file name.
+      # @param source [String]
+      #   The source file name.
+      # @param env [Environment]
+      #   The Environment.
+      #
+      # @return [Boolean]
+      #   Whether this builder object is capable of producing a given target
+      #   file name from a given source file name.
+      def produces?(target, source, env)
+        target.end_with?(*env['OBJSUFFIX']) and
+          KNOWN_SUFFIXES.find do |compiler, suffix_var|
+            source.end_with?(*env[suffix_var])
+          end
+      end
+
+      # Run the builder to produce a build target.
+      #
+      # @param options [Hash] Builder run options.
+      #
+      # @return [String, ThreadedCommand]
+      #   Target file name if target is up to date or a {ThreadedCommand}
+      #   to execute to build the target.
+      def run(options)
+        target, sources, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
+        vars = vars.merge({
+          '_TARGET' => target,
+          '_SOURCES' => sources,
+          '_DEPFILE' => Rscons.set_suffix(target, env.expand_varref("${DEPFILESUFFIX}", vars)),
+        })
+        com_prefix = KNOWN_SUFFIXES.find do |compiler, suffix_var|
+          sources.first.end_with?(*env.expand_varref("${#{suffix_var}}", vars))
+        end.tap do |v|
+          v.nil? and raise "Error: unknown input file type: #{sources.first.inspect}"
+        end.first
+        command = env.build_command("${#{com_prefix}CMD}", vars)
+        # Store vars back into options so new keys are accessible in #finalize.
+        options[:vars] = vars
+        standard_threaded_build("#{com_prefix} #{target}", target, command, sources, env, cache)
+      end
+
+      # Finalize the build operation.
+      #
+      # @param options [Hash] Builder finalize options.
+      #
+      # @return [String, nil]
+      #   Name of the target file on success or nil on failure.
+      def finalize(options)
+        if options[:command_status]
+          target, deps, cache, env, vars = options.values_at(:target, :sources, :cache, :env, :vars)
+          if File.exists?(vars['_DEPFILE'])
+            deps += Environment.parse_makefile_deps(vars['_DEPFILE'], target)
+            FileUtils.rm_f(vars['_DEPFILE'])
+          end
+          cache.register_build(target, options[:tc].command, deps.uniq, env)
+          target
+        end
+      end
+
+    end
+  end
+end