makeconf 0.1.0

data/lib/makeconf/androidproject.rb

@@ -0,0 +1,310 @@
+class AndroidProject < BaseProject
+
+  attr_accessor :target_arch,
+                :target_arch_abi, 
+                :target_abi, 
+                :target_platform
+
+  def initialize(options)
+    super(options)
+
+    # Public
+    @target_platform = 'android-14'
+    @target_arch = 'arm'
+    @target_arch_abi = 'armeabi'
+    @target_abi = 'armeabi-v7a'
+    @ndk_path = nil
+    @sdk_path = nil
+
+    # Private
+    @prebuilt_libs = []
+
+    # KLUDGE: We need to know the NDK and SDK paths very early on.
+    # Peek at the original ARGV to find them.
+    Makeconf.original_argv.each do |arg|
+      if arg =~ /^--with-ndk=(.*)/
+         @ndk_path = $1
+      end
+      if arg =~ /^--with-sdk=(.*)/
+         @sdk_path = $1
+      end
+    end
+
+    self.ndk_toolchain_version = '4.6'
+  end
+
+  # Parse ARGV options
+  # Should only be called from Makeconf.parse_options()
+  # Note that ndk_path and sdk_path are previously parsed during initialize()
+  def parse_options(opts)
+    super(opts)
+
+    opts.separator ""
+    opts.separator "Android options:"
+
+    opts.on('--with-ndk=DIRECTORY', "Path to the Android NDK") do |arg|
+       @ndk_path = arg
+    end
+    opts.on('--with-sdk=DIRECTORY', "Path to the Android SDK") do |arg|
+       @sdk_path = arg
+    end
+
+  end
+
+  def ndk_toolchain_version
+    @ndk_toolchain_version
+  end
+
+  def ndk_toolchain_version=(version)
+    @ndk_toolchain_version = version
+
+    ndk_cc = toolchain_binary('gcc')
+
+    #FIXME -overwrites previous Compiler object
+    @cc = CCompiler.new(
+            :search => ndk_cc
+            ) 
+    @cc.sysroot = ndk_sysroot
+  end
+
+  def preconfigure
+
+    printf 'checking for the Android NDK.. '
+    throw 'Unable to locate the NDK. Please set the --with-ndk variable to the correct path' if @ndk_path.nil?
+    puts @ndk_path
+    printf 'checking for the Android SDK.. '
+    throw 'Unable to locate the SDK. Please set the --with-sdk variable to the correct path' if @sdk_path.nil?
+    puts @sdk_path
+  end
+
+  def to_make
+
+    write_android_mk
+    write_application_mk
+
+    # Generate the ndk-build command
+    ndk_build = '$(NDK)/ndk-build V=1 NDK_DEBUG=1 NDK_PROJECT_PATH=.'
+    unless @ndk_toolchain_version.nil?
+      ndk_build += " NDK_TOOLCHAIN_VERSION=#{@ndk_toolchain_version}"
+    end
+
+    mf = super
+
+    mf.define_variable('NDK_LIBDIR', ':=', ndk_libdir)
+    mf.define_variable('NDK', '?=', @ndk_path)
+    mf.define_variable('SDK', '?=', @sdk_path)
+    mf.define_variable('GDB', '?=', toolchain_binary('gdb'))
+    mf.define_variable('ADB', '?=', '$(SDK)/platform-tools/adb')
+    mf.target('all').rules.push ndk_build
+    
+    # Copy objects from obj/ to the top level, to match the behavior
+    # of non-Android platforms
+    # FIXME: this is very crude and should use the actual :output filenames
+    #        also, it will only copy libraries and not executables
+    #
+    mf.target('all').rules.push 'cp obj/local/*/*.a obj/local/*/*.so .'
+
+    # Generate the 'make clean' target
+    mf.target('clean').rules = [ ndk_build + ' clean' ]
+
+    # Generate the 'make check' target
+    mf.target('check').deps = []        # FIXME: should depend on 'all'
+    @build.each do |obj|
+      if obj.kind_of?(Test)
+        mf.target('check').rules.push([
+          '$(ADB) push libs/' + @target_abi + '/' + obj.output + ' /data/local/tmp',
+          '$(ADB) shell chmod 751 /data/local/tmp/' + obj.output,
+          '$(ADB) shell /data/local/tmp/' + obj.output,
+          '$(ADB) shell rm /data/local/tmp/' + obj.output
+          ])
+      end
+    end
+
+    # Run a $(BINARY) under the Android debugger
+    # see: http://www.kandroid.org/online-pdk/guide/debugging_gdb.html
+    mf.add_target('debug', [], [
+         '$(ADB) forward tcp:5039 tcp:5039',
+         '$(ADB) push $(BINARY) /data/local/tmp',
+         '$(ADB) shell chmod 751 /data/local/tmp/`basename $(BINARY)`',
+         '$(ADB) shell gdbserver :5039 /data/local/tmp/`basename $(BINARY)` &',
+         'sleep 2', # give gdbserver time to start
+  
+          # Pull things from the device that are needed for debugging
+          '$(ADB) pull /system/bin/linker obj/local/armeabi/linker',
+          '$(ADB) pull /system/lib/libc.so obj/local/armeabi/libc.so',
+          '$(ADB) pull /system/lib/libm.so obj/local/armeabi/libm.so',
+          '$(ADB) pull /system/lib/libstdc++.so obj/local/armeabi/libstdc++.so',
+  
+         'echo "set solib-search-path obj/local/armeabi" > .gdb-commands',
+         'echo "target remote :5039" >> .gdb-commands',
+         '$(GDB) -x .gdb-commands $(BINARY)',
+         'rm .gdb-commands',
+         ])
+  
+    # Connect to the device and run a shell
+    # TODO: add to makeconf
+    mf.add_target('shell', [], [ '$(ADB) shell' ])
+
+    mf
+  end
+
+  # Return the path to the Android NDK system root
+  def ndk_sysroot
+     @ndk_path + '/platforms/' + @target_platform + '/arch-' + @target_arch
+  end
+
+  # Return the path to the Android NDK /usr/lib 
+  def ndk_libdir
+     ndk_sysroot + '/usr/lib/'
+  end
+
+private
+
+  # Create the Android.mk makefile
+  def write_android_mk
+    ofile = 'Android.mk'
+    buf = [
+      '# Automatically generated by ./configure -- do not edit',
+      '',
+      'TARGET_PLATFORM := ' + @target_platform,
+      'TARGET_ARCH_ABI := ' + @target_arch_abi,
+      'LOCAL_PATH := $(call my-dir)',
+      '',
+    ]
+
+    @build.each do |obj|
+      next if obj.kind_of? Header
+      next if obj.kind_of? ExternalProject 
+      buf.push 'include $(CLEAR_VARS)',
+            '';
+
+      id = obj.id
+      id += '-static' if obj.kind_of? StaticLibrary
+
+      buf.push "LOCAL_MODULE    := #{id}"
+      buf.push "LOCAL_MODULE_FILENAME := #{obj.id}" if obj.kind_of? StaticLibrary
+      buf.push "LOCAL_SRC_FILES := " + obj.expand_sources(obj.sources).join(' ')
+      buf.push "LOCAL_CFLAGS    := " + obj.cflags.join(' ')
+      buf.push translate_ldadd(obj.ldadd) if obj.ldadd
+      buf.push ''
+      case obj.class.to_s
+      when 'StaticLibrary'
+        buf.push 'include $(BUILD_STATIC_LIBRARY)'
+      when 'SharedLibrary'
+        buf.push 'include $(BUILD_SHARED_LIBRARY)'
+      when 'Binary', 'Test'
+        buf.push 'include $(BUILD_EXECUTABLE)'
+      else
+        throw "Unsuported class #{obj.class}"
+      end
+      buf.push ''
+    end
+
+    buf.push prebuilt_libraries
+
+    puts 'creating ' + ofile
+    f = File.open(ofile, 'w')
+    buf.each do |str|
+      f.printf "#{str}\n" 
+    end
+    f.close
+  
+  end
+
+  # Create the jni/Application.mk makefile
+  def write_application_mk
+    ofile = 'jni/Application.mk'
+    buf = [
+      '# Automatically generated by ./configure -- do not edit',
+      'APP_PROJECT_PATH := .',
+      'APP_BUILD_SCRIPT := $(APP_PROJECT_PATH)/Android.mk',
+      'APP_PLATFORM     := ' + @target_platform,
+      'APP_ABI          := ' + @target_abi,
+      'APP_OPTIM        := debug',
+    ]
+
+    Dir.mkdir 'jni' unless File.exists?('jni')
+    puts 'creating ' + ofile
+    f = File.open(ofile, 'w')
+    buf.each do |str|
+      f.printf "#{str}\n" 
+    end
+    f.close
+  end
+
+private
+
+  # Translate LDADD flags into the corresponding Android.mk prebuilt definitions
+  def prebuilt_libraries
+    buf = []
+    @build.each do |obj|
+    # TODO: shared libs
+      obj.ldadd.each do |item|
+        next if provides?(item) or item =~ /^obj\/local\//
+        prebuilt = File.basename(item).sub(/\.a$/, '-prebuilt')
+        if item =~ /\.a$/ and item =~ /\// and not @prebuilt_libs.include? prebuilt
+           # FIXME: assumes it is a prebuilt library in a different path
+           buf.push('',
+              'include $(CLEAR_VARS)',
+              'LOCAL_MODULE := ' + File.basename(item).sub(/\.a$/, '-prebuilt'),
+              'LOCAL_SRC_FILES := ' + item,
+              'include $(PREBUILT_STATIC_LIBRARY)'
+              )
+           @prebuilt_libs.push prebuilt
+        end
+      end
+    end
+    buf.join "\n"
+  end
+
+  # Translate LDADD flags into the corresponding Android.mk variables
+  def translate_ldadd(ldadd)
+     static_libs = []
+     # TODO: shared libs
+     ldadd.each do |item|
+       if item =~ /\.a$/ 
+          if provides?(item) or item =~ /^obj\/local\//
+            static_libs.push File.basename(item).sub(/\.a$/, '-static')
+          else
+            static_libs.push File.basename(item).sub(/\.a$/, '-prebuilt')
+          end
+       end
+     end
+     
+     buf = ''
+     buf += 'LOCAL_STATIC_LIBRARIES := ' + static_libs.join(' ') if static_libs
+     buf
+  end
+
+  # Determine the path to the Android NDK
+  def find_ndk()
+    [ ENV['NDK'] ].each do |x|
+      if !x.nil? and File.exists?(x)
+        return x
+      end
+    end
+    nil
+  end
+
+  # Return the full path to a prebuilt binary in the toolchain
+  #
+  def toolchain_binary(file)
+
+    # Determine the type of prebuilt binary to use
+    if RbConfig::CONFIG['host_os'] =~ /linux/
+      build_os = 'linux-x86';
+    elsif RbConfig::CONFIG['host_os'] =~ /darwin/
+      build_os = 'darwin-x86';
+    else
+      throw 'Unknown build OS: ' + RbConfig::CONFIG['host_os']
+    end
+
+    @ndk_path +
+       '/toolchains/'+ @target_arch + '-linux-androideabi-' +
+       @ndk_toolchain_version +
+       '/prebuilt/' +
+       build_os +
+            '/bin/' + @target_arch + '-linux-androideabi-' + file
+  end
+
+end

data/lib/makeconf/baseproject.rb

@@ -0,0 +1,386 @@
+# A project contains all of the information about the build.
+# This is the base class from which all other Project subclasses are built
+#
+class BaseProject
+ 
+  require 'net/http'
+
+  attr_accessor :id, :version, :summary, :description, 
+        :author, :license, :license_file, :config_h
+
+  attr_reader :cc
+
+  # KLUDGE: remove these if possible                
+  attr_accessor :makefile, :installer, :packager
+
+  def log
+    Makeconf.logger
+  end
+
+  # Called by the object constructor
+  def initialize(options)
+    raise ArgumentError unless options.kind_of?(Hash)
+    @id = 'myproject'
+    @version = '0.1'
+    @summary = 'Undefined project summary'
+    @description = 'Undefined project description'
+    @license = 'Unknown license'
+    @license_file = nil
+    @author = 'Unknown author'
+    @config_h = 'config.h'
+    @header = {}        # Hash of system header availablity
+    @build = []         # List of items to build
+    @distribute = []    # List of items to distribute
+    @install = []       # List of items to install
+    @target = []        # List of additional Makefile targets
+    @decls = {}         # List of declarations discovered via check_decl()
+    @funcs = {}         # List of functions discovered via check_func()
+    @packager = Packager.new(self)
+    @cc = nil
+
+    # Provided by the parent Makeconf object
+    @installer = nil
+    @makefile = nil
+
+#    # Initialize missing variables to be empty Arrays 
+#    [:manpages, :headers, :libraries, :tests, :check_decls, :check_funcs,
+#     :extra_dist, :targets, :binaries].each do |k|
+#       h[k] = [] unless h.has_key? k
+#       h[k] = [ h[k] ] if h[k].kind_of?(String)
+#    end
+#    h[:scripts] = {} unless h.has_key?(:scripts)
+
+     # Generate a hash containing all the different element types
+     #items = {}
+     #%w{manpage header library binary test check_decl check_func extra_dist targets}.each do |k|
+     #  items[k] = xml.elements[k] || []
+     #end
+
+     options.each do |key,val|
+        #p "key=#{key} val=#{val}"
+       case key
+       when :id
+         @id = val
+       when :version
+         @version = val.to_s
+       when :cc
+         @cc = val
+       when :license_file
+         @license_file = val
+       when 'library', 'libraries'
+         val.each do |id, e|
+           build SharedLibrary.new(id, @cc.clone).parse(e)
+           build StaticLibrary.new(id, @cc.clone).parse(e)
+         end
+       when 'manpage'
+          manpage(val)  
+       when 'header'
+          header(val)  
+       when 'extra_dist'
+          distribute val 
+       when 'targets'
+          target val
+       when 'script', 'check_decl', 'check_func'
+          throw 'FIXME'
+            #items['script'].each { |k,v| script(k,v) }
+            #items['check_decl'].each { |id,decl| check_decl(id,decl) }
+#items['check_func'].each { |f| check_func(f) }
+       else
+          throw "Unknown option -- #{key}: #{val}"
+       end
+     end
+
+    # Determine the path to the license file
+    if @license_file.nil?
+      %w{COPYING LICENSE}.each do |p|
+        if File.exists?(p)
+            @license_file = p
+            break
+        end
+      end
+    end
+
+    @cc ||= CCompiler.new 
+
+
+    yield self if block_given?
+  end
+
+  # Parse ARGV options
+  # Should only be called from Makeconf.parse_options()
+  def parse_options(opts)
+    opts.separator ""
+    opts.separator "Project options:"
+#none yet
+  end
+
+  # Examine the operating environment and set configuration options
+  def configure
+
+    preconfigure if respond_to? 'preconfigure'
+
+    # Run each buildable object's preconfigure() method
+    @build.each { |x| x.preconfigure if x.respond_to? 'preconfigure' }
+
+    # Run each buildable object's configure() method
+    @build.each { |x| x.configure if x.respond_to? 'configure' }
+
+    postconfigure if respond_to? 'postconfigure'
+
+    # Run each buildable object's postconfigure() method
+    @build.each { |x| x.postconfigure if x.respond_to? 'postconfigure' }
+
+    # Build a list of local headers
+    local_headers = []
+    @build.each do |x| 
+      local_headers.concat x.makedepends
+    end
+    local_headers.sort!.uniq!
+
+    # Test for the existence of each referenced system header
+    sysdeps.each do |header|
+      printf "checking for #{header}... "
+      @header[header] = @cc.check_header(header)
+      puts @header[header] ? 'yes' : 'no'
+    end
+
+#    make_installable(@ast['data'], '$(PKGDATADIR)')
+#    make_installable(@ast['manpages'], '$(MANDIR)') #FIXME: Needs a subdir
+  end
+
+  # Return the Makefile for the project
+  # This should only be done after finalize() has been called.
+  def to_make
+    makefile = Makefile.new
+
+    makefile.add_dependency('dist', distfile)
+    makefile.distclean(distfile)
+    makefile.distclean(@config_h)
+    makefile.merge!(@cc.makefile)
+    makefile.merge!(@packager.makefile)
+    makefile.make_dist(@id, @version)
+    @distribute.each { |f| @makefile.distribute f }
+    @build.each { |x| makefile.merge!(x.build) if x.enable }
+    makefile.merge! @installer.to_make
+
+    # Add custom targets
+    @target.each { |t| makefile.add_target t }
+
+    makefile
+  end
+
+  def finalize
+    @packager.finalize
+    @build.each { |x| x.finalize }
+    @install.each { |x| @installer.install x }
+  end
+
+  # Check if a system header declares a macro or symbol
+  def check_decl(header,decl)
+      throw ArgumentError unless header.kind_of? String
+      decl = [ decl ] if decl.kind_of? String
+      throw ArgumentError unless decl.kind_of? Array
+
+       @cc ||= CCompiler.new() #FIXME: stop this
+
+      decl.each do |x|
+        next if @decls.has_key? x
+        printf "checking whether #{x} is declared... "
+        @decls[x] = @cc.test_compile "#define _GNU_SOURCE\n#include <#{header}>\nint main() { #{x}; }"
+        puts @decls[x] ? 'yes' : 'no'
+      end
+  end
+
+  # Check if a function is available in the standard C library
+  # TODO: probably should add :ldadd when checking..
+  def check_func(func)
+      func = [ func ] if func.kind_of? String
+      throw ArgumentError unless func.kind_of? Array
+
+       @cc ||= CCompiler.new() #FIXME: stop this
+      func.each do |x|
+        next if @funcs.has_key? x
+        printf "checking for #{x}... "
+        @funcs[x] = @cc.test_link "void *#{x}();\nint main() { void *p;\np = &#{x}; }"
+        puts @funcs[x] ? 'yes' : 'no'
+      end
+  end
+
+  def add_binary(options)
+    options[:cc] ||= @cc
+    id = options[:id] + Platform.executable_extension
+    build Binary.new(options)
+  end
+
+  def add(*objs)
+    objs.each do |obj|
+      if obj.kind_of?(Library)
+        obj.buildable.each do |e|
+           add(e)
+        end
+      else
+        obj.project = self if obj.kind_of?(Buildable)
+        build(obj)
+      end
+    end
+  end
+
+  # Add item(s) to build
+  # FIXME: this violates OOP encapsulation
+  def build(*arg)
+    arg.each do |x|
+
+      # Add a custom Makefile target
+      if x.kind_of? Target
+          @target.push x
+          next
+      end
+
+      unless x.respond_to?(:build)
+        pp x
+        throw ArgumentError.new('Invalid argument') 
+      end
+
+      if x.kind_of?(SharedLibrary) or x.kind_of?(StaticLibrary)
+        dest = '$(LIBDIR)'
+      else
+        dest = '$(BINDIR)'
+      end
+      sources = x.output
+      mode = '0755'
+
+      @build.push x
+
+      next if x.kind_of?(Header) #ugly
+
+      @install.push({ 
+        :sources => sources,
+        :dest => dest,
+        :mode => mode,
+        }) if x.installable
+    end
+  end
+
+  # Add item(s) to install
+  def install(*arg)
+    arg.each do |x|
+      # FIXME: shouldn't something be installed now?
+      @distribute.push Dir.glob(x)
+    end
+  end
+
+  # Add item(s) to distribute in the source tarball
+  def distribute(*arg)
+    arg.each do |x|
+      @distribute.push Dir.glob(x)
+    end
+  end
+
+  # Add a C/C++ header file to be installed
+  def header(path, opt = {})
+    throw ArgumentError, 'bad options' unless opt.kind_of? Hash
+    @install.push({ 
+        :sources => path,
+        :dest => (opt[:dest].nil? ? '$(INCLUDEDIR)' : opt[:dest]),
+        :mode => '0644',
+        })
+  end
+
+  # Add a manpage file to be installed
+  def manpage(path, opt = {})
+    throw ArgumentError, 'bad options' unless opt.kind_of? Hash
+    section = path.gsub(/.*\./, '')
+    @install.push({ 
+        :sources => path,
+        :dest => (opt[:dest].nil? ? "$(MANDIR)/man#{section}" : opt[:dest]),
+        :mode => '0644',
+        })
+  end
+
+  # Add a script to be installed
+  def script(id, opt = {})
+    throw ArgumentError, 'bad options' unless opt.kind_of? Hash
+    @install.push({ 
+        :sources => opt[:sources],
+        :dest => (opt[:dest].nil? ? "$(BINDIR)" : opt[:dest]),
+        :rename => opt[:rename],
+        :mode => '0755',
+        })
+  end
+
+  # Return the compiler associated with the project
+  def compiler(language = 'C')
+    throw 'Not implemented' if language != 'C'
+    throw 'Undefined compiler' if @cc.nil?
+    @cc
+  end
+
+  # Return a library definition
+  def library(id)
+    @ast['libraries'][id]
+  end
+
+  # Return a list of all system header dependencies for all Buildable
+  # objects in the project.
+  def sysdeps
+    res = []
+    @build.each do |x|
+      x.sysdep.each { |k,v| res.concat v }
+    end
+    res.sort.uniq
+  end
+
+  # Returns the filename of the source code distribution archive
+  def distfile
+    @id + '-' + @version.to_s + '.tar.gz'
+  end
+
+  # Generate the config.h header file
+  def write_config_h
+    ofile = @config_h
+    buf = {}
+
+    @header.keys.sort.each { |k| buf["HAVE_#{k}".upcase] = @header[k] }
+    @decls.keys.sort.each { |x| buf["HAVE_DECL_#{x}".upcase] = @decls[x] }
+    @funcs.keys.sort.each { |x| buf["HAVE_#{x}".upcase] = @funcs[x] }
+
+    puts 'creating ' + ofile
+    f = File.open(ofile, 'w')
+    f.print "/* AUTOMATICALLY GENERATED -- DO NOT EDIT */\n"
+    buf.keys.sort.each do |k|
+      v = buf[k]
+      id = k.upcase.gsub(%r{[/.-]}, '_')
+      if v == true
+        f.printf "#define #{id} 1\n"
+      else
+        f.printf "#undef  #{id}\n" 
+      end
+    end
+    f.close
+  end
+
+  # Add an additional Makefile target
+  def target(t)
+    throw ArgumentError.new('Invalid data type') unless t.kind_of?(Target) 
+    @target.push t
+  end
+
+#XXX fixme -- testing
+  def mount(uri,subdir)
+    x = Net::HTTP.get(URI(uri))
+    puts x.length
+  end
+
+  # Test if the project will build a library with a given pathname.
+  # This is used for inter-dependency analysis
+  def provides?(path)
+    fn = File.basename(path)
+    @build.each do |obj|
+       if obj.respond_to?(:output)
+         return true if obj.output == fn
+       end
+    end
+    return false
+  end    
+
+end