bake 0.1.0

data/lib/bake/context.rb

@@ -0,0 +1,101 @@
+require 'bake/string_utils.rb'
+
+module Bake
+    class Context
+        def initialize(scheme_loader)
+            @scheme_loader = scheme_loader
+            @current = nil
+        end
+
+        def context_eval(target, str = nil, file = nil, &block)
+            old = @current
+            begin
+                @current = target
+                if str
+                    instance_eval(str, file ? file : '')
+                else
+                    instance_eval(&block)
+                end
+            ensure
+                @current = old
+            end
+        end
+
+        def using(scheme_and_toolset)
+            scheme_name, toolset_name = scheme_and_toolset.to_s.split('.')
+            toolset_name = 'default' if !toolset_name
+            scheme = @scheme_loader.scheme(scheme_name)
+            raise "invalid scheme '#{scheme_name}'" if !scheme
+            scheme.toolset = toolset_name
+        end
+
+        def glob(*args)
+            has_options = args.last.respond_to?(:to_hash)
+            options = has_options ? args.pop.to_hash : {}
+            exclude = array_opt(options, :exclude)
+            files = []
+            args.each do |pat|
+                matches = Dir[pat]
+                matches.each do |file|
+                    if !exclude.find { |exc| File.fnmatch(exc, file) }
+                        files.push(file) 
+                    end
+                end
+            end
+            if block_given?
+                for i in 0...files.size
+                    yield(files[i])
+                end
+            end
+            return files
+        end
+
+        def macro(name, &block)
+            raise "no block given for macro '#{name}'" if !block
+            @current.opt(:macros => { :name => name, :block => block })
+        end
+
+        def method_missing(method, *args, &block)
+            @scheme_loader.schemes.each do |name, scheme|
+                if scheme.has_constructor?(method)
+                    target = scheme.construct(method, @current, *args)
+                    context_eval(target, &block) if block
+                    return target
+                end
+            end
+            return object_method_missing(method, *args, &block) if !@current
+            macro = @current[:macros].find { |macro| macro[:name] == method }
+            if macro
+                return instance_exec(*args, &macro[:block])
+            end
+            if @current.respond_to?(method)
+                return @current.send(method, *args, &block)
+            end
+            raise "undefined symbol '#{method}'"
+        end
+
+    private
+        def array_opt(options, name)
+            opt = options[name]
+            return [] if !opt
+            if opt.respond_to?(:to_ary)
+                opt = opt.to_ary
+            else
+                opt = [ opt ]
+            end
+        end
+
+        # took this implementation from http://tinyurl.com/gzrtn
+        def instance_exec(*args, &block)
+            mname = "__instance_exec_#{Thread.current.object_id.abs}"
+            class << self; self end.class_eval{ define_method(mname, &block) }
+            begin
+                ret = send(mname, *args)
+            ensure
+                class << self; self end.class_eval{ undef_method(mname) } rescue nil
+            end
+            ret
+        end
+    end
+end
+

data/lib/bake/cpp_scheme.rb

@@ -0,0 +1,460 @@
+require 'bake/toolset'
+require 'bake/target'
+require 'fileutils'
+require 'set'
+
+class CppToolsetBase < Bake::Toolset
+    def build(target)
+        if stale?(target)
+            FileUtils.mkdir_p(target[:outdir])
+            if target.is_a?(Cpp::Object)
+                compile(target)
+                # refresh the .includes file
+                includes = target.includes
+                filename = "#{target[:outdir]}/#{target.src.basename}.includes"
+                File.open(filename, "w") do |file|
+                    includes.each { |inc| file.puts(inc) }
+                end
+            elsif target.is_a?(Cpp::Library)
+                ar(target)
+            elsif target.is_a?(Cpp::Executable)
+                link(target)
+            elsif target.is_a?(Cpp::Runner)
+                run(target)
+            else
+                raise "unknown Cpp target of class '#{target.class}"
+            end
+        end
+    end
+    
+    def stale?(target)
+        t = Time.now
+        output_files(target).each do |out|
+            return true if !File.exists?(out)
+            out_time = File.mtime(out)
+            t = out_time if out_time < t
+        end
+        if target.is_a?(Cpp::Object)
+            return true if File.mtime(target.src) > t
+            target.includes.each { |file| return true if File.mtime(file) > t }
+        elsif target.is_a?(Cpp::Runner)
+            return File.mtime(output_files(target.deps[0])[0]) > t
+        else
+            is_linked = target.is_a?(Cpp::Executable) ||
+                (target.is_a?(Cpp::Library) && target[:libtype] == 'dynamic')
+            target.children.each do |child|
+                output_files(child).each do |file|
+                    return true if File.mtime(file) > t
+                end
+            end
+            target.deps.each do |dep|
+                if is_linked && dep.is_a?(Cpp::Library) &&
+                    dep[:libtype] != 'dynamic'
+                    output_files(dep).each do |file|
+                        return true if File.mtime(file) > t
+                    end
+                end
+            end
+        end
+        return false
+    end
+    
+    def clean(target)
+        output_files(target).each { |file| FileUtils.rm_f(file) }
+        if target.is_a?(Cpp::Object)
+            filename = "#{target[:outdir]}/#{target.src.basename}.includes"
+            FileUtils.rm_f(filename)
+        end
+    end
+    
+    def output_files(target)
+        out = output(target)
+        return [] if !out
+        return out.to_a if out.respond_to?(:to_a)
+        return [ out ]
+    end
+end
+
+class GccToolsetBase < CppToolsetBase
+    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}")
+        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.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 = []
+        (target.children + 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 + ' '
+                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
+
+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
+
+    class Gcc < GccToolsetBase
+    end
+
+    class Msvc6 < CppToolsetBase
+        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.children + 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
+
+    class Library < Bake::Target
+        ACCESSORS = :lib
+
+        def initialize(parent, name)
+            super(parent)
+            @name = name
+            default(:libtype => 'static')
+            default(:debug_symbols? => false)
+        end
+
+        def src(*args)
+            return args.flatten.collect { |file| Cpp::Object.new(self, file) }
+        end
+    end
+
+    class SystemLibrary < Bake::Target
+        ACCESSORS = :syslib
+
+        attr_reader :file
+
+        def initialize(parent, name, file)
+            super(parent)
+            @name = name
+            @file = file
+            opt(:built? => true)
+        end
+    end
+
+    class Executable < Bake::Target
+        ACCESSORS = :exe
+
+        def initialize(parent, name)
+            super(parent)
+            @name = name
+            default(:debug_symbols? => false)
+        end
+
+        def src(*args)
+            return args.flatten.collect { |file| Cpp::Object.new(self, file) }
+        end
+    end
+
+    class Source < Bake::Target
+        attr_reader :output
+
+        def initialize(parent, src)
+            super(parent)
+            @output = src
+            opt(:built? => true)
+        end
+    end
+
+    class Object < Bake::Target
+        ACCESSORS = :obj
+
+        def initialize(parent, src = nil)
+            super(parent)
+            return if !src
+            if src.instance_of?(String)
+                children << Source.new(self, src)
+            else
+                children << src
+            end
+            default(:exceptions? => true)
+            default(:rtti? => true)
+            default(:optimizations? => false)
+            default(:multithreaded? => true)
+        end
+
+        def src
+            return children.first.output
+        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 < Bake::Target
+        ACCESSORS = :run
+
+        def initialize(parent, exe)
+            super(parent)
+            target = dep(exe)[0]
+            if !target.is_a?(Executable)
+                raise "target '#{target.name}' is not an executable"
+            end
+        end
+    end
+end
+