akro 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a16d1336ccfa1d5eb66dd17fa14e3dac63c2d6dd
-  data.tar.gz: 5de90316397edbfe5b812a76fbb37fe8afa1e23a
+  metadata.gz: a9cde35182bf4c229ae6c69f93d9b93845dd465b
+  data.tar.gz: b4eddd80a57434cc08afa83573c224a6eacdb4c0
 SHA512:
-  metadata.gz: 638e33a9f55198950fb9d06199b7ce7de05b83962f1e21d18190da58d5def6616b62d7e145bc845d7e0ed31d332595bcc311c533be647b8632d2358a242cb9a4
-  data.tar.gz: 180ec49c66566ae3a4b437b8acb0a81f12e43e78512bd4eee910646b11048497b99a6637f6ad541bb947b8604478d3b998899d6f75e1b8b814b9b4abd7d552a5
+  metadata.gz: ee4b34956e2f1e70b517f42aaa7fa58fe27a355695c71d80b2c1ca24beb16e41d7b4eecac1695df45d9d886917876951b72894d4965ce963dbd45372f5a960d7
+  data.tar.gz: c48a54a82ab33aa85a42b5047bc42fa774fcc84222879adbd2813300cdf9de6d7a1c1c3f0eed9417f6c7be4bdbc3bd5bcbd0333738c79ec86ffc6aa379786ca4

data/lib/akro.rb

@@ -42,15 +42,30 @@ $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"]
+def windows?
+  (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) != nil
+end
+
+if windows?
+  $HEADER_EXTENSIONS = [".H", ".hpp"]
+  $CPP_EXTENSIONS = [".C", ".cc", ".cpp", ".cxx", ".c++"]
+else
+  $HEADER_EXTENSIONS = [".h", ".hpp", ".H"]
+  $CPP_EXTENSIONS = [".c", ".cc", ".cpp", ".cxx", ".c++", ".C"]
+end
 $OBJ_EXTENSION = ".o"
 $STATIC_LIB_EXTENSION = ".a"
-$DYNAMIC_LIB_EXTENSION = ".so"
+if windows?
+  $DYNAMIC_LIB_EXTENSION = ".dll"
+else
+  $DYNAMIC_LIB_EXTENSION = ".so"
+end
 
 $LIB_CAPTURE_MAP = Hash.new
 $CAPTURING_LIBS = Set.new
 
+$PER_FILE_COMPILE_FLAGS = lambda {|mode, src| ""}
+
 AkroTest = Struct.new("AkroTest", :name, :script, :binary, :cmdline)
 $AKRO_TESTS = []
 $AKRO_TESTS_MAP = Hash.new
@@ -65,9 +80,7 @@ def add_test(name: nil, script: nil, binary: nil, cmdline: nil)
 end
 
 $AKRO_BINARIES = []
-def add_binary(path)
-  $AKRO_BINARIES << path.to_str()
-end
+$BIN_EXTRA_FLAGS = Hash.new
 
 def add_binaries(*paths)
   paths.each do |path|
@@ -75,6 +88,14 @@ def add_binaries(*paths)
   end
 end
 
+def add_binary(path: nil, additional_link_params: nil)
+  raise "Must specify path for binary" if path.nil?
+  if !additional_link_params.nil? && additional_link_params != ""
+    $BIN_EXTRA_FLAGS[path] = additional_link_params
+  end
+  $AKRO_BINARIES << path.to_str()
+end
+
 AkroLibrary = Struct.new("AkroLibrary", :path, :sources, :static, :recurse, :capture_deps, :additional_params)
 $AKRO_LIBS = []
 
@@ -104,17 +125,23 @@ end
 
 # Module with overrideable command line functions
 module CmdLine
-  def CmdLine.compile_base_cmdline(mode)
-    "#{$COMPILER_PREFIX}#{$COMPILER} #{$COMPILE_FLAGS} #{$MODE_COMPILE_FLAGS[mode]}"
+  def CmdLine.compile_base_cmdline(mode, src)
+    per_file_flags = $PER_FILE_COMPILE_FLAGS.call(mode, src)
+    if per_file_flags.size() > 0
+      per_file_flags = " " + per_file_flags
+    end
+    "#{$COMPILER_PREFIX}#{$COMPILER} #{$COMPILE_FLAGS} #{$MODE_COMPILE_FLAGS[mode]}#{per_file_flags}"
   end
   def CmdLine.dependency_cmdline(mode, src)
-    "#{CmdLine.compile_base_cmdline(mode)} -M #{src}"
+    "#{CmdLine.compile_base_cmdline(mode, src)} -M #{src}"
   end
   def CmdLine.compile_cmdline(mode, src, obj)
-    "#{CmdLine.compile_base_cmdline(mode)} -c #{src} -o #{obj}"
+    "#{CmdLine.compile_base_cmdline(mode, src)} -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}"
+    nomodebin = FileMapper.strip_mode(bin)
+    per_file_flags = if $BIN_EXTRA_FLAGS.has_key?(nomodebin) then " " + $BIN_EXTRA_FLAGS[nomodebin] else "" end
+    "#{$LINKER_PREFIX}#{$LINKER} #{$LINK_FLAGS} #{$MODE_LINK_FLAGS[mode]} #{objs.join(' ')} #{$ADDITIONAL_LINK_FLAGS}#{per_file_flags} -o #{bin}"
   end
   def CmdLine.static_lib_cmdline(objs, bin)
     "#{$AR} rcs #{bin} #{objs.join(' ')}"

data/lib/akrobuild.rake

@@ -48,7 +48,7 @@ module FileMapper
     raise "Unknown mode #{mode} for #{path}" if !$MODES.include?(mode)
     mode
   end
-  def FileMapper.get_mode_from_dc(path)
+  def FileMapper.get_mode_from_akpath(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]
@@ -106,6 +106,15 @@ module FileMapper
     raise "#{path} is not a .depcache file" if !path.end_with?('.depcache') || !path.start_with?('.akro')
     path.gsub(/\.depcache$/, ".compcmd" )
   end
+  def FileMapper.map_compcmd_to_cpp(path)
+    raise "#{path} is not a .compcmd file" if !path.end_with?('.compcmd') || !path.start_with?('.akro')
+    file = path[/^\.akro\/(.*)\.compcmd$/, 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_exe_to_linkcmd(path)
     ".akro/#{path.gsub(/\.exe$/, ".linkcmd" )}"
   end
@@ -151,7 +160,7 @@ end
 module Builder
   def Builder.create_depcache(src, dc)
     success = false
-    mode = FileMapper.get_mode_from_dc(dc)
+    mode = FileMapper.get_mode_from_akpath(dc)
     basedir, _ = File.split(dc)
     FileUtils.mkdir_p(basedir)
     output = File.open(dc, "w")
@@ -162,12 +171,15 @@ module Builder
       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
+      # Replace quoted spaces with placeholders
+      deps.gsub!(/\\ /, '<*%#?>') # a string that never exists in filenames
+      # Get rid of endlines completeley
       deps.gsub!(/\\\n/, '')
       # also get rid of <filename>: at the beginning
+      # split by spaces
       deps[/^[^:]*:(.*)$/, 1].split(' ').each do |line|
         # Output either a relative path if the file is local, or the original line.
+        line.gsub!('<*%#?>', ' ')
         output << (Util.make_relative_path(line.strip) || line) << "\n"
       end
       output.close
@@ -240,10 +252,11 @@ 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
+rule ".compcmd" => ->(compcmd) {
+  mode = FileMapper.get_mode_from_akpath(compcmd)
+  src = FileMapper.map_compcmd_to_cpp(compcmd)
+  cmd = CmdLine.compile_base_cmdline(mode, src)
+  if File.exists?(compcmd) && File.read(compcmd).strip == cmd.strip then
     []
   else
     "always"
@@ -252,16 +265,17 @@ rule ".compcmd" => ->(dc) {
   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"
+  mode = FileMapper.get_mode_from_akpath(task.name)
+  src = FileMapper.map_compcmd_to_cpp(task.name)
+  output << CmdLine.compile_base_cmdline(mode, src) << "\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>")
+  mode = FileMapper.get_mode_from_akpath(dc)
+  cmd = CmdLine.link_cmdline(mode, $LINK_BINARY_OBJS[binary], binary)
   if File.exists?(dc) && File.read(dc).strip == cmd.strip then
     []
   else
@@ -272,16 +286,16 @@ rule ".linkcmd" => ->(dc) {
   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"
+  mode = FileMapper.get_mode_from_akpath(task.name)
+  output << CmdLine.link_cmdline(mode, $LINK_BINARY_OBJS[binary], binary) << "\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>")
+  mode = FileMapper.get_mode_from_akpath(dc)
+  cmd = CmdLine.dynamic_lib_cmdline(mode, $LINK_BINARY_OBJS[dynlib], "", dynlib)
   if File.exists?(dc) && File.read(dc).strip == cmd.strip then
     []
   else
@@ -292,16 +306,16 @@ rule ".dynlinkcmd" => ->(dc) {
   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"
+  mode = FileMapper.get_mode_from_akpath(task.name)
+  output << CmdLine.dynamic_lib_cmdline(mode, $LINK_BINARY_OBJS[dynlib], "", dynlib) << "\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>")
+  mode = FileMapper.get_mode_from_akpath(dc)
+  cmd = CmdLine.static_lib_cmdline($LINK_BINARY_OBJS[stlib], stlib)
   if File.exists?(dc) && File.read(dc).strip == cmd.strip then
     []
   else
@@ -312,8 +326,8 @@ rule ".stlinkcmd" => ->(dc) {
   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"
+  mode = FileMapper.get_mode_from_akpath(task.name)
+  output << CmdLine.static_lib_cmdline($LINK_BINARY_OBJS[stlib], stlib) << "\n"
   output.close
 end
 
@@ -473,6 +487,9 @@ $MODES.each do |mode|
     raise "Binary cannot start with mode #{bin}" if bin.start_with?(mode + "/")
     Rake::Task[mode].enhance(["#{mode}/#{bin}"])
   end
+  # Build all non-capturing libs by default.
+  # Capturing libs are automatically invoked by binaries anyway.
+  Rake::Task[mode].enhance($AKRO_LIBS.select{|l| !l.capture_deps}.map{|l| libname(mode, l)})
   $AKRO_TESTS.each do |test|
     test_dep = 
       if !test.binary.nil?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: akro
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Vlad Petric
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-03 00:00:00.000000000 Z
+date: 2016-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: '11.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.1'
+        version: '11.3'
 description: 
 email: vlad@impaler.org
 executables: