makeconf 0.1.0

data/lib/makeconf/binary.rb

@@ -0,0 +1,30 @@
+# An executable binary file
+class Binary < Buildable
+
+  def initialize(options)
+    raise ArgumentError unless options.kind_of?(Hash)
+    super(options)
+    @output = @id + Platform.executable_extension
+    @output_type = 'binary'
+  end
+
+  def DEADWOOD_build
+    binfile = @id + Platform.executable_extension
+    cc = @compiler.clone
+    cc.is_library = false
+    cc.sources = @sources
+    cc.output = binfile
+
+#XXX-BROKEN cc.add_targets(@makefile)
+
+    @makefile.merge!(cc.to_make(binfile))
+
+    @makefile.clean(cc.objs)
+    @makefile.install(binfile, '$(BINDIR)', { 'mode' => '755' }) \
+        if @installable
+    @output.push binfile
+    super()
+  end
+          
+end
+

data/lib/makeconf/buildable.rb

@@ -0,0 +1,270 @@
+# A buildable object like a library or executable
+class Buildable
+
+  attr_accessor :id, :project,
+        :buildable, :installable, :distributable,
+        :localdep, :sysdep, :enable,
+        :output, :output_type, :sources, :cflags, :ldadd, :rpath,
+        :topdir
+
+  def initialize(options)
+    raise ArgumentError unless options.kind_of?(Hash)
+    default = {
+        :id => options[:id],
+        :enable => true,
+        :buildable => true,
+        :distributable => true,
+        :installable => true,
+        :extension => '',
+        :cflags => [],
+        :ldflags => [],
+        :ldadd => [],
+        :rpath => '',
+        :topdir => '',
+        :depends => [],
+    }
+    default.each do |k,v| 
+      instance_variable_set('@' + k.to_s, v)
+    end
+    @output = id
+    @output_type = nil      # filled in by the derived class
+
+    # Local and system header dependencies for each @sources file
+    # These are filled in by Compiler.makedepends()
+    @localdep = {}
+    @sysdep = {}
+
+    # Filled in by sources=()
+    @sources = []
+    @source_code = {}
+
+    # Parse options
+
+    # FIXME- consider adding support for:
+    #%w{name enable distributable installable extension
+#   topdir rpath}
+
+    log.debug "Buildable options: " + options.pretty_inspect
+      
+    options.each do |k,v|
+      log.debug "k=#{k} v=#{v.to_s}"
+      case k
+      when :id
+        @id = v
+      when :cc
+        @cc = v.clone
+      when :cflags
+        @cflags = v
+        @cflags = [ @cflags ] if @cflags.kind_of?(String)
+      when :ldflags
+        @ldflags = v
+      when :ldadd
+        @ldadd.push(v).flatten!
+      when :project
+        @project = v
+      when :buildable
+        @buildable = v
+      when :sources
+        v = [ v ] if v.kind_of?(String)
+        @sources = v
+      else
+        throw "Unrecognized option -- #{k}: #{v}"
+      end
+    end
+    log.debug "Buildable parsed as: " + self.pretty_inspect
+
+#FIXME: move some of these to the switch statement
+#    # Parse simple textual child elements
+#    %w{cflags ldflags ldadd depends sources}.each do |k|
+#      instance_variable_set('@' + k, yaml[k]) if yaml.has_key? k
+#    end
+
+  end
+
+  def expand_sources(x)
+    log.info "expanding [#{x.to_s}] to source file list"
+    raise ArgumentError('Wrong type') unless x.is_a? Array
+
+    # Use glob(3) to expand the list of sources
+    buf = []
+    x.each do |src| 
+      if src =~ /\*/
+        buf << Dir.glob(src)
+      else
+        buf.push src
+      end
+    end
+    buf.flatten
+
+# TODO: elsewhere
+    # Ensure that all source files exist
+#@sources.each do |src|
+#      throw ArgumentError("#{src} does not exist") unless File.exist? src
+#    end
+
+#XXX-lame
+#    # Read all source code into a single array
+#    @source_code = {}
+#    @sources.each { |x| @source_code[x] = File.readlines(x) }
+
+  end
+
+  # Return the list of intermediate object files
+  def objects
+     expand_sources(@sources).map { |x| x.gsub(/\.c$/, '.o') }
+  end
+
+  def library?
+    @output_type == 'shared library' or @output_type == 'static library'
+  end
+
+  def library_type
+    case @output_type
+    when 'shared library'
+    return :shared
+    when 'static library'
+    return :static
+    else
+    throw 'Not a library'
+    end
+  end
+
+  def binary?
+    @output_type =~ /binary/
+  end
+
+  def finalize
+  end
+
+  # Return a hash containing Makefile rules and targets
+  # needed to build the object.
+  #
+  def build
+    makefile = Makefile.new
+    objs = []
+    sources = expand_sources(@sources)
+
+    # Don't do anything if we aren't going to be built
+    return makefile unless @buildable
+
+    # Allow ndk-build to create the object, for Android
+    return makefile if SystemType.host =~ /-androideabi$/
+
+    log.debug 'buildable = ' + self.pretty_inspect
+
+    if sources.empty?
+      pp self
+      raise 'One or more source files are required' if sources.empty?
+    end
+
+    # Generate the targets and rules for each translation unit
+    sources.each do |src|
+      object_suffix = ''
+      if library? 
+        if library_type == :shared
+#DEADWOOD:cflags.push '-fpic'
+        else
+          object_suffix = '-static'
+        end
+      end
+      obj = src.sub(/.c$/, object_suffix + Platform.object_extension)
+      cc = @project.cc.clone
+      cc.shared_library = library? and library_type == :shared
+      cc.flags = @cflags
+      cc.output = obj
+      cc.sources = src
+      #TODO: cc.topdir = @topdir
+
+      ld = cc.ld
+      ld.flags = @ldflags
+      @ldadd = [ @ldadd ] if @ldadd.kind_of?(String)
+      @ldadd.each { |lib| ld.library lib }
+
+      makefile.add_target(obj, [src, localdep[src]].flatten, cc.rule)
+      makefile.clean(obj)
+      objs.push obj
+    end
+
+    # Generate the targets and rules for the link stage
+    if library? and library_type == :static
+       cmd = Platform.archiver(output, objs)
+    else
+      cc = @project.cc.clone
+      cc.shared_library = library? and library_type == :shared
+      cc.flags = @cflags
+      cc.sources = sources
+      cc.ld.flags = @ldflags
+      @ldadd = [ @ldadd ] if @ldadd.kind_of?(String)
+      @ldadd.each { |lib| cc.ld.library lib }
+      cc.ld.output = @output
+      cmd = cc.ld.rule 
+    end
+    makefile.add_target(output, objs, cmd)
+    makefile.add_dependency('all', output)
+    makefile.clean(output)
+    makefile.distribute(sources) if distributable
+
+    return makefile
+  end
+ 
+  # Return a hash containing Makefile dependencies
+  def makedepends
+    res = []
+
+    if @sources.nil?
+       log.error self.to_s
+       raise 'Missing sources'
+    end
+
+    # Generate the targets and rules for each translation unit
+    expand_sources(@sources).each do |src|
+      next if src =~ /\.o$/
+      cc = @project.cc.clone
+      cc.flags = [ @cflags, '-E' ]
+      cc.output = '-'
+      cc.sources = src
+      #TODO: topdir
+      cmd = cc.command + Platform.dev_null_stderr
+
+      # TODO: do @sysdep also
+      @localdep[src] = []
+      IO.popen(cmd).each do |x|
+        if x =~ /^# \d+ "([^\/<].*\.h)"/
+          @localdep[src].push $1
+        end
+      end
+      @localdep[src].sort!.uniq!
+      res.concat @localdep[src]
+
+      # Generate a list of system header dependencies
+      # FIXME: does a lot of duplicate work reading files in..
+      buf = []
+      @sysdep[src] = []
+      buf.concat File.readlines(src)
+      @localdep[src].each do |x|
+        if File.exist? x
+          buf.concat File.readlines(x)
+        end
+      end
+      buf.each do |x|
+        begin
+          if x =~ /^#\s*include\s+<(.*?)>/
+            @sysdep[src].push $1
+          end
+        rescue ArgumentError
+          # FIXME: should give more info about which file and line
+          warn "** WARNING: invalid multibyte sequence encountered in one of the source code files:"
+        end
+      end
+      @sysdep[src].sort!.uniq!
+
+    end
+    res
+  end
+
+  private
+
+  def log
+    Makeconf.logger
+  end
+end

data/lib/makeconf/compiler.rb

@@ -0,0 +1,332 @@
+# Processes source code files to produce intermediate object files.
+#
+class Compiler
+
+  require 'tempfile'
+
+  attr_accessor :sysroot
+  attr_reader :ld
+
+  def initialize(language, extension)
+    @language = language
+    @extension = extension
+    @ld = Linker.new()
+    windows_init if Platform.is_windows?
+    @flags = []
+    @sources = []     # List of input files
+    @output = nil
+    @sysroot = nil
+    @quiet = false          # If true, output will be suppressed
+
+    # TODO:
+    # If true, all source files will be passed to the compiler at one time.
+    # This will also combine the link and compilation phases.
+    # See: the -combine option in GCC
+    #@combine = false
+
+  end
+
+  def sources=(a)
+    a = [ a ] if a.kind_of?(String)
+    throw 'Array input required' unless a.kind_of?(Array)
+    @sources = a
+    @ld.objects = a.map { |x| x.sub(/\.c$/, '.o') } #FIXME: hardcoded to C
+  end
+
+  def cflags
+    @flags
+  end
+
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # Return the intermediate object files for each source file
+  def object_files(sources)
+    res = []
+    sources.sort.each do |s|
+      res.push s.sub(/.c$/, Platform.object_extension)
+    end
+    res
+  end
+
+  def quiet=(b)
+    ld.quiet = b
+    @quiet = b
+  end
+
+  def output=(s)
+    @output = s
+    ld.output = s
+  end
+
+  def makefile
+    m = Makefile.new
+    m.define_variable('CC', ':=', @path)
+    m.define_variable('LD', ':=', @ld.path)
+    return m
+  end
+
+  # Return the command formatted as a Makefile rule
+  def rule
+    [ '$(CC)', '-c', flags, '$(CFLAGS)', @sources ].flatten.join(' ')
+  end
+
+  # Return the complete command line to compile an object
+  def command
+    log.debug self.pretty_inspect
+
+    throw 'Invalid linker' unless @ld.is_a?(Linker)
+    throw 'One or more source files are required' unless @sources.length > 0
+#      cflags = default_flags
+#      cflags.concat @flags
+#    end
+#    throw cflags
+
+#    topdir = h[:topdir] || ''
+#    ld = @ld.clone
+#    ldadd = h[:ldadd]
+#    ld.flags = h[:ldflags]
+#    ld.output = Platform.pathspec(h[:output])
+#    ld.rpath = h[:rpath] if h[:rpath].length > 0
+
+#    inputs = h[:sources]
+#    inputs = [ inputs ] if inputs.is_a? String
+#    inputs = inputs.map { |x| Platform.pathspec(topdir + x) }
+#    throw 'One or more sources are required' unless inputs.count
+
+#TODO:if @combine
+# return [ @path, cflags, '-combine', ldflags, inputs, ldadd ].flatten.join(' ')
+#
+    
+    cmd = [ @path, '-c', flags, @sources ].flatten.join(' ')
+
+    cmd += Platform.dev_null if @quiet
+
+    log.debug "Compiler command: #{cmd}"
+
+    cmd
+  end
+
+  def flags
+    tok = @flags
+
+   # KLUDGE: remove things that CL.EXE doesn't understand
+#    if @path.match(/cl.exe$/i)
+#      cflags += ' '
+#      cflags.gsub!(/ -Wall /, ' ') #  /Wall generates too much noise
+#      cflags.gsub!(/ -Werror /, ' ')  # Could use /WX here
+#      cflags.gsub!(/ -W /, ' ')
+#      cflags.gsub!(/ -Wno-.*? /, ' ')
+#      cflags.gsub!(/ -Wextra /, ' ')
+#      cflags.gsub!(/ -fpic /, ' ')
+#      cflags.gsub!(/ -std=.*? /, ' ')
+#      cflags.gsub!(/ -pedantic /, ' ')
+#    end
+
+    # Set the output path
+    unless @output.nil?
+      outfile = Platform.pathspec(@output)
+      if vendor == 'Microsoft'
+        tok.push '"-IC:\Program Files\Microsoft Visual Studio 10.0\VC\include"' # XXX-HARDCODED
+        tok.push '/Fo' + outfile
+        tok.push '/MD'
+      else
+        tok.push '-o', outfile
+      end
+    end
+
+    if @ld.shared_library 
+      if Platform.is_windows?
+        throw 'FIXME'
+      else
+        tok.push '-fpic' unless is_mingw?
+      end
+    end
+
+    tok.push '--sysroot=' + @sysroot unless @sysroot.nil?
+
+    tok.join(' ')
+  end
+
+  def flags=(s)
+    @flags = s
+    @flags = @flags.split(' ') if @flags.kind_of?(String)
+  end
+
+  # Enable compiler and linker options to create a shared library
+  def shared_library=(b)
+    case b
+    when true
+      if Platform.is_windows?
+        # noop
+      else
+        @flags.push '-fpic'
+        @ld.shared_library = true
+      end
+    when false
+      # noop
+    else
+      throw 'Invalid value'
+    end
+  end
+
+  # Test if the compiler supports a command line option
+  def has_option(opt)
+
+    # Create a simple test file
+    f = Tempfile.new(['test_has_option', @extension]);
+    f.puts 'int main() { }'
+    f.flush
+
+#FIXME: /dev/null not portable
+    cmd = [ @path, opt, '-o /dev/null', '-c', f.path ].join(' ') + Platform.dev_null
+    Platform.execute cmd
+  end
+
+  # Check if a header is available
+  def check_header(path)
+    test_compile("#include <" + path + ">")
+  end
+
+  # Compile and link a test program
+  def test_link(code)
+    test_compile(code, :combined)
+  end
+
+  # Run the compilation command
+  def compile
+    cmd = self.command
+    log.debug "Invoking the compiler"
+    rc = Platform.execute cmd
+    log.debug "Compilation complete; rc=#{rc.to_s}"
+  end
+
+  # Compile a test program
+  def test_compile(code, stage = :compile)
+
+    # Write the code to a temporary source file
+    f = Tempfile.new(['test_compile', @extension]);
+    f.print code
+    f.flush
+###objfile = f.path + '.out'
+
+    # Run the compiler
+    cc = self.clone
+    cc.sources = f.path
+###    cc.output = objfile
+    cc.flags += '-o /dev/null' #FIXME: /dev/null not portable
+    cc.quiet = true
+    rc = cc.compile
+
+    # Delete the object file
+    objfile = File.basename( f.path.sub(@extension, '.o') )
+    File.unlink(objfile) if File.exist? objfile
+
+    return rc
+  end
+
+ 
+  # Try to determine a usable default set of compiler flags
+  def default_flags
+    cflags = []
+
+    # GCC on Solaris 10 produces 32-bit code by default, so add -m64
+    # when running in 64-bit mode.
+    if Platform.is_solaris? and Platform.word_size == 64
+       cflags.push '-m64'
+    end
+
+    cflags
+  end
+
+  private
+
+  # Special initialization for MS Windows
+  def windows_init
+    # FIXME: hardcoded to VS10 on C: drive, should pull the information from vcvars.bat
+    ENV['PATH'] = 'C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\;C:\Program Files\Microsoft Visual Studio 10.0\VC\BIN;C:\Program Files\Microsoft Visual Studio 10.0\Common7\Tools' + ENV['PATH']
+    ENV['INCLUDE'] = 'INCLUDE=C:\Program Files\Microsoft Visual Studio 10.0\VC\INCLUDE;C:\Program Files\Microsoft SDKs\Windows\v7.0A\include;'
+    ENV['LIB'] = 'C:\Program Files\Microsoft Visual Studio 10.0\VC\LIB;C:\Program Files\Microsoft SDKs\Windows\v7.0A\lib;'
+    ENV['LIBPATH'] = 'C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319;C:\WINDOWS\Microsoft.NET\Framework\v3.5;C:\Program Files\Microsoft Visual Studio 10.0\VC\LIB;'
+    ENV['VCINSTALLDIR'] = "C:\Program Files\\Microsoft Visual Studio 10.0\\VC\\"
+    ENV['VS100COMNTOOLS'] = "C:\\Program Files\\Microsoft Visual Studio 10.0\\Common7\\Tools\\"
+    ENV['VSINSTALLDIR'] = "C:\\Program Files\\Microsoft Visual Studio 10.0\\"
+    ENV['WindowsSdkDir'] = "C:\\Program Files\\Microsoft SDKs\\Windows\\v7.0A\\"
+  end
+
+  # Search for a suitable compiler
+  def search(compilers)
+    res = nil
+    if ENV['CC']
+      res = ENV['CC']
+    else
+      compilers.each do |command|
+         if (command =~ /^\// and File.exists?(command)) or Platform.which(command)
+           res = command
+           break
+         end
+      end
+    end
+
+    # FIXME: kludge for Windows, breaks mingw
+    if Platform.is_windows?
+        res = 'cl.exe'
+    end
+
+    throw 'No suitable compiler found' if res.nil? || res == ''
+
+    if Platform.is_windows? && res.match(/cl.exe/i)
+        help = ' /? <NUL'
+    else
+        help = ' --help'
+    end
+    
+    # Verify the command can be executed
+    cmd = res + help + Platform.dev_null
+    unless Platform.execute(cmd)
+       puts "not found"
+       print " -- tried: " + cmd
+       raise
+    end
+
+    puts res
+    res
+  end
+
+  # Return the name of the compiler vendor
+  def vendor
+    if @path.match(/cl.exe$/i)
+      'Microsoft'
+    else
+      'Unknown'
+    end
+  end
+end
+
+class CCompiler < Compiler
+
+  attr_accessor :output_type
+  attr_reader :path
+
+  def initialize(options = {})
+    @search_list = options.has_key?(:search) ? options[:search] : [ 'cc', 'gcc', 'clang', 'cl.exe']
+    @search_list = [ @search_list ] unless @search_list.kind_of?(Array)
+    @output_type = nil
+    super('C', '.c')
+    printf "checking for a C compiler.. "
+    @path = search(@search_list)
+  end
+
+  # Returns true if the compiler is MinGW
+  def is_mingw?
+    @path =~ /mingw/        # Kludge
+  end
+
+private
+
+  def log
+    Makeconf.logger
+  end
+
+end