akro 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c69ca34e3c6f0e691cf032931d3f1fa8a7fa7b95
+  data.tar.gz: 015d35f735e0bbde0d93774f0c989d82df53429e
+SHA512:
+  metadata.gz: 3257b2d6318db6f815cad2663df2f914b5a1fcb6ecf23bbb985fb9c4abac63ee43267c84ab4cdba678dce52c8122561c0b8b5393c8a7e5f8c122e7a09157f2c0
+  data.tar.gz: 18e0a729c4906341b6655d3fa0c112946ba9a885ba2fb63da99a5a057752649eb8b7db1cac2776443ff458c24fc7c3eaf01649e5016701e7e00e80b0e7361b52

data/bin/akro

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2016 Vlad Petric
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+
+# At the top level, Akro is a wrapper around rake. The reason for
+# the wrapping is that rake does not allow pre-loads before the
+# rakefile. 
+# Akro needs to define several functions: add_test, add_binary(ies),
+# add_library before a rakefile is processed. The akro main file,
+# akrobuild.rake, is postloaded.
+#
+begin
+  require 'rubygems'
+  gem 'akro'
+rescue LoadError
+end
+#preload
+require 'akro'
+
+#postload - will only be handled after the rakefile
+rake_import = "#{File.dirname(File.dirname(File.realdirpath(__FILE__)))}/lib/akrobuild.rake"
+Rake.application.add_import(rake_import)
+Rake.application.run

data/lib/akro.rb

@@ -0,0 +1,135 @@
+# Copyright (c) 2016 Vlad Petric
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+require 'rake'
+
+$VERBOSE_BUILD = false
+
+# Use $COMPILER_PREFIX for things like ccache
+$COMPILER_PREFIX = nil
+$COMPILER = "g++"
+$COMPILE_FLAGS = "-Wall"
+$MODE_COMPILE_FLAGS = {
+  "debug" => "-g3",
+  "release" => "-O3 -g3"
+}
+
+$AR = "ar"
+
+# nil for linker means - use the same as the compiler
+$LINKER = nil
+$LINKER_PREFIX = nil
+$LINK_FLAGS = nil
+$MODE_LINK_FLAGS = nil
+# $ADDITIONAL_LINK_FLAGS is for third party libraries and objects
+$ADDITIONAL_LINK_FLAGS = ""
+
+$HEADER_EXTENSIONS = [".h", ".hpp", ".H"]
+$CPP_EXTENSIONS = [".c", ".cc", ".cpp", ".cxx", ".c++", ".C"]
+$OBJ_EXTENSION = ".o"
+$STATIC_LIB_EXTENSION = ".a"
+$DYNAMIC_LIB_EXTENSION = ".so"
+
+$LIB_CAPTURE_MAP = Hash.new
+
+AkroTest = Struct.new("AkroTest", :name, :script, :binary, :cmdline)
+$AKRO_TESTS = []
+$AKRO_TESTS_MAP = Hash.new
+def add_test(name: nil, script: nil, binary: nil, cmdline: nil)
+  raise "Test must have a name" if name.nil?
+  raise "Test must have at least a script and a binary" if script.nil? and binary.nil?
+  raise "Binary must end in .exe" if !binary.nil? and !binary.end_with?(".exe")
+  test = AkroTest.new(name, script, binary, cmdline)
+  $AKRO_TESTS << test
+  raise "Test #{name} appears multiple times" if $AKRO_TESTS_MAP.has_key?(name)
+  $AKRO_TESTS_MAP[name] = test
+end
+
+$AKRO_BINARIES = []
+def add_binary(path)
+  $AKRO_BINARIES << path.to_str()
+end
+
+def add_binaries(*paths)
+  paths.each do |path|
+    $AKRO_BINARIES << path.to_str()
+  end
+end
+
+AkroLibrary = Struct.new("AkroLibrary", :path, :sources, :static, :recurse, :capture_deps, :additional_params)
+$AKRO_LIBS = []
+
+def add_static_library(path: nil, sources: nil, recurse: true, capture_deps: true, additional_params: nil)
+  raise "Must specify path for static library" if path.nil?
+  raise "Must specify source for static library #{path}" if sources.nil?
+  $AKRO_LIBS << AkroLibrary.new(path, sources, true, recurse, capture_deps, additional_params)
+end
+def add_dynamic_library(path: nil, sources: nil, recurse: true, capture_deps: true, additional_params: nil)
+  raise "Must specify path for dynamic library" if path.nil?
+  raise "Must specify source for dynamic library #{path}" if sources.nil?
+  $AKRO_LIBS << AkroLibrary.new(path, sources, false, recurse, capture_deps, additional_params)
+end
+
+def add_tests(*tests)
+  tests.each do |t|
+    if t.respond_to?(:to_str)
+      s = t.to_str()
+      add_test(name: s, script: s, binary: s, cmdline: nil)
+    elsif t.is_a?(AkroTest)
+      $AKRO_TESTS << t
+    else
+      raise "Can't add test of class #{t.class.name} "
+    end
+  end
+end
+
+# Module with overrideable command line functions
+module CmdLine
+  def CmdLine.compile_base_cmdline(mode)
+    "#{$COMPILER_PREFIX}#{$COMPILER} #{$COMPILE_FLAGS} #{$MODE_COMPILE_FLAGS[mode]}"
+  end
+  def CmdLine.dependency_cmdline(mode, src)
+    "#{CmdLine.compile_base_cmdline(mode)} -M #{src}"
+  end
+  def CmdLine.compile_cmdline(mode, src, obj)
+    "#{CmdLine.compile_base_cmdline(mode)} -c #{src} -o #{obj}"
+  end
+  def CmdLine.link_cmdline(mode, objs, bin)
+    "#{$LINKER_PREFIX}#{$LINKER} #{$LINK_FLAGS} #{$MODE_LINK_FLAGS[mode]} #{objs.join(' ')} #{$ADDITIONAL_LINK_FLAGS} -o #{bin}"
+  end
+  def CmdLine.static_lib_cmdline(objs, bin)
+    "#{$AR} rcs #{bin} #{objs.join(' ')}"
+  end
+  def CmdLine.dynamic_lib_cmdline(mode, objs, additional_params, bin)
+    if !additional_params.nil?
+      if additional_params.kind_of?(Array)
+        extra_params = " " + objs.join(" ")
+      elsif additional_params.respond_to?(:to_str)
+        extra_params = " " + additional_params.to_str
+      else
+        raise "Additional params to a dynamic library must be either a string or an array of strings"
+      end
+    else
+      extra_params = ""
+    end
+    soname = if bin.include?("/") then FileMapper.strip_mode(bin) else bin end
+    "#{$LINKER_PREFIX}#{$COMPILER} -shared #{$COMPILE_FLAGS} #{$MODE_COMPILE_FLAGS[mode]} -Wl,-soname,#{soname} -o #{bin} #{objs.join(' ')}#{extra_params}"
+  end
+end

data/lib/akrobuild.rake

@@ -0,0 +1,492 @@
+# Copyright (c) 2016 Vlad Petric
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+$MODES = $MODE_COMPILE_FLAGS.keys
+$COMPILER_PREFIX = $COMPILER_PREFIX.nil? ? "" : $COMPILER_PREFIX + " "
+$LINKER_PREFIX = $LINKER_PREFIX.nil? ? $COMPILER_PREFIX : $LINKER_PREFIX + " "
+$LINKER = $LINKER.nil? ? $COMPILER : $LINKER
+$LINK_FLAGS = $LINK_FLAGS.nil? ? $COMPILE_FLAGS : $LINK_FLAGS
+$MODE_LINK_FLAGS = $MODE_LINK_FLAGS.nil? ? $MODE_COMPILE_FLAGS : $MODE_LINK_FLAGS 
+
+module Util
+  def Util.make_relative_path(path)
+    absolute_path = File.absolute_path(path)
+    base_dir = File.absolute_path(Dir.pwd)
+    base_dir << '/' if !base_dir.end_with?('/')
+    r = absolute_path.start_with?(base_dir) ? absolute_path[base_dir.size..-1] : nil
+    if !r.nil? && r.start_with?('/')
+      raise "Relative path #{r} is not relative"
+    end
+    r
+  end
+end
+
+module FileMapper
+  # Extract build mode from path.
+  # E.g., debug/a/b/c.o returns debug.
+  def FileMapper.get_mode(path)
+    rel_path = Util.make_relative_path(path)
+    raise "Path #{path} does not belong to #{Dir.pwd}" if rel_path.nil?
+    mode = rel_path[/^([^\/]*)/, 1]
+    raise "Unknown mode #{mode} for #{path}" if !$MODES.include?(mode)
+    mode
+  end
+  def FileMapper.get_mode_from_dc(path)
+    rel_path = Util.make_relative_path(path)
+    raise "Path #{path} does not belong to #{Dir.pwd}" if rel_path.nil?
+    mode = rel_path[/^\.akro\/([^\/]*)/, 1]
+    raise "Unknown mode #{mode} for #{path}" if !$MODES.include?(mode)
+    mode
+  end
+  # Strip the build mode from path.
+  def FileMapper.strip_mode(path)
+    rel_path = Util.make_relative_path(path)
+    raise "Path #{path} does not belong to #{Dir.pwd}" if rel_path.nil?
+    get_mode(rel_path) # for sanity checking
+    rel_path[/^[^\/]*\/(.*)$/, 1]
+  end
+  # Maps object file to its corresponding depcache file.
+  # E.g., release/a/b/c.o maps to .akro/release/a/b/c.depcache
+  def FileMapper.map_obj_to_dc(path)
+    FileMapper.get_mode(path)
+    raise "#{path} is not a #{$OBJ_EXTENSION} file" if !path.end_with?($OBJ_EXTENSION)
+    ".akro/#{path[0..-$OBJ_EXTENSION.length-1]}.depcache"
+  end
+  # Maps object file to its corresponding cpp file, if it exists.
+  # E.g., release/a/b/c.o maps to a/b/c{.cpp,.cc,.cxx,.c++}
+  def FileMapper.map_obj_to_cpp(path)
+    raise "#{path} is not a #{$OBJ_EXTENSION} file" if !path.end_with?($OBJ_EXTENSION)
+    file = FileMapper.strip_mode(path)
+    file = file[0..-$OBJ_EXTENSION.length-1]   
+    srcs = $CPP_EXTENSIONS.map{|ext| file + ext}.select{|fname| File.exist?(fname)}
+    raise "Multiple sources for base name #{file}: #{srcs.join(' ')}" if srcs.length > 1
+    srcs.length == 0? nil : srcs[0]
+  end
+  def FileMapper.map_cpp_to_dc(mode, path)
+    $CPP_EXTENSIONS.map do |ext|
+      return ".akro/#{mode}/#{path[0..-ext.length-1]}.depcache" if path.end_with?(ext)
+    end
+    raise "#{path} is not one of: #{$CPP_EXTENSIONS.join(',')}"
+  end
+  def FileMapper.map_cpp_to_obj(mode, path)
+    $CPP_EXTENSIONS.map do |ext|
+      return "#{mode}/#{path[0..-ext.length-1]}#{$OBJ_EXTENSION}" if path.end_with?(ext)
+    end
+    raise "#{path} is not one of: #{$CPP_EXTENSIONS.join(',')}"
+  end
+  # Maps depcache file to its corresponding cpp file, which should exist.
+  # E.g., .akro/release/a/b/c.o maps to a/b/c{.cpp,.cc,.cxx,.c++}
+  def FileMapper.map_dc_to_cpp(path)
+    raise "#{path} is not a .depcache file" if !path.end_with?('.depcache') || !path.start_with?('.akro')
+    file = path[/^\.akro\/(.*)\.depcache$/, 1]
+    file = FileMapper.strip_mode(file)
+    srcs = $CPP_EXTENSIONS.map{|ext| file + ext}.select{|fname| File.exist?(fname)}
+    raise "Multiple sources for base name #{file}: #{srcs.join(' ')}" if srcs.length > 1
+    raise "No sources for base name #{file}" if srcs.length == 0
+    srcs[0]
+  end
+  def FileMapper.map_dc_to_compcmd(path)
+    raise "#{path} is not a .depcache file" if !path.end_with?('.depcache') || !path.start_with?('.akro')
+    path.gsub(/\.depcache$/, ".compcmd" )
+  end
+  def FileMapper.map_exe_to_linkcmd(path)
+    ".akro/#{path.gsub(/\.exe$/, ".linkcmd" )}"
+  end
+  def FileMapper.map_linkcmd_to_exe(path)
+    path[/^.akro\/(.*)\.linkcmd$/, 1] + ".exe"
+  end
+  def FileMapper.map_static_lib_to_linkcmd(path)
+    ".akro/#{path.gsub(/#{$STATIC_LIB_EXTENSION}$/, ".stlinkcmd" )}"
+  end
+  def FileMapper.map_linkcmd_to_static_lib(path)
+    path[/^.akro\/(.*)\.stlinkcmd$/, 1] + $STATIC_LIB_EXTENSION
+  end
+  def FileMapper.map_dynamic_lib_to_linkcmd(path)
+    ".akro/#{path.gsub(/#{$DYNAMIC_LIB_EXTENSION}$/, ".dynlinkcmd" )}"
+  end
+  def FileMapper.map_linkcmd_to_dynamic_lib(path)
+    path[/^.akro\/(.*)\.dynlinkcmd$/, 1] + $DYNAMIC_LIB_EXTENSION
+  end
+  # Maps header file to its corresponding cpp file, if it exists
+  # E.g., a/b/c.h maps to a/b/c.cpp, if a/b/c.cpp exists, otherwise nil
+  def FileMapper.map_header_to_cpp(path)
+    rel_path = Util.make_relative_path(path)
+    # file is not local
+    return nil if rel_path.nil?
+    #$HEADER_EXTENSIONS.select{|ext| rel_path.end_with?(ext)}.each do |ext|
+    #end
+    srcs = $HEADER_EXTENSIONS.select{|ext| rel_path.end_with?(ext)}.collect{ |ext|
+      base_path = rel_path[0..-ext.length-1]
+      $CPP_EXTENSIONS.map{|cppext| base_path + cppext}.select{|file| File.exist?(file)}
+    }.flatten.uniq
+    raise "Multiple sources for base name #{path}: #{srcs.join(' ')}" if srcs.length > 1
+    srcs.length == 0? nil : srcs[0]
+  end
+   
+  def FileMapper.map_script_to_exe(path)
+    path_no_ext = path[/^(.*)[^.\/]*$/, 1]
+    srcs = $CPP_EXTENSIONS.map{|cppext| path + cppext}.select{|file| File.exist?(file)}
+    srcs.length == 0? nil : path + ".exe"
+  end
+end
+
+#Builder encapsulates the compilation/linking/dependecy checking functionality
+module Builder
+  def Builder.create_depcache(src, dc)
+    success = false
+    mode = FileMapper.get_mode_from_dc(dc)
+    basedir, _ = File.split(dc)
+    FileUtils.mkdir_p(basedir)
+    output = File.open(dc, "w")
+    puts "Determining dependencies for #{dc}" if $VERBOSE_BUILD
+    begin
+      #Using backticks as Rake's sh outputs the command. Don't want that here.
+      cmdline = CmdLine.dependency_cmdline(mode, src)
+      puts cmdline if $VERBOSE_BUILD
+      deps = `#{cmdline}`
+      raise "Dependency determination failed for #{src}" if $?.to_i != 0
+      # NOTE(vlad): spaces within included filenames are not supported
+      # Get rid of \ at the end of lines, and also of the newline
+      deps.gsub!(/\\\n/, '')
+      # also get rid of <filename>: at the beginning
+      deps[/^[^:]*:(.*)$/, 1].split(' ').each do |line|
+        # Output either a relative path if the file is local, or the original line.
+        output << (Util.make_relative_path(line.strip) || line) << "\n"
+      end
+      output.close
+      success = true
+    ensure
+      FileUtils.rm(dc) if !success
+    end
+  end
+
+  def Builder.compile_object(src, obj)
+    mode = FileMapper.get_mode(obj)
+    basedir, _ = File.split(obj)
+    FileUtils.mkdir_p(basedir)
+    RakeFileUtils::sh(CmdLine.compile_cmdline(mode, src, obj)) do |ok, res|
+      raise "Compilation failed for #{src}" if !ok
+    end
+  end
+
+  def Builder.link_binary(objs, bin)
+    mode = FileMapper.get_mode(bin)
+    basedir, _ = File.split(bin)
+    FileUtils.mkdir_p(basedir)
+    RakeFileUtils::sh(CmdLine.link_cmdline(mode, objs, bin)) do |ok, res|
+      raise "Linking failed for #{bin}" if !ok
+    end
+  end
+  def Builder.archive_static_library(objs, bin)
+    basedir, _ = File.split(bin)
+    FileUtils.mkdir_p(basedir)
+    RakeFileUtils::sh(CmdLine.static_lib_cmdline(objs, bin)) do |ok, res|
+      raise "Archiving failed for #{bin}" if !ok
+    end
+  end
+
+  def Builder.build_dynamic_library(mode, objs, additional_params, bin)
+    mode = FileMapper.get_mode(bin)
+    basedir, _ = File.split(bin)
+    FileUtils.mkdir_p(basedir)
+    RakeFileUtils::sh(CmdLine.dynamic_lib_cmdline(mode, objs, additional_params, bin)) do |ok, res|
+      raise "Building dynamic library #{bin} failed" if !ok
+    end
+  end
+
+  def Builder.depcache_object_collect(mode, top_level_srcs)
+    all_covered_cpps = Set.new
+    all_objects = []
+    srcs = top_level_srcs
+    while !srcs.empty?
+      new_srcs = [] 
+      dcs = srcs.map{|src| FileMapper.map_cpp_to_dc(mode, src)}
+      dcs.each{|dc| Rake::Task[dc].invoke}
+      dcs.each do |dc|
+        cpp = FileMapper.map_dc_to_cpp(dc)
+        obj = FileMapper.map_cpp_to_obj(mode, cpp)
+        all_objects << obj if !all_objects.include?(obj)
+        File.readlines(dc).map{|line| line.strip}.each do |header|
+          new_cpp = FileMapper.map_header_to_cpp(header)
+          if !new_cpp.nil? and !all_covered_cpps.include?(new_cpp)
+            new_srcs << new_cpp
+            all_covered_cpps << new_cpp
+          end
+        end
+      end
+      srcs = new_srcs
+    end
+    all_objects
+  end
+end
+
+#Phony task that forces anything depending on it to run 
+task "always"
+  
+rule ".compcmd" => ->(dc) {
+  mode = FileMapper.get_mode_from_dc(dc)
+  cmd = CmdLine.compile_base_cmdline(mode)
+  if File.exists?(dc) && File.read(dc).strip == cmd.strip then
+    []
+  else
+    "always"
+  end
+} do |task|
+  basedir, _ = File.split(task.name)
+  FileUtils.mkdir_p(basedir)
+  output = File.open(task.name, "w")
+  mode = FileMapper.get_mode_from_dc(task.name)
+  output << CmdLine.compile_base_cmdline(mode) << "\n"
+  output.close
+end
+
+rule ".linkcmd" => ->(dc) {
+  binary = FileMapper.map_linkcmd_to_exe(dc)
+  raise "Internal error - linkcmd not mapped for #{binary}" if !$LINK_BINARY_OBJS.has_key?(binary)
+  mode = FileMapper.get_mode_from_dc(dc)
+  cmd = CmdLine.link_cmdline(mode, $LINK_BINARY_OBJS[binary], "<placeholder>")
+  if File.exists?(dc) && File.read(dc).strip == cmd.strip then
+    []
+  else
+    "always"
+  end
+} do |task|
+  basedir, _ = File.split(task.name)
+  binary = FileMapper.map_linkcmd_to_exe(task.name)
+  FileUtils.mkdir_p(basedir)
+  output = File.open(task.name, "w")
+  mode = FileMapper.get_mode_from_dc(task.name)
+  output << CmdLine.link_cmdline(mode, $LINK_BINARY_OBJS[binary], "<placeholder>") << "\n"
+  output.close
+end
+
+rule ".dynlinkcmd" => ->(dc) {
+  dynlib = FileMapper.map_linkcmd_to_dynamic_lib(dc)
+  raise "Internal error - linkcmd not mapped for #{dynlib}" if !$LINK_BINARY_OBJS.has_key?(dynlib)
+  mode = FileMapper.get_mode_from_dc(dc)
+  cmd = CmdLine.dynamic_lib_cmdline(mode, $LINK_BINARY_OBJS[dynlib], "", "<placeholder>")
+  if File.exists?(dc) && File.read(dc).strip == cmd.strip then
+    []
+  else
+    "always"
+  end
+} do |task|
+  basedir, _ = File.split(task.name)
+  dynlib = FileMapper.map_linkcmd_to_dynamic_lib(task.name)
+  FileUtils.mkdir_p(basedir)
+  output = File.open(task.name, "w")
+  mode = FileMapper.get_mode_from_dc(task.name)
+  output << CmdLine.dynamic_lib_cmdline(mode, $LINK_BINARY_OBJS[dynlib], "", "<placeholder>") << "\n"
+  output.close
+end
+
+rule ".stlinkcmd" => ->(dc) {
+  stlib = FileMapper.map_linkcmd_to_static_lib(dc)
+  raise "Internal error - linkcmd not mapped for #{stlib}" if !$LINK_BINARY_OBJS.has_key?(stlib)
+  mode = FileMapper.get_mode_from_dc(dc)
+  cmd = CmdLine.static_lib_cmdline($LINK_BINARY_OBJS[stlib], "<placeholder>")
+  if File.exists?(dc) && File.read(dc).strip == cmd.strip then
+    []
+  else
+    "always"
+  end
+} do |task|
+  basedir, _ = File.split(task.name)
+  stlib = FileMapper.map_linkcmd_to_static_lib(task.name)
+  FileUtils.mkdir_p(basedir)
+  output = File.open(task.name, "w")
+  mode = FileMapper.get_mode_from_dc(task.name)
+  output << CmdLine.static_lib_cmdline($LINK_BINARY_OBJS[stlib], "<placeholder>") << "\n"
+  output.close
+end
+
+
+rule ".depcache" => ->(dc){
+  [FileMapper.map_dc_to_compcmd(dc), FileMapper.map_dc_to_cpp(dc)] + 
+  (File.exist?(dc) ? File.readlines(dc).map{|line| line.strip}: [])
+} do |task|
+  src = FileMapper.map_dc_to_cpp(task.name)
+  Builder.create_depcache(src, task.name)
+end
+
+rule $OBJ_EXTENSION => ->(obj){
+  src = FileMapper.map_obj_to_cpp(obj)
+  raise "No source for object file #{obj}" if src.nil?
+  dc = FileMapper.map_obj_to_dc(obj)
+  [src, dc, FileMapper.map_dc_to_compcmd(dc)] +
+  (File.exist?(dc) ? File.readlines(dc).map{|line| line.strip}: [])
+} do |task|
+  src = FileMapper.map_obj_to_cpp(task.name)
+  Builder.compile_object(src, task.name)
+end
+
+def libname(mode, lib)
+  "#{mode}/#{lib.path}#{if lib.static then $STATIC_LIB_EXTENSION else $DYNAMIC_LIB_EXTENSION end}"
+end
+
+def invoke_all_capturing_libs(mode)
+  $AKRO_LIBS.each do |lib|
+    if lib.capture_deps 
+      Rake::Task[libname(mode, lib)].invoke
+    end
+  end
+end
+
+$LINK_BINARY_OBJS = Hash.new
+
+rule ".exe" => ->(binary){
+  obj = binary.gsub(/\.exe$/, $OBJ_EXTENSION)
+  mode = FileMapper.get_mode(binary)
+  cpp = FileMapper.map_obj_to_cpp(obj)
+  raise "No proper #{$CPP_EXTENSIONS.join(',')} file found for #{binary}" if cpp.nil?
+  obj_list = []
+  # Two passes through the object list - the capturing libraries will
+  # be inserted on the position of the *last* object in the list
+  last_obj = Hash.new
+  objs = Builder.depcache_object_collect(mode, [cpp])
+  objs.each do |obj|
+    if $LIB_CAPTURE_MAP.has_key?(obj)
+      last_obj[$LIB_CAPTURE_MAP[obj]] = obj
+    end
+  end
+  objs.each do |obj|
+    if $LIB_CAPTURE_MAP.has_key?(obj)
+      capture_lib = $LIB_CAPTURE_MAP[obj]
+      if last_obj[capture_lib] == obj
+        obj_list << capture_lib
+      end
+    else
+      obj_list << obj
+    end
+  end
+  $LINK_BINARY_OBJS[binary] = obj_list
+  [FileMapper.map_exe_to_linkcmd(binary)] + obj_list
+} do |task|
+  Builder.link_binary(task.prerequisites[1..-1], task.name)
+end
+
+rule $STATIC_LIB_EXTENSION => ->(library) {
+  mode = FileMapper.get_mode(library)
+  srcs = []
+  lib = FileMapper.strip_mode(library)[0..-$STATIC_LIB_EXTENSION.length-1]
+  libspec = nil
+  $AKRO_LIBS.each do |alib|
+    if alib.path == lib and alib.static
+      raise "Library #{library} declared multiple times" if !libspec.nil?
+      libspec = alib
+      srcs << alib.sources
+    end
+  end
+  raise "Library #{library} not found!" if libspec.nil?
+  srcs.flatten!
+  if libspec.recurse
+    objs = Builder.depcache_object_collect(mode, srcs)
+  else
+    objs = srcs.collect{|src| FileMapper.map_cpp_to_obj(mode, src)}
+  end
+  if libspec.capture_deps
+    objs.each do |obj|
+      if $LIB_CAPTURE_MAP.has_key?(obj)
+        raise "Object #{obj} has dependency captures for multiple libraries - #{$LIB_CAPTURE_MAP[obj]} and #{library}"
+      end
+      $LIB_CAPTURE_MAP[obj] = library
+    end
+  end
+  $LINK_BINARY_OBJS[library] = objs
+  [FileMapper.map_static_lib_to_linkcmd(library)] + objs
+} do |task|
+  Builder.archive_static_library(task.prerequisites[1..-1], task.name)
+end
+
+rule $DYNAMIC_LIB_EXTENSION => ->(library) {
+  mode = FileMapper.get_mode(library)
+  srcs = []
+  lib = FileMapper.strip_mode(library)[0..-$DYNAMIC_LIB_EXTENSION.length-1]
+  libspec = nil
+  $AKRO_LIBS.each do |alib|
+    if alib.path == lib and not alib.static
+      raise "Library #{library} declared multiple times" if !libspec.nil?
+      libspec = alib
+      srcs << alib.sources
+    end
+  end
+  raise "Library #{library} not found!" if libspec.nil?
+  srcs.flatten!
+  if libspec.recurse
+    objs = Builder.depcache_object_collect(mode, srcs)
+  else
+    objs = srcs.collect{|src| FileMapper.map_cpp_to_obj(mode, src)}
+  end
+  if libspec.capture_deps
+    objs.each do |obj|
+      if $LIB_CAPTURE_MAP.has_key?(obj)
+        raise "Object #{obj} has dependency captures for multiple libraries - #{$LIB_CAPTURE_MAP[obj]} and #{library}"
+      end
+      $LIB_CAPTURE_MAP[obj] = library
+    end
+  end
+  $LINK_BINARY_OBJS[library] = objs
+  [FileMapper.map_dynamic_lib_to_linkcmd(library)] + objs
+} do |task|
+  libspec = nil
+  lib = FileMapper.strip_mode(task.name)[0..-$DYNAMIC_LIB_EXTENSION.length-1]
+  $AKRO_LIBS.each do |alib|
+    if alib.path == lib and not alib.static
+      libspec = alib
+    end
+  end
+  mode = FileMapper.get_mode(task.name)
+  Builder.build_dynamic_library(mode, task.prerequisites[1..-1], libspec.additional_params, task.name)
+end
+
+task :clean do
+  FileUtils::rm_rf(".akro/")
+  $MODES.each{|mode| FileUtils::rm_rf("#{mode}/")}
+end
+
+$MODES.each do |mode|
+  invoke_all_capturing_libs(mode)
+  task mode
+  task "test_#{mode}"
+  $AKRO_BINARIES.each do |bin|
+    raise "Binary cannot start with mode #{bin}" if bin.start_with?(mode + "/")
+    Rake::Task[mode].enhance(["#{mode}/#{bin}"])
+  end
+  $AKRO_TESTS.each do |test|
+    test_dep = 
+      if !test.binary.nil?
+        "#{mode}/#{test.binary}"
+      else
+        # map_script_to_exe may return nil, which is fine
+        FileMapper.map_script_to_exe(test.script)
+      end
+    task "#{test.name}_test_#{mode}" => test_dep do |task|
+      puts "Running test #{task.name}"
+      base = (if !test.script.nil? then "#{test.script}" else "#{mode}/#{test.binary}" end)
+      params = (if !test.cmdline.nil? then " " + test.cmdline else "" end)
+      new_ld_path = if ENV.has_key?("LD_LIBRARY_PATH") then "#{mode}/:#{ENV['LD_LIBRARY_PATH']}" else "#{mode}/" end
+      system({"MODE" => mode, "LD_LIBRARY_PATH" => new_ld_path}, base + params) do |ok, res|
+        raise "Test #{task.name} failed" if !ok
+      end
+      puts "Test #{task.name} passed"
+    end
+    Rake::Task["test_#{mode}"].enhance(["#{test.name}_test_#{mode}"])
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: akro
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Vlad Petric
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+description: 
+email: vlad@impaler.org
+executables:
+- akro
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/akro
+- lib/akro.rb
+- lib/akrobuild.rake
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Akro build - an extreme C++ build system
+test_files: []