makeconf 0.1.0

data/lib/makeconf/linker.rb

@@ -0,0 +1,171 @@
+# A linker combines multiple object files into a single executable or library file. 
+#
+class Linker
+
+  attr_accessor :output, :objects, :quiet, :shared_library
+  attr_reader :path
+
+  def initialize
+    @flags = []
+    @objects = []
+    @output = nil
+    @shared_library = false
+    @ldadd = []
+    @quiet = false          # If true, output will be suppressed
+
+    # Determine the path to the linker executable
+    @path = nil
+#TODO: support using Clang/GCC on windows
+#if vendor == 'Microsoft'
+    if Platform.is_windows?
+      @path = 'LINK.EXE'
+    else
+      @path = 'cc' #XXX-FIXME horrible
+    end
+
+    if ENV['CC']
+      @path = ENV['CC']
+    end
+    if ENV['LD']
+      @path = ENV['LD']
+    end
+  end
+
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # Sets the ELF soname to the specified string
+  def soname(s)
+    unless Platform.is_windows?
+     @flags.push ['soname', s]
+    end
+  end
+
+  # Add all symbols to the dynamic symbol table (GNU ld only)
+  def export_dynamic
+    unless Platform.is_windows?
+     @flags.push 'export-dynamic'
+    end
+  end
+
+  # Override the normal search path for the dynamic linker
+  def rpath=(dir)
+    if Platform.is_solaris?
+      @flags.push ['R', dir]
+    elsif Platform.is_linux?
+      @flags.push ['-rpath', dir]
+    elsif Platform.is_windows?
+      # XXX-FIXME Windows does not support the rpath concept
+      return
+    else
+      throw 'Unsupported OS'
+    end
+    @flags.push ['-L', dir]
+  end
+
+  # Returns the linker flags suitable for passing to the compiler
+  def flags
+     tok = []
+
+    # Set the output path
+    throw 'Output pathname is required' if @output.nil?
+    if Platform.is_windows?
+      tok.push "/OUT:\"#{@output}"
+    else
+      tok.push '-o', @output
+    end
+
+    # Enable shared library output
+    if @shared_library
+      if Platform.is_windows?
+        tok.push '/DLL'
+      else
+        tok.push '-shared'
+        tok.push '-fpic'        # TODO: sometimes -fPIC is needed
+      end
+    end
+
+    # Assume that we want to link with shared libraries
+    # built within this project
+    tok.push '-L', '.'
+
+    @flags.each do |f|
+       if f.kind_of?(Array)
+         tok.push '-Wl,-' + f[0] + ',' + f[1]
+       else
+         tok.push '-Wl,-' + f
+       end
+    end
+
+    return ' ' + tok.join(' ')
+  end
+
+  def command
+    # windows: 'link.exe /DLL /OUT:$@ ' + deps.join(' '))
+    # linux: 'cc ' .... (see Compiler::)
+    cmd = [ @path, flags, @objects, @ldadd ].flatten.join(' ')
+    cmd += Platform.dev_null if @quiet
+    log.debug "Linker command = `#{cmd}'"
+
+    return cmd
+  end
+
+  # Return the command formatted as a Makefile rule
+  def rule
+     ['$(LD)', flags, '$(LDFLAGS)', @objects, @ldadd, '$(LDADD)'].flatten.join(' ')
+  end
+
+  # Execute the linker command
+  def link
+    throw 'STUB'
+  end
+
+  def flags=(tok)
+    @flags = default_flags
+    return if tok.nil?
+    if tok.kind_of?(Array)
+      @flags.concat tok
+    elsif tok.kind_of?(String)
+      @flags.concat tok.split(' ') #XXX-broken, will not handle things like '-rpath /foo'
+    else
+      log.error tok.pretty_inspect
+      throw 'Invalid flag type'
+    end
+  end
+
+  # Try to determine a usable default set of linker flags
+  def default_flags
+    ldflags = []
+
+    # 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
+       ldflags.push '-m64'
+       ldflags.push '-R/usr/sfw/lib/amd64' if Platform.is_x86?
+    end
+
+    ldflags
+  end
+
+  # Add one or more libraries to the list of files to link
+  def library(lib)
+    case lib.class.to_s
+    when 'Array'
+      tok = lib
+    when 'String'
+      tok = lib.split(' ')
+    else
+      throw "Invalid value: #{lib.class}"
+    end
+    @ldadd.concat tok
+  end
+
+private
+
+  def log
+    Makeconf.logger
+  end
+
+end
+

data/lib/makeconf/makefile.rb

@@ -0,0 +1,126 @@
+# A Makefile is a collection of targets and rules used to build software.
+#
+class Makefile
+  
+  # Object constructor.
+  def initialize
+    @vars = {}
+    @targets = {}
+
+    %w[all check clean distclean install uninstall distdir].each do |x|
+        add_target(x)
+    end
+  end
+
+  # Define a variable within the Makefile
+  def define_variable(lval,op,rval)
+    throw "invalid arguments" if lval.nil? or op.nil? 
+    throw "variable `#{lval}' is undefined" if rval.nil?
+    @vars[lval] = [ op, rval ]
+  end
+
+  def target(object)
+    @targets[object]
+  end
+
+  def merge!(src)
+    throw 'invalid argument' unless src.is_a?(Makefile)
+    @vars.merge!(src.vars)
+    src.targets.each do |k,v|
+      if targets.has_key?(k)
+         targets[k].merge!(v)
+      else
+         targets[k] = (v)
+      end
+    end
+  end
+
+  def add_target(object,depends = [], rules = [])
+    if object.kind_of?(Target)
+      @targets[object.objs] = object
+    else
+      @targets[object] = Target.new(object,depends,rules)
+    end
+  end
+
+  def add_rule(target, rule)
+    add_target(target, [], []) unless @targets.has_key? target
+    @targets[target].add_rule(rule)
+  end
+
+  # Add a file to the tarball during 'make dist'
+  def distribute(path)
+    path = [ path ] if path.kind_of? String
+
+    path.each do |src|
+      # FIXME: support Windows backslashery
+      if src =~ /\//
+         dst = '$(distdir)/' + File.dirname(src)
+         @targets['distdir'].mkdir(dst)
+         @targets['distdir'].cp(src, dst)
+      else
+         @targets['distdir'].cp(src, '$(distdir)')
+      end
+    end
+  end
+
+  # Add a file to be removed during 'make clean'
+  # TODO: optimize by eliminating multiple rm(1) fork/exec
+  def clean(path)
+    add_rule('clean', Platform.rm(Platform.pathspec(path)))
+  end
+
+  # Add a file to be removed during 'make distclean'
+  # TODO: optimize by eliminating multiple rm(1) fork/exec
+  def distclean(path)
+    add_rule('distclean', Platform.rm(Platform.pathspec(path)))
+  end
+
+  def add_dependency(target,depends)
+    add_target(target, [depends], []) unless @targets.has_key? target
+    @targets[target].add_dependency(depends)
+  end
+
+  def make_dist(project,version)
+    distdir = project + '-' + version.to_s
+    # XXX-FIXME this should come from the Project
+    distfile = project + '-' + version.to_s + '.tar.gz'
+    tg = Target.new(distfile)
+    tg.add_rule(Platform.rmdir(distdir))
+    tg.add_rule("mkdir " + distdir)
+    tg.add_rule('$(MAKE) distdir distdir=' + distdir)
+    if Platform.is_windows? 
+
+# FIXME - Not implemented yet
+
+    else
+       tg.add_rule("rm -rf #{distdir}.tar #{distdir}.tar.gz")
+       tg.add_rule("tar cf #{distdir}.tar #{distdir}")
+       tg.add_rule("gzip #{distdir}.tar")
+       tg.add_rule("rm -rf #{distdir}")
+       clean("#{distdir}.tar.gz")
+    end
+    @targets[distfile] = tg
+  end
+
+  def to_s
+    res = ''
+    @vars.sort.each { |x,y| res += [x, y[0], y[1]].join(' ') + "\n" }
+    res += "\n\n"
+    res += "default: all\n"
+    targets.each { |x,y| throw "#{x} is broken" unless y.is_a? Target }
+    @targets.sort.each { |x,y| res += y.to_s }
+    res
+  end
+
+  def write(path)
+    f = File.open(path, 'w')
+    f.print "# AUTOMATICALLY GENERATED -- DO NOT EDIT\n"
+    f.print self.to_s
+    f.close
+  end
+
+  protected
+
+  attr_reader :vars, :targets
+end

data/lib/makeconf/packager.rb

@@ -0,0 +1,90 @@
+# A packager produces a package in the preferred OS format (e.g. RPM, DEB)
+class Packager
+
+  attr_reader :makefile
+
+  def initialize(project)
+    @project = project
+    @makefile = Makefile.new
+  end
+
+  def finalize
+    make_rpm_spec
+    @makefile.add_target(
+            'package',
+            ['clean', @project.distfile],
+     		['rm -rf rpm *.rpm',
+             'mkdir -p rpm/BUILD rpm/RPMS rpm/SOURCES rpm/SPECS rpm/SRPMS',
+             'mkdir -p rpm/RPMS/i386 rpm/RPMS/x86_64',
+		     "cp #{@project.distfile} rpm/SOURCES",
+  		     'rpmbuild --define "_topdir ./rpm" -bs rpm.spec',
+  	   	     'mv ./rpm/SRPMS/* .',
+      		 'rm -rf rpm',
+     		])
+    @makefile.add_rule('clean', Platform.rm('*.rpm')) # FIXME: wildcard is bad
+    @makefile.add_rule('distclean', Platform.rm('rpm.spec'))
+  end
+
+  # Generate an RPM spec file
+  def make_rpm_spec
+    puts 'creating rpm.spec'
+    f = File.open('rpm.spec', 'w')
+    f.puts <<EOF
+# DO NOT EDIT -- automatically generated by ./configure
+Name:       #{@project.id}
+Summary:    #{@project.summary}
+Version:    #{@project.version}
+Release:    1
+License:    #{@project.license}
+Vendor:     #{@project.author}
+Group:      System Environment/Libraries
+Source0:    %{name}-%version.tar.gz
+
+%description
+#{@project.description}
+
+%package devel
+Summary: Header files, libraries and development documentation for %{name}
+Group: Development/Libraries
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+This package contains the header files, static libraries and development
+documentation for %{name}. If you like to develop programs using %{name},
+you will need to install %{name}-devel.
+
+%prep
+%setup -q -n PROGRAM-VERSION
+
+%build
+./configure --prefix=/usr
+make
+
+%install
+make DESTDIR=%{buildroot} install
+
+%clean
+[ %{buildroot} != "/" ] && rm -rf %{buildroot}
+
+%post -p /sbin/ldconfig
+%postun -p /sbin/ldconfig
+
+%files
+%defattr(-,root,root)
+
+/usr/lib/*.so.*
+
+%files devel
+%defattr(-,root,root)
+
+/usr/lib/*.so
+/usr/include/*
+/usr/share/man/man3/*
+
+%changelog
+* Thu Jan 01 2011 Some Person <nobody@nobody.invalid> - #{@project.version}-1
+- automatically generated spec file
+EOF
+  f.close()
+  end
+end

data/lib/makeconf/platform.rb

@@ -0,0 +1,213 @@
+#
+# Abstraction for platform-specific system commands and variables
+# This class only contains static methods.
+#
+class Platform
+
+  attr_reader :host_os, :target_os
+
+  require 'rbconfig'
+
+  # TODO: allow target_os to be overridden for cross-compiling
+
+  @@host_os = RbConfig::CONFIG['host_os']
+  @@target_os = @@host_os
+
+  # Returns true or false depending on if the target is MS Windows
+  def Platform.is_windows?
+    @@target_os =~ /mswin|mingw/
+  end
+
+  # Returns true or false depending on if the target is Solaris
+  def Platform.is_solaris?
+    @@target_os =~ /^solaris/
+  end
+
+  # Returns true or false depending on if the target is Linux
+  def Platform.is_linux?
+    @@target_os =~ /^linux/
+  end
+
+  # Returns true or false depending on if the target is x86-compatible
+  def Platform.is_x86?
+    RbConfig::CONFIG['host_cpu'] =~ /^(x86_64|i386)$/ ? true : false
+  end
+
+  # Returns the name of the operating system vendor
+  def Platform.vendor
+    return 'Fedora' if File.exists?('/etc/fedora-release')
+    return 'Red Hat' if File.exists?('/etc/redhat-release')
+    return 'Debian' if File.exists?('/etc/debian_version')
+    return 'Unknown' 
+  end
+  
+  # Returns the native word size
+  def Platform.word_size
+    if @@host_os =~ /^solaris/
+      `/usr/bin/isainfo -b`.to_i
+    elsif @@host_os =~ /^linux/
+      if `/usr/bin/file /bin/bash` =~ /32-bit/
+        return 32
+      else
+        return 64
+      end
+    else
+      throw 'Unknown word size'
+    end
+  end
+
+  def Platform.archiver(archive,members)
+    if is_windows? && ! ENV['MSYSTEM']
+      'lib.exe ' + members.join(' ') + ' /OUT:' + archive
+    else
+      # TODO: add '/usr/bin/strip --strip-unneeded' + archive
+      'ar rs ' + archive + ' ' + members.join(' ')
+    end
+  end
+
+  # Create a directory and all of it's components
+  def Platform.mkdir(path)
+    if path.kind_of?(Array)
+        path = path.flatten.join(' ')
+    end
+    throw 'invalid path' if path.nil? or path == ''
+    if is_windows?
+       "mkdir '#{path}'"
+    else
+       "umask 22 ; mkdir -p '#{path}'"
+    end
+  end
+
+  # Remove a regular file
+  def Platform.rm(path)
+    if path.kind_of?(Array)
+        path = path.join(' ')
+    end
+    if is_windows? && ! ENV['MSYSTEM']
+      return 'del /F ' + path
+    else
+      return 'rm -f ' + path
+    end
+  end
+
+  # Remove a directory along with all of it's contents
+  def Platform.rmdir(path)
+    is_windows? ? "rmdir /S /Q #{path}" : "rm -rf #{path}"
+  end
+
+  def Platform.cp(src,dst)
+    if src.kind_of?(Array)
+      src = src.join(' ')
+    end
+
+    if is_windows? && ! ENV['MSYSTEM']
+      return "copy #{src} #{dst}"
+    else
+      return "cp #{src} #{dst}"
+    end
+  end
+
+  # Send all output to /dev/null or it's equivalent
+  def Platform.dev_null
+    if is_windows? && ! ENV['MSYSTEM'] 
+      ' >NUL 2>NUL' 
+    else
+      ' >/dev/null 2>&1'
+    end
+  end
+
+  # Send standard error to /dev/null or it's equivalent
+  def Platform.dev_null_stderr
+    if is_windows? && ! ENV['MSYSTEM'] 
+      ' 2>NUL' 
+    else
+      ' 2>/dev/null'
+    end
+  end
+
+  # The extension used for executable files 
+  def Platform.executable_extension
+    is_windows? ? '.exe' : ''
+  end
+
+  # The extension used for intermediate object files 
+  def Platform.object_extension
+    is_windows? ? '.obj' : '.o'
+  end
+
+  # The extension used for static libraries
+  def Platform.static_library_extension
+    is_windows? ? '.lib' : '.a'
+  end
+
+  # The extension used for shared libraries
+  def Platform.shared_library_extension
+    is_windows? ? '.dll' : '.so'
+  end
+
+  # Returns true if the current environment supports graphical display
+  def Platform.is_graphical?
+    return true if Platform.is_windows?
+    return true if ENV.has_key?('DISPLAY') and not ENV['DISPLAY'].empty?
+    return false
+  end
+
+  # Emulate the which(1) command
+  def Platform.which(command)
+    return nil if is_windows?      # FIXME: STUB
+    ENV['PATH'].split(':').each do |prefix|
+      path = prefix + '/' + command
+      return command if File.executable?(path)
+    end
+    nil
+  end
+
+  # Converts a slash-delimited path into a backslash-delimited path on Windows.
+  def Platform.pathspec(path)
+    if is_windows?
+      path.gsub(%r{/}) { "\\" }
+    else
+      path
+    end
+  end
+
+  # Run an external command. On Windows, the system() function uses
+  # cmd.exe which pops up an ugly DOS window.
+  def Platform.execute(cmd)
+    if is_windows?
+      # NEED INFO
+        #shell = WIN32OLE.new('Shell.Application')
+#shell.ShellExecute('cmd.exe', '', ,,
+
+# DOESNOT WORK
+#p = IO.popen(cmd)
+#        p.readlines
+#        return $?.exitstatus == 0 ? true : false
+
+
+        
+        # NOTE: requires Ruby 1.9
+#    pid = Process.spawn(cmd)
+#        pid, status = Process.waitpid2(pid)
+#        return status.exitstatus == 0 ? true : false
+
+        return system(cmd)
+    else
+        system(cmd)
+    end
+  end
+
+  # Returns true if the user is running as the superuser on Unix
+  # or has Administrator privileges on Windows.
+  def Platform.is_superuser?
+    if is_windows?
+      Process.euid == 0
+    else
+      system "reg query HKU\\S-1-5-19" + Platform.dev_null
+    end
+  end
+
+  if is_windows?
+    require 'win32ole'
+  end
+end

data/lib/makeconf/project.rb

@@ -0,0 +1,19 @@
+# A project contains all of the information about the build.
+#
+class Project
+ 
+  require 'makeconf/systemtype'
+  require 'makeconf/baseproject'
+  require 'makeconf/androidproject'
+
+  def self.new(options)
+    if SystemType.host =~ /-androideabi$/
+       object = AndroidProject.allocate
+    else
+       object = BaseProject.allocate
+    end
+    object.send :initialize, options
+    object
+  end
+
+end

data/lib/makeconf/systemtype.rb

@@ -0,0 +1,35 @@
+# Detect the build system type and allow for cross-compilation
+#
+class SystemType
+
+  # FIXME: detect 'build' properly
+  @@build = RbConfig::CONFIG['host_os']
+  @@host = nil
+  @@target = nil
+
+  ARGV.each do |arg|
+    case arg
+    when /^--build=(.*)$/
+      @@build = $1
+      puts "determining build system type.. #{@@build}"
+    when /^--host=(.*)$/
+      @@host = $1
+      puts "determining host system type.. #{@@host}"
+    when /^--target=(.*)$/
+      @@target = $1
+    end
+  end
+
+  def SystemType.build
+    @@build
+  end
+
+  def SystemType.host
+    @@host
+  end
+
+  def SystemType.target
+    @@target
+  end
+
+end