bake 0.1.0 → 0.1.1

data/lib/bake/plugins/cpp.rb

@@ -0,0 +1,122 @@
+require 'bake/target'
+
+module Bake
+    module Plugins
+        module Cpp
+            class SystemLibrary < Target
+                attr_reader :file
+
+                def initialize(parent, toolset, name, file)
+                    super(parent, toolset)
+                    @built = true
+                    @name = name
+                    @file = file
+                    opt(:built? => true)
+                end
+            end
+
+            class Library < Target
+                def initialize(parent, toolset, name)
+                    super(parent, toolset)
+                    @name = name
+                    default(:libtype => 'static')
+                    default(:debug_symbols? => false)
+                end
+
+                def add_dep(target)
+                    return super if !target.is_a?(FileTarget)
+                    deps << Cpp::Object.new(self, toolset, target)
+                end
+            end
+
+            class Executable < Target
+                def initialize(parent, toolset, name)
+                    super(parent, toolset)
+                    @name = name
+                    default(:debug_symbols? => false)
+                end
+
+                def add_dep(target)
+                    return super if !target.is_a?(FileTarget)
+                    deps << Cpp::Object.new(self, toolset, target)
+                end
+            end
+
+            class Object < Target
+                def initialize(parent, toolset, file_target)
+                    super(parent, toolset)
+                    deps << file_target
+                    default(:exceptions? => true)
+                    default(:rtti? => true)
+                    default(:optimizations? => false)
+                    default(:multithreaded? => true)
+                end
+
+                def src
+                    return deps.first.path
+                end
+
+                def includes(recalc = false)
+                    incfile = "#{get(:outdir)}/#{src}.includes"
+                    if !@includes || recalc
+                        if File.exists?(incfile)
+                            @includes = load_includes(incfile)
+                        else
+                            @includes = calc_includes(src, Set.new)
+                        end
+                    end
+                    return @includes
+                end
+
+            private
+                def load_includes(incfile)
+                    includes = Set.new
+                    file = File.open(incfile)
+                    while line = file.gets
+                        line.chomp!
+                        includes << line if !line.empty?
+                    end
+                    file.close
+                    return includes
+                end
+
+                def calc_includes(filename, include_fns)
+                    new_include_fns = Set.new
+                    File.open(filename) do |file|
+                        incdirs = get(:incdirs)
+                        while line = file.gets
+                            if line =~ /\s*#\s*include\s+("|<)([^"]+)("|>)/
+                                inc = $2
+                                incdirs.each do |include_dir|
+                                    fn = File.join(include_dir, inc)
+                                    break if include_fns.include?(fn)
+                                    if File.exists?(fn)
+                                        new_include_fns << fn
+                                        include_fns << fn
+                                        break
+                                    end
+                                end
+                            end
+                        end
+                    end
+                    
+                    new_include_fns.each do |inc|
+                        calc_includes(inc, include_fns)
+                    end
+                    return include_fns
+                end
+            end
+
+            class Runner < Target
+                def initialize(parent, toolset, exe)
+                    super(parent, toolset)
+                    target = dep(exe)[0]
+                    if !target.is_a?(Executable)
+                        raise "target '#{target}' is not an executable"
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/cpp/darwin.rb

@@ -0,0 +1,27 @@
+module Bake
+    module Plugins
+        module Cpp
+            class Darwin < GccToolsetBase
+                def ar(lib)
+                    obj_str, lib_str, flags = process_inputs(lib)
+                    
+                    output = lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        sh("g++ #{flags} -dynamiclib -o #{output} #{obj_str} #{lib_str}")
+                    else
+                        sh("ar rcs #{output} #{obj_str}")
+                    end
+                end
+                
+            private
+                def lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        return File.join(lib[:outdir], "#{lib.name}.dylib")
+                    end
+                    return File.join(lib[:outdir], "lib#{lib.name}.a")
+                end
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/cpp/gcc.rb

@@ -0,0 +1,9 @@
+module Bake
+    module Plugins
+        module Cpp
+            class Gcc < GccToolsetBase
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/cpp/gcc_toolset_base.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+
+module Bake
+    module Plugins
+        module Cpp
+            class GccToolsetBase < ToolsetBase
+                def output(target)
+                    if target.is_a?(Cpp::Object)
+                        return obj_fn(target)
+                    elsif target.is_a?(Cpp::Library)
+                        return lib_fn(target)
+                    elsif target.is_a?(Cpp::Executable)
+                        return exe_fn(target)
+                    elsif target.is_a?(Cpp::Runner)
+                        return runner_fn(target)
+                    end
+                    return nil
+                end
+                
+                def compile(obj)
+                    src = obj.src
+                    output = obj_fn(obj)
+                    flags = build_flags('-I', obj[:incdirs] + obj[:sysincdirs]) +
+                        build_flags('-D', obj[:defines])
+                    flags += obj[:cflags].join(' ')
+                    flags += ' -fno-rtti' if !obj[:rtti?]
+                    flags += ' -O3' if obj[:optimizations?]
+                    flags += ' -g' if obj[:debug_symbols?]
+                    sh("g++ -c -o #{output} #{flags} #{src}")
+                end
+                
+                def ar(lib)
+                    obj_str, lib_str, flags = process_inputs(lib)
+                    
+                    output = lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        sh("g++ #{flags} -shared -Wl,-soname,#{output} -o #{output} #{obj_str} #{lib_str}")
+                        if lib.has_prop?(:gcc_lib_path)
+                            fn = File.join(lib[:gcc_lib_path], output.basename)
+                            File.symlink(output, fn) if !File.exists?(fn)
+                        end
+                    else
+                        sh("ar rcs #{output} #{obj_str}")
+                    end
+                end
+                
+                def link(exe)
+                    obj_str, lib_str, flags = process_inputs(exe)
+                    
+                    output = exe_fn(exe)
+                    sh("g++ #{flags} -o #{output} #{obj_str} #{lib_str}")
+                end
+
+                def run(runner)
+                    sh(exe_fn(runner.deps.first))
+                    FileUtils.touch(runner_fn(runner))
+                end
+                
+            private
+                def build_flags(flag, args)
+                    return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
+                end
+                
+                def obj_fn(obj)
+                    src = obj.src
+                    basename = File.basename(src, File.extname(src)) + '.o'
+                    return File.join(obj[:outdir], basename)
+                end
+                
+                def lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        return File.join(lib[:outdir], "lib#{lib.name}.so")
+                    end
+                    return File.join(lib[:outdir], "lib#{lib.name}.a")
+                end
+                
+                def exe_fn(exe)
+                    return File.join(exe[:outdir], exe.name)
+                end
+
+                def runner_fn(runner)
+                    return "#{exe_fn(runner.deps.first)}.success"
+                end
+
+                def process_inputs(target)
+                    output = output(target)
+                    obj_str = ''
+                    lib_str = ''
+                    libdirs = []
+                    rtdirs = []
+                    target.deps.each do |input|
+                        if input.is_a?(Cpp::Object)
+                            fn = obj_fn(input)
+                            obj_str += fn + ' '
+                        elsif input.is_a?(Cpp::SystemLibrary)
+                            lib_str += '-l' + input.file + ' '
+                        elsif input.is_a?(Cpp::Library)
+                            fn = lib_fn(input)
+                            if input[:libtype] == 'dynamic'
+                                obj_str += fn + ' '
+                                rtdirs << File.dirname(fn)
+                            else
+                                lib_str += '-l' + input.name + ' '
+                                libdir = File.dirname(fn)
+                                libdirs << libdir if !libdirs.include?(libdir)
+                            end
+                        end
+                    end
+                    
+                    libdirs.concat(target[:libdirs])
+                    flags = build_flags('-L', libdirs)
+                    return [ obj_str, lib_str, flags ]
+                end
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/cpp/msvc.rb

@@ -0,0 +1,124 @@
+require 'fileutils'
+
+module Bake
+    module Plugins
+        module Cpp
+            class Msvc < ToolsetBase
+                def output(target)
+                    if target.is_a?(Object)
+                        return obj_fn(target)
+                    elsif target.is_a?(Library)
+                        return lib_fn(target)
+                    elsif target.is_a?(Executable)
+                        return exe_fn(target)
+                    end
+                    return nil
+                end
+                
+                def compile(obj)
+                    src = obj.src
+                    output = obj_fn(obj)
+                    flags = build_flags('/I', obj[:incdirs] + obj[:sysincdirs]) +
+                        build_flags('/D', obj[:defines])
+                    flags += obj[:cflags].join(' ')
+                    flags += ' /MD'
+                    flags += ' /EHsc' if obj[:exceptions?]
+                    flags += ' /GR' if obj[:rtti?]
+                    flags += obj[:optimizations?] ? ' /O2' : ' /Od'
+                    flags += ' /Z7' if obj[:debug_symbols?]
+                    sh("cl /nologo #{flags} /c /Fo#{output} /Tp#{src}")
+                end
+                
+                def ar(lib)
+                    obj_str, flags = process_inputs(lib)
+                    
+                    output = lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        flags += ' /debug' if lib[:debug_symbols?]
+                        sh("link /nologo /dll #{flags} /out:#{output[1]} #{obj_str}")
+                    else
+                        sh("lib /nologo /out:#{output} #{obj_str}")
+                    end
+                end
+                
+                def link(exe)
+                    obj_str, flags = process_inputs(exe)
+                    
+                    output = exe_fn(exe)
+                    flags += ' /debug' if exe[:debug_symbols?]
+                    sh("link /nologo /subsystem:console #{flags} /out:#{output} #{obj_str}")
+                end
+                
+                def run(runner)
+                    sh(exe_fn(runner.deps.first))
+                    FileUtils.touch(runner_fn(runner))
+                end
+                
+            private
+                def build_flags(flag, args)
+                    return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
+                end
+                
+                def obj_fn(obj)
+                    src = obj.src
+                    basename = File.basename(src, File.extname(src)) + '.obj'
+                    return File.join(obj[:outdir], basename)
+                end
+                
+                def lib_fn(lib)
+                    if lib[:libtype] == 'dynamic'
+                        return [File.join(lib[:outdir], "#{lib.name}.lib"),
+                            File.join(lib[:outdir], "#{lib.name}.dll"),
+                            File.join(lib[:outdir], "#{lib.name}.exp")]
+                    end
+                    return File.join(lib[:outdir], "#{lib.name}.lib")
+                end
+                
+                def exe_fn(exe)
+                    return File.join(exe[:outdir], exe.name + '.exe')
+                end
+                
+                def runner_fn(runner)
+                    return "#{exe_fn(runner.deps.first)}.success"
+                end
+                
+                def process_inputs(target)
+                    output = output(target)
+                    obj_str = ''
+                    libdirs = []
+                    static_lib = target.is_a?(Library) && target[:libtype] == 'static'
+                    target.deps.each do |input|
+                        if input.is_a?(Object)
+                            fn = obj_fn(input)
+                            obj_str += fn + ' '
+                        elsif input.is_a?(SystemLibrary)
+                            if !static_lib
+                                obj_str += input.file + '.lib '
+                            end
+                        elsif input.is_a?(Library)
+                            if !static_lib
+                                if input[:libtype] == 'dynamic'
+                                    fn = lib_fn(input)[0]
+                                else
+                                    fn = lib_fn(input)
+                                end
+                                libdir = File.dirname(fn)
+                                libdirs << libdir if !libdirs.include?(libdir)
+                                obj_str += File.basename(fn) + ' '
+                            end
+                        end
+                    end
+                    
+                    if !static_lib
+                        target[:libs].each { |lib| obj_str += lib + '.lib ' }
+                    end
+                    libdirs.concat(target[:libdirs])
+                    flags = build_flags('/LIBPATH:', libdirs)
+                    
+                    return [ obj_str, flags ]
+                end
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/cpp/qt.rb

@@ -0,0 +1,50 @@
+require 'bake/toolset'
+require 'fileutils'
+
+module Bake
+    module Plugins
+        module Cpp
+            module Qt
+                class Moc
+                    include Toolset
+
+                    def build(target)
+                        raise "unknown target '#{target}'" if !target.is_a?(MocFile)
+                        return if !stale?(target)
+                        src = target.src
+                        sh("moc -o #{target.output} #{target.src}")
+                    end
+
+                    def clean(target)
+                        FileUtils.rm_f(target.output)
+                    end
+
+                    def stale?(target)
+                        return true if !File.exists?(target.output)
+                        return File.mtime(target.src) > File.mtime(target.output)
+                    end
+
+                    def sh(*args)
+                        cmd = args.join(' ')
+                        puts cmd
+                        system(*args)
+                        raise "error: #{cmd}" if !$? || !$?.success?
+                    end
+                end
+
+                class MocFile < Bake::Target
+                    attr_reader :output
+                    attr_accessor :src
+
+                    def initialize(parent, src)
+                        super(parent)
+                        ext = File.extname(src)
+                        @output = File.basename(src, ext) + '.moc' + ext
+                        @src = src
+                    end
+                end
+            end
+        end
+    end
+end
+