p4conf.rb #31

#*******************************************************************************
# Usage:
#
#	ruby p4conf.rb  --apidir=<path to api> \
#			--apibuild=<Perforce API build> \
#                      --gccver=[23]
#
#	<Perforce API build> should be the identifier of the Perforce API
#	build you downloaded from the website. This is the same as the
#	directory you got it from, but without the leading "bin.". For
#	example, if you downloaded the API build from:
#
#	http://www.perforce.com/downloads/perforce/r05.1/bin.linux26amd64/
#
#	then the API build identifier is 'linux26amd64'
#
#	--gccver defaults to 3 if not specified.
#
#*******************************************************************************
require 'mkmf'
require 'rbconfig'
require "getoptlong"

class ApiVersion
    def initialize( major, minor = nil )
	if( major.kind_of?( String ) && ! minor )
	    if( major =~ /(\d+)\.(\d+)/ )
		major = $1
		minor = $2
	    else
		raise( "Bad API version: #{major}" )
	    end
	end

	@major 	= major.to_i
	@minor	= minor.to_i
    end

    attr_reader :major, :minor

    include Comparable

    def to_s
	"#{major}.#{minor}"
    end

    def to_i
	major << 8 | minor
    end

    def <=>( other )
	hi = @major <=> other.major
	lo = @minor <=> other.minor

	return hi == 0 ? lo : hi
    end
end

#*******************************************************************************
# Prompt the user for something
#*******************************************************************************
def prompt( str, testproc )
    while true
	print( str + ": " )
	val = $stdin.gets.chomp
	break if ( testproc.call( val ) )
    end
    return val
end


#*******************************************************************************
# Find out as much info about the platform as we can. Ideally we want to
# determine the OS name, version and CPU architecture so we can decide
# which compiler flags should be used for the Perforce API for that
# platform.
#*******************************************************************************
def probe_platform

    #
    # Work out the target OS, Version, and Platform
    #
    $p4osplat = CONFIG[ 'host_cpu' ].upcase
    $p4osname = CONFIG[ 'host_os' ].upcase
    $p4osname = $p4osname.gsub( /MSWIN32(_\d+)?/, "NT" )
    $p4osname = $p4osname.split( "-" ).shift
    $p4osver  = ""

    # Translate Ruby's arch names into Perforce's. Mostly the same so
    # only the exceptions are handled here.
    if( $p4osplat =~ /^I.86$/ )
	$p4osplat = "X86"
    elsif( $p4osplat == "X86_64" )
	$p4osplat = "AMD64"
    elsif( $p4osplat == "POWERPC" )
	$p4osplat = "PPC"
    end

    # Now work out the OS version
    if( $p4osname == "NT" )
	$p4osver = ""
    elsif( $p4osname =~ /FREEBSD([0-9]+)/ )
	$p4osname = "FREEBSD"
	$p4osver = $1
    elsif( $p4osname =~ /DARWIN([0-9]+)/ )
	$p4osname = "DARWIN"
	$p4osver = $1
    elsif( $p4osname =~ /AIX(5)\.(\d)/ )
	# AIX osname looks like "aix5.3.0.0"
	$p4osname = "AIX"
	$p4osver = $1 + $2
    else
	# Try running a 'uname -r' to work out the version
	begin
	    $p4osver=`uname -r`
	    ver_re = /^(\d+)\.(\d+)/
	    if( md = ver_re.match( $p4osver ) )
		maj = md[1].to_i
		min = md[2].to_i

		# Convert Solaris 5.6 into 2.6.
		if( $p4osname == "SOLARIS" )
		    maj -= 3
		end

		$p4osver = maj.to_s + min.to_s
	    end
	rescue
	    # Nothing - if it failed, it failed.
	end
    end
end

#*******************************************************************************
# Allow the user to override our guesses as to the platform and provide
# an explicit API build version.
#*******************************************************************************
def override_platform( plat )

    archs = %w{ x86 amd64 ppc sparc arm axp }

    # Build the regular expression we're going to use, first as a string
    plat_re = '(\D+)(\d+)?('
    plat_re += archs.join( '|' )
    plat_re += ')?'

    # Now convert to a regexp
    plat_re = Regexp.new( plat_re )

    if( md = plat_re.match( plat ) )
	$p4osname = md[ 1 ].upcase
	$p4osver  = md[ 2 ] || ""
	$p4osplat = ( md[ 3 ] || "" ).upcase
    end
end

#*******************************************************************************
# Add the #define for const_char='const char' on platforms that need it
#*******************************************************************************
def set_const_char()
    $CFLAGS += %Q{-Dconst_char="const char" }
end
    
#*******************************************************************************
# Set platform specific compile options
#*******************************************************************************
def set_platform_cflags
    $CFLAGS += "-DOS_#{$p4osname} "
    $CFLAGS += "-DOS_#{$p4osname}#{$p4osver} "
    $CFLAGS += "-DOS_#{$p4osname}#{$p4osver}#{$p4osplat} "

    if( $p4osname == "NT" )
      $CFLAGS += "/DCASE_INSENSITIVE "
      $CFLAGS += "/MT "
    end

    if( $p4osname == "SOLARIS" )
	$CFLAGS += "-Dsolaris "
	# Solaris 2.7 and later require -Dconst_char="const char"
	if ( $p4osver.to_i >= 27 )
	    set_const_char()
	end
    elsif( $p4osname == "LINUX" && $p4osplat == "AMD64" )
	set_const_char()
    end

    if( $p4osname == "DARWIN" )
	$CFLAGS += "-DCASE_INSENSITIVE "
    end
end

#*******************************************************************************
# Set platform specific build options
#*******************************************************************************
def set_platform_opts
    if ( $p4osname == "CYGWIN" && $p4gccver == 2 )
	CONFIG[ "CC" ] = "gcc-2"
	CONFIG[ "CXX" ] = "g++-2"
	CONFIG[ "LDSHARED" ].gsub!( /g\+\+/, "g++-2" ) 
    elsif ( $p4osname == "DARWIN" && $p4gccver == 2 )
	CONFIG[ "CC" ] = "gcc2"
	CONFIG[ "CXX" ] = "g++2"
	CONFIG[ "LDSHARED" ].sub!( /^cc/, "g++2" ) 
    elsif ( $p4osname == "DARWIN" )
	CONFIG[ "LDSHARED" ] = CONFIG[ "CXX" ] + " -bundle"
    elsif ( $p4osname == "FREEBSD" )
	# FreeBSD 6 at least uses cc for linking by default
	CONFIG[ "LDSHARED" ].sub!( /^cc/, "c++" ) 
    end
end


#*******************************************************************************
# Use platform libs. Call *before* adding the API libs to preserve linking 
# order.
#*******************************************************************************
def use_platform_libs
    if ( $p4osname == "SOLARIS" )
	osver = `uname -r`
	osver.gsub!( /5\./, "2" )
	if ( osver == "25" )
	    $LDFLAGS += "/usr/ucblib/libucb.a "
	end
	use_lib( "nsl" )
	use_lib( "socket" )
    elsif ( $p4osname == "NT" )
	use_lib( "advapi32" )
	use_lib( "wsock32" )
	use_lib( "kernel32" )
	use_lib( "oldnames" )
	use_lib( "libcmt" )
    elsif( $p4osname == "CYGWIN" )
        # Clear out the bogus libs on cygwin.
        CONFIG[ "LIBS" ] = ""
    elsif( $p4osname == "DARWIN" && $p4osver.to_i >= 8 )
	$LDFLAGS += " -framework Carbon"
    end
end


#*******************************************************************************
# Set directory for the Perforce API 
#*******************************************************************************
def set_apidir( path )
    libdir = path + "/lib"
    libdir = File.directory?( libdir ) ? libdir : path 

    hdrdir = path + "/include/p4"
    hdrdir = File.directory?( hdrdir ) ? hdrdir : path

    $LIBPATH = [ libdir ] | $LIBPATH 
    $CFLAGS += " -I#{hdrdir} "
end

#*******************************************************************************
# Get the version of the Perforce API in a directory
#*******************************************************************************
def get_api_version( dir )
    #
    # 2007.2 and later APIs put the Version file in the 'sample' 
    # subdirectory. Look there if we can't find it in the API root
    #
    ver_file = dir + "/Version"
    unless File.exists?( ver_file )
	ver_file = dir + "/sample/Version"
	return nil unless File.exists?( ver_file )
    end

    re = Regexp.new( '^RELEASE = (\d+)[\. ](\d+)' )
    apiver = nil
    File.open( ver_file, "r" ) do
	|f|
	f.each_line do
	    |line|
	    if md = re.match( line ) 
		apiver = ApiVersion.new( md[ 1 ],  md[ 2 ] )
		break
	    end
	end
    end
    return apiver
end
		
#*******************************************************************************
# Function to check that the version of the API used is digestible
#*******************************************************************************
def check_api_version( ver )
    return true if ver <= $MAX_API_VERSION

    puts <<EOS

This version of P4Ruby was designed to be used with the #{$MAX_API_VERSION}
Perforce C++ API. It may not work with later versions of the API.

EOS
    print( "Would you like to continue (y/n): " )
    answer = $stdin.gets.chomp
    return false unless answer == "y"
    true
end

#*******************************************************************************
# function for generating a correctly formatted #define string
#*******************************************************************************
def define( macro, value, string=true )
    if( string )
	%Q{#define #{macro}\t"#{value}"}
    else
	%Q{#define #{macro}\t#{value}}
    end
end

#*******************************************************************************
#* Write the extconf.h file 
#*******************************************************************************
def write_extconf_h
    File.open( "extconf.h", "w" ) do
	|ch|
	ch.puts( "#include <version.h>" )
	ch.puts( define( "P4APIVER_STRING",	$apiver ) )
	ch.puts( define( "P4APIVER_ID", 	$apiver.to_i, false ) )
	ch.puts( define( "P4OSNAME",		$p4osname ) )
	ch.puts( define( "P4OSPLAT",		$p4osplat ) )
	ch.puts( define( "P4OSVER",		$p4osver ) )
	ch.puts( define( "P4CFLAGS", 		$CFLAGS.gsub( '"', '\"' ) ) )
	ch.puts( define( "P4LIBPATH",		$LIBPATH.join( ":" ) ) )
	ch.puts( define( "P4LIBS",   		$libs ) )
	ch.puts <<EOS
#if RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 6
#  define P4RUBY_FUNC_CAST( f ) ((VALUE (*)()) f)
#else
#  define P4RUBY_FUNC_CAST( f ) ((VALUE (*)( VALUE )) f)
#endif
EOS
    end
end

#*******************************************************************************
# Add a Perforce API library making sure it's properly named on NT
#*******************************************************************************
def api_lib( lib )
    rlib = lib
    rlib = "lib" + lib if ( $p4osname == "NT" )
    use_lib( rlib )
end
 
#*******************************************************************************
# Add a library to the link command bypassing lame have_library/find_library
# which utterly suck for C++ libs. 
# NOTE: Add libs in *reverse* order.
#*******************************************************************************
def use_lib( lib ) 
    $libs = append_library( $libs, lib )
end

#*******************************************************************************
# Function to write the makefile itself. This is mostly a wrapper around
# mkmf's create_makefile(), but due to some deficiencies in mkmf w.r.t C++
# sources, we occasionally have to edit the makefile
#*******************************************************************************
def write_makefile( name )
    create_makefile( name )
    if ( CONFIG[ "CXX" ] )
	# Then we need to add a definition of CXX to the makefile
	# or the build will fail on some platforms (Cygwin at least).
	File.unlink( "Makefile.tmp" ) if File.exists?( "Makefile.tmp" )
	File.rename( "Makefile", "Makefile.tmp" )
	inmf = File.open( "Makefile.tmp" )
	outmf = File.open( "Makefile", "w+" )
	seen = false
	inmf.each do
	    |line|
	    if ( !seen && line =~ /^CC = / )
		outmf.puts( "CXX = " + CONFIG[ "CXX" ] )
		seen = true
	    end
	    outmf.puts( line )
	end
	inmf.close
	outmf.close
	File.unlink( "Makefile.tmp" )
    end


end

#*******************************************************************************
# Start of main functionality
#*******************************************************************************

#
# Maximum version of the Perforce API this build of P4Ruby knows how to
# work with
#
$MAX_API_VERSION = ApiVersion.new( 2007, 2 )

opts = GetoptLong.new(
		[ "--apidir",	"-d", 	GetoptLong::REQUIRED_ARGUMENT ],
		[ "--apibuild",	"-b",	GetoptLong::REQUIRED_ARGUMENT ],
		[ "--gccver",		GetoptLong::REQUIRED_ARGUMENT ]
		)
$apidir = nil
$apiver = nil
$apibuild = nil
$p4gccver = 3

#*******************************************************************************
# C++ programs should be linked with g++ not with gcc. mkmf doesn't get that
# right, so we have to hack it a little here. This particularly affects
# gcc 3.x users as older gcc versions didn't mind too much. Since mkmf is
# pretty convoluted it seems the safest way to ensure that g++ is used is
# to update the CC value as that ripples through the Makefile
#*******************************************************************************

if ( CONFIG[ "CC" ] =~ /gcc/ )
    CONFIG[ "CC" ].sub!( /gcc/, "g++" )
    CONFIG[ 'LDSHARED' ].sub!( /gcc/, "g++" )
    CONFIG[ "CXX" ] = CONFIG[ "CC" ] unless CONFIG.has_key?( "CXX" )
end

opts.each do
    |opt,arg|
    if ( opt == "--apidir" )
	$apidir = File.expand_path( arg ) 
    elsif( opt == "--apibuild" )
	$apibuild = arg
    elsif( opt == "--gccver" )
	$p4gccver = arg[0,1].to_i 
    end
end

puts( "" )
puts( "Starting to configure P4/Ruby for building" )
puts( "" )

#
# Guess the platform we're on, and then allow the user to override our
# guesswork if necessary
#
probe_platform()
override_platform( $apibuild )

#
# If the user has not supplied the api directories or apiver we prompt for them
#
dirproc = Proc.new {
	    |dir|
	    dir = File.expand_path( dir )
	    if ( ! File.directory?( dir ) )
		puts( "No such directory. Try again" )
		false
	    else
		true
	    end
	}

if ( ! $apidir )
    $apidir = prompt( "Enter the path to the Perforce API", dirproc )
    $apidir = File.expand_path( $apidir )
end

# 
# Read the Version file in the API directory to find the API version string
# and add this to the build environment
#

#
# If we failed to work this out, we have to ask the user.
#
verproc = Proc.new {
	    |ver|
	    if( ver =~ /(\d+)\.(\d+)/ )
		true
	    else
		puts( "Not a valid Perforce version. Try again." )
		false
	    end
	}

$apiver = get_api_version( $apidir )
if( !$apiver )
    while( ! $apiver )
	$apiver = prompt( "Enter the version of the Perforce API", verproc )
    end
    $apiver = ApiVersion.new( $apiver )
end

# 
# Check that the version of the API is one we can cope with, or that the
# user wants to punt.
#
exit( 1 ) unless check_api_version( $apiver )

set_apidir( $apidir )
set_platform_opts()
set_platform_cflags()

#
# 2006.1 or later API builds always need const_char defined
#
sixone = ApiVersion.new( 2006, 1 )
set_const_char() if( $apiver >= sixone )

use_platform_libs()

# Perforce API libraries - in reverse order 
api_lib( "supp" )
api_lib( "rpc" )
api_lib( "client" )

# 
# OK, now we know what we're going to do, let's tell the user
#
puts <<EOS

P4/Ruby Configuration Summary
-----------------------------

Using Perforce API Version: #{$apiver}
API headers and libs from : #{$apidir}
OS name                   : #{$p4osname}
OS version                : #{$p4osver}
Platform                  : #{$p4osplat}
CFLAGS                    : #{$CFLAGS}
LIBPATH                   : #{$LIBPATH.join(":")}
libs                      : #{$libs}

EOS

puts( "Creating extconf.h" )
write_extconf_h
write_makefile( "P4" )