root/juggler/branches/2.0_alpha_4/configure.pl

#!/usr/bin/env perl

# ************** <auto-copyright.pl BEGIN do not edit this line> **************
#
# VR Juggler is (C) Copyright 1998-2003 by Iowa State University
#
# Original Authors:
#   Allen Bierbaum, Christopher Just,
#   Patrick Hartling, Kevin Meinert,
#   Carolina Cruz-Neira, Albert Baker
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#
# -----------------------------------------------------------------
# File:          $RCSfile$
# Date modified: $Date$
# Version:       $Revision$
# -----------------------------------------------------------------
#
# *************** <auto-copyright.pl END do not edit this line> ***************

use 5.005;

use strict 'vars';
use vars qw($base_dir $module $PRELUDE $FEATURE_ARGS $PACKAGE_ARGS $PROLOGUE
            $LAST_ARG_GROUP $OS $Win32 $CFG_LOAD_FUNC);
use vars qw(%MODULES);

use Cwd qw(chdir getcwd);
use File::Basename;
use File::Path;
use Getopt::Long;
use Pod::Usage;

BEGIN
{
   $base_dir = (fileparse("$0"))[1];
}

use lib("$base_dir");
use JugglerConfigure;

# Subroutine prototypes.
sub mergeArgArrays($$);
sub loadDefaultArgs($);
sub configureModule($);
sub regenModuleInfo($);
sub generateMakefile(;$);
sub generateReconfig($@);
sub listModules();
sub printHelp();
sub getConfigureHelp($$);
sub parseOutput($$);
sub getPlatform();
sub getRelativePath($$);

%MODULES = ();

my $all_help      = 0;
my $cfg           = "juggler.cfg";
my $user_cfg      = '';
$module           = '';
my $script_help   = 0;
my $manual        = 0;
my $regen         = 0;
my $mod_list      = 0;
my $args_file     = 'acdefaults.cfg';
my $args_mod_file = 'acdefaults.pl';
my $user_args     = '';
my $user_args_mod = '';
my $no_user_args  = 0;

$PRELUDE        = 0;
$FEATURE_ARGS   = 1;
$PACKAGE_ARGS   = 2;
$PROLOGUE       = 3;
$LAST_ARG_GROUP = 4;

$CFG_LOAD_FUNC = undef;
$OS            = '';

my @save_argv = @ARGV;

Getopt::Long::Configure('pass_through');
GetOptions('help|?' => \$script_help, 'cfg=s' => \$user_cfg,
           'module=s' => \$module, 'all-help' => \$all_help,
           'manual' => \$manual, 'regen' => \$regen, 'modlist' => \$mod_list,
           'args=s' => \$user_args, 'argsmod=s' => \$user_args_mod,
           'noargs' => \$no_user_args, 'os=s' => \$OS)
   or pod2usage(2);

# Print the help output and exit if --help was on the command line.
pod2usage(1) if $script_help;
pod2usage(-exitstatus => 0, -verbose => 2) if $manual;

die "ERROR: No configuration given\n" unless $cfg || $user_cfg;

$Win32 = 1 if $ENV{'OS'} && $ENV{'OS'} =~ /Windows/;

# On Windows, the command-line arguments can confuse the Cygwin shell.  For
# example, the character used to separate paths is ';', but the shell sees
# that as a statement separator.  We can deal with this by ensuring that the
# shell interprets command-line arguments as literal strings (i.e., by
# putting quotes around each argument).
if ( $Win32 ) 
{
   die "Absolute Cygwin paths confuse Visual C++.  Use a relative path.\n"
      if $0 =~ /^\//;

   for ( my $i = 0; $i <= $#save_argv; $i++ )
   {
      $save_argv[$i] = "\"$save_argv[$i]\"";
   }

   for ( my $i = 0; $i <= $#ARGV; $i++ )
   {
      $ARGV[$i] = "\"$ARGV[$i]\"";
   }
}

my $cfg_load = ("$user_cfg" eq "") ? "$base_dir/$cfg" : "$user_cfg";
%MODULES = JugglerConfigure::parseConfigFile("$cfg_load");

listModules() && exit(0) if $mod_list;
printHelp() && exit(0) if $all_help;

if ( $regen )
{
   if ( $module )
   {
      die "ERROR: No such module $module in $cfg!\n"
         unless defined($MODULES{"$module"});

      regenModuleInfo("$module");
      generateMakefile("$module");
   }
   elsif ( $JugglerConfigure::DEFAULT_MODULE &&
           defined($MODULES{"$JugglerConfigure::DEFAULT_MODULE"}) )
   {
      regenModuleInfo("$JugglerConfigure::DEFAULT_MODULE");
      generateMakefile("$JugglerConfigure::DEFAULT_MODULE");
   }
   else
   {
      foreach ( keys(%MODULES) )
      {
         regenModuleInfo("$_");
      }

      generateMakefile();
   }
}
else
{
   my $cache_file_set = 0;

   foreach ( @ARGV )
   {
      if ( /-cache-f/ )
      {
         $cache_file_set = 1;
         last;
      }
   }

   # Unless the user passed --noargs, try to find default argument values.
   unless ( $no_user_args )
   {
      my $args_mod = ("$user_args_mod" eq "") ? "$base_dir/$args_mod_file"
                                              : "$user_args_mod";

      # Figure out what argument file to load, if any.  If the user specified
      # a file name on the command line, it will be in $user_args.  Otherwise,
      # we fall back on $base_dir/$args_file.
      my $args_load = ("$user_args" eq "") ? "$base_dir/$args_file"
                                           : "$user_args";

      if ( -r "$args_mod" )
      {
         require "$args_mod";

         if ( $CFG_LOAD_FUNC )
         {
            my @default_args = &$CFG_LOAD_FUNC();
            mergeArgArrays(\@ARGV, \@default_args);
         }
      }
      elsif ( -r "$args_load" )
      {
         loadDefaultArgs("$args_load");
      }
   }

   if ( ! $cache_file_set )
   {
      my $cwd = getcwd();
      push(@ARGV, "--cache-file=$cwd/config.cache");
   }

   # Configure the module named on the command line.
   if ( $module )
   {
      die "ERROR: No such module $module in $cfg!\n"
         unless defined($MODULES{"$module"});

      generateReconfig("$module", @save_argv);
      configureModule("$module");
      generateMakefile("$module");
   }
   # If no module was named on the command line but we do have a default
   # module, configure it.
   elsif ( $JugglerConfigure::DEFAULT_MODULE &&
           defined($MODULES{"$JugglerConfigure::DEFAULT_MODULE"}) )
   {
      generateReconfig("$JugglerConfigure::DEFAULT_MODULE", @save_argv);
      configureModule("$JugglerConfigure::DEFAULT_MODULE");
      generateMakefile("$JugglerConfigure::DEFAULT_MODULE");
   }
   # If neither of the above will do, just configure every module we know
   # about from the input file.
   else
   {
      generateReconfig('', @save_argv);

      foreach ( keys(%MODULES) )
      {
         configureModule("$_");
      }

      generateMakefile();
   }
}

exit(0);

# =============================================================================
# Subroutines follow.
# =============================================================================

sub mergeArgArrays ($$)
{
   my $dest_list   = shift;
   my $source_list = shift;

   foreach ( @$source_list )
   {
      # Strip leading and trailing whitespace.
      s/^\s+//;
      s/\s+$//;
      next if /^$/;   # Just to be safe...
      
      # Only add the argument if it is not already on the command line.
      m/^(--[^=]+)/;
      push(@$dest_list, "$_") unless grep(/$1/, @$dest_list);
   }
}

sub loadDefaultArgs ($)
{
   my $args_load = shift;

   if ( open(ARGS_FILE, "$args_load") )
   {
      print "Loading default arguments from $args_load ...\n";
      my $args_contents = '';

      while ( <ARGS_FILE> )
      {
         s/#.*$//;           # Strip comments
         next if /^\s*$/;    # Skip blank lines
         $args_contents .= "$_";
      }

      close(ARGS_FILE) or warn "WARNING: Could not close $args_load: $!\n";

      my $platform = getPlatform();

      while ( "$args_contents" ne '' )
      {
         my @args_list = ();

         # Read in the arguments for all platforms.
         if ( $args_contents =~ /^\s*all\s*{(.+?)}\s*/si )
         {
            @args_list     = split(m|$/|, "$1");
            $args_contents = $';
         }
         # Read in the arguments for the current platform.
         elsif ( $args_contents =~ /^\s*$platform\s*{(.+?)}\s*/sio )
         {
            @args_list     = split(m|$/|, "$1");
            $args_contents = $';
         }
         # Skip a platform that does not match $platform.
         elsif ( $args_contents =~ /^\s*(\S+)\b\s*{(.+?)}\s*/s )
         {
            print "Skipping $1\n";
            $args_contents = $';
         }

         mergeArgArrays(\@ARGV, \@args_list);
      }
   }
   else
   {
      warn "WARNING: Coult not read from $args_load: $!\n";
   }
}

sub configureModule ($)
{
   my $module_name = shift;

   my $cwd = getcwd();
   my $safe_cwd;

   if ( $Win32 )
   {
      $safe_cwd = `cygpath -w $cwd`;
      chomp($safe_cwd);
      $safe_cwd =~ s/\\/\//g;
   }
   else
   {
      $safe_cwd = "$cwd";
   }

   die "ERROR: No module $module_name defined\n"
      unless defined($MODULES{"$module_name"});

   # Use ksh to run configure if we are on Solaris.  Otherwise, use sh
   my $shell = ((getPlatform() =~ /solaris/i) ? 'ksh' : '/bin/sh');

   my $depencency;
   foreach $depencency ( $MODULES{"$module_name"}->getDependencies() )
   {
      my $mod_path = $depencency->getPath();

      mkpath("$mod_path", 1, 0755) unless -d "$mod_path";

      # Do not try to proceed with $dependency unless we can chdir to
      # $mod_path.
      unless ( chdir("$mod_path") )
      {
         warn "WARNING: Could not chdir to $mod_path: $!\n";
         next;
      }

      my $src_root;

      # Dependeing on the value of $base_dir, assign $src_root such that it
      # is an absolute path.
      # XXX: This creates a problem on Win32 with $(srcdir) in generated
      # makefiles!  Win32 utilities will not understand the Cygwin path, but
      # they would understand a relative path...
      if ( $base_dir =~ /^\// )
      {
         $src_root = "$base_dir";
      }
      else
      {
         $src_root = "$cwd/$base_dir";
      }

      # Ensure $src_root isn't terminated with a '/'.
      $src_root =~ s/\/$//;

      # If we're being run in Win32, force a relative path for $src_root
      my $cfg_exec = "$src_root/$mod_path/configure";
      if ($Win32)
      {
         $cfg_exec = getRelativePath(getcwd(), $cfg_exec);
      }

      print "Running $shell $cfg_exec @ARGV\n";
      system("$shell $cfg_exec @ARGV 2>&1") == 0
         or die "Configuration of $module_name in $ENV{'PWD'} failed\n" .
                "Check $ENV{'PWD'}/config.log for details\n";

      my %mod_env = $depencency->getEnvironment();
      foreach ( keys(%mod_env) )
      {
         my $env_val = $depencency->getEnvironmentValue($_);

         if ( /_CONFIG$/ )
         {
            $ENV{"$_"}    = "$cwd/$mod_path/$env_val";
            $ENV{'PATH'} .= ":$cwd/$mod_path";
         }
         elsif ( /_BASE_DIR$/ )
         {
            if ( "$env_val" eq "instlinks" )
            {
               $ENV{"$_"} = "$safe_cwd/instlinks";
            }
            else
            {
               $ENV{"$_"} = "$env_val";
            }
         }
         else
         {
            $ENV{"$_"} = "$env_val";
         }
      }

      $ENV{'USE_BASE_DIR'} = 'yes';

      chdir("$cwd");
   }
}

sub regenModuleInfo ($)
{
   my $module_name = shift;

   my $cwd = getcwd();

   die "ERROR: No module $module_name defined\n"
      unless defined($MODULES{"$module_name"});

   my $depencency;
   foreach $depencency ( $MODULES{"$module_name"}->getDependencies() )
   {
      my $mod_path = $depencency->getPath();

      chdir("$mod_path")
         or die "WARNING: Could not chdir to $mod_path\n";
      system("./config.status 2>&1") == 0
         or die "Regeneration for $module_name in $ENV{'PWD'} failed\n";
      chdir("$cwd");
   }
}

sub generateMakefile (;$)
{
   my $gen_module = shift || '';

   open(INPUT, "$base_dir/Makefile.in")
      or die "ERROR: Could not read from $base_dir/Makefile.in: $!\n";

   my $input_file;
   while ( <INPUT> )
   {
      $input_file .= "$_";
   }

   close(INPUT);

   my $modules;
   my @module_array;

   if ( $gen_module )
   {
      foreach ( $MODULES{"$gen_module"}->getDependencies() )
      {
         $modules .= $_->getPath() . " ";
      }
   }
   else
   {
      my $mod_name;
      foreach $mod_name ( keys(%MODULES) )
      {
         my $temp_mod;
         foreach $temp_mod ( $MODULES{"$mod_name"}->getDependencies() )
         {
            $modules .= $temp_mod->getPath() . " ";
         }
      }
   }

   warn "WARNING: No modules defined!\n" unless $modules;

   my $cwd = getcwd();
   chdir("$base_dir");
   $input_file =~ s/\@JUGGLER_PROJECTS\@/$modules/g;

   if ( $Win32 )
   {
      # Get the Win32-friendly versions of these paths.  Then change the \'s
      # to /'s just to be safe.
      my $win_pwd = `cygpath -w $ENV{'PWD'}`;
      my $win_cwd = `cygpath -w $cwd`;
      chomp($win_pwd);
      chomp($win_cwd);

      $win_pwd =~ s/\\/\//g;
      $win_cwd =~ s/\\/\//g;

      $input_file =~ s/\@JUGGLERROOT_ABS\@/$win_pwd/g;
      $input_file =~ s/\@topdir\@/$win_cwd/g;
   }
   else
   {
      $input_file =~ s/\@JUGGLERROOT_ABS\@/$ENV{'PWD'}/g;
      $input_file =~ s/\@topdir\@/$cwd/g;
   }

   chdir("$cwd");

   print "Generating Makefile\n";
   open(OUTPUT, "> Makefile") or die "ERROR: Could not create Makefile: $!\n";
   print OUTPUT "$input_file";
   close(OUTPUT) or warn "WARNING: Failed to save Makefile: $!\n";
}

sub generateReconfig ($@)
{
   my $gen_module = shift;
   my @arg_list   = @_;

   my $modules;

   open(RECONFIG, "> reconfig");

   if ( $gen_module )
   {
      foreach ( $MODULES{"$gen_module"}->getDependencies() )
      {
         print RECONFIG "(cd " . $_->getPath() . " && rm -f config.status " .
                        "config.cache config.log)\n"
      }
   }
   else
   {
      my $mod_name;
      foreach $mod_name ( keys(%MODULES) )
      {
         foreach ( $MODULES{"$mod_name"}->getDependencies() )
         {
            print RECONFIG "(cd " . $_->getPath() . " && rm -f config.status " .
                           "config.cache config.log)\n"
         }
      }
   }

   print RECONFIG "rm -f config.cache\n";

   # Print the command to run this script again.  The actual output will be
   # the exec shell command followed by the full path to the Perl
   # interpreter used to run this script; the same path to the script that
   # the user entered; and the full argument list given on the command line.
   print RECONFIG "exec $^X $0 ", "@arg_list \n";
   close(RECONFIG);
   chmod(0755, "reconfig");
}

sub listModules ()
{
   my $mod_name;
   foreach $mod_name ( keys(%MODULES) )
   {
      print "$mod_name";

#      if ( $#{$MODULES{"$mod_name"}} != -1 )
#      {
#         print " (Requires:";
#
#         my $dep_ref;
#         foreach $dep_ref ( @{$MODULES{"$mod_name"}} )
#         {
#            print " ${$dep_ref}{'path'}";
#         }
#
#         print ")";
#      }

      print "\n";
   }

   return 1;
}

sub printHelp ()
{
   my @help_output = ();

   # Initialize the references that are contained within @help_output.
   my $i;
   for ( $i = 0; $i < $LAST_ARG_GROUP; $i++ )
   {
      $help_output[$i] = {};
   }

   if ( $module )
   {
      getConfigureHelp("$module", \@help_output);
   }
   elsif ( $JugglerConfigure::DEFAULT_MODULE &&
           defined($MODULES{"$JugglerConfigure::DEFAULT_MODULE"}) )
   {
      getConfigureHelp("$JugglerConfigure::DEFAULT_MODULE", \@help_output);
   }
   else
   {
      foreach ( keys(%MODULES) )
      {
         getConfigureHelp("$_", \@help_output);
      }
   }

   for ( $i = 0; $i < $LAST_ARG_GROUP; $i++ )
   {
      SWITCH:
      {
         if ( $i == $PRELUDE )
         {
            last SWITCH;
         }

         if ( $i == $FEATURE_ARGS )
         {
            print "Optional Features:\n";
            last SWITCH;
         }

         if ( $i == $PACKAGE_ARGS )
         {
            print "\nOptional Packages:\n";
            last SWITCH;
         }

         if ( $i == $PROLOGUE )
         {
            print "\n";
            last SWITCH;
         }
      }

      foreach ( sort(keys(%{$help_output[$i]})) )
      {
         print "${$help_output[$i]}{$_}";
      }
   }

   print "\n";

   print "Modules that may be built:\n";
   foreach ( keys(%MODULES) )
   {
      print "\t$_\n";
   }

   print "\nDefault module is $JugglerConfigure::DEFAULT_MODULE\n"
      if $JugglerConfigure::DEFAULT_MODULE;

   return 1;
}

sub getConfigureHelp ($$)
{
   my $mod_name    = shift;
   my $arg_arr_ref = shift;

   foreach ( $MODULES{"$mod_name"}->getDependencies() )
   {
      next unless -x "$base_dir/$$_{'path'}/configure";

      open(CFG_OUTPUT, "$base_dir/$$_{'path'}/configure --help |");

      my $cfg_output;
      while ( <CFG_OUTPUT> )
      {
         $cfg_output .= "$_";
      }

      close(CFG_OUTPUT);

      parseOutput("$cfg_output", $arg_arr_ref);
   }
}

sub parseOutput ($$)
{
   my $string      = shift;
   my $arg_arr_ref = shift;

   while ( $string !~ /^\s*$/s )
   {
      # Match everything up to the list of optional features.  This forms the
      # prelude of the help output.
      if ( $string =~ /^(Usage:.*)(Optional Features:)/s )
      {
         $string = "$2$'";
         ${$$arg_arr_ref[$PRELUDE]}{'all'} = "$1";
      }
      # Handle the --enable and --disable list of options.
      elsif ( $string =~ /^(Optional Features:.*)(Optional Packages:)/s )
      {
         $string = "$2$'";

         my @param_list = split(/\n/, "$1");

         # Loop over all the lines of output in the "Optional Features" block.
         my $i;
         for ( $i = 0; $i <= $#param_list; $i++ )
         {
            if ( $param_list[$i] =~ /(--(enable|disable)\S+)/ )
            {
               my $param = "$1";

               # If $param does not exist in the hash of feature arguments,
               # we need to add it.
               if ( ! exists(${$$arg_arr_ref[$FEATURE_ARGS]}{"$param"}) )
               {
                  # Add the first line of information for $param.
                  my $param_info = "$param_list[$i]\n";

                  # If the following lines are a continuation of the info for
                  # $param, add them to $param_info as well.
                  while ( $i + 1 <= $#param_list &&
                          $param_list[$i + 1] !~ /--(enable|disable)/ )
                  {
                     $param_info .= "$param_list[$i + 1]\n";
                     $i++;
                  }

                  # Store the complete information block for $param.
                  ${$$arg_arr_ref[$FEATURE_ARGS]}{"$param"} = "$param_info";
               }
            }
         }
      }
      # Handle the --with and --without list of options.
      elsif ( $string =~ /^(Optional Packages:.*)(Some influential)/s )
      {
         $string = "$2$'";

         my @param_list = split(/\n/, "$1");

         # Loop over all the lines of output in the "Optional Packages" block.
         my $i;
         for ( $i = 0; $i <= $#param_list; $i++ )
         {
            if ( $param_list[$i] =~ /(--with\S+)/ )
            {
               my $param = "$1";

               # If $param does not exist in the hash of package arguments,
               # we need to add it.
               if ( ! exists(${$$arg_arr_ref[$PACKAGE_ARGS]}{"$param"}) )
               {
                  # Add the first line of information for $param.
                  my $param_info = "$param_list[$i]\n";

                  # If the following lines are a continuation of the info for
                  # $param, add them to $param_info as well.
                  while ( $i + 1 <= $#param_list &&
                          $param_list[$i + 1] !~ /--with/ )
                  {
                     $param_info .= "$param_list[$i + 1]\n";
                     $i++;
                  }

                  # Store the complete information block for $param.
                  ${$$arg_arr_ref[$PACKAGE_ARGS]}{"$param"} = "$param_info";
               }
            }
         }
      }
      # We'll keep everything after the line beginning with "Some influential"
      # to form the prologue of the help output.
      elsif ( $string =~ /^(Some influential.*)$/s )
      {
         $string = "$'";   # This should be the empty string.
         ${$$arg_arr_ref[$PROLOGUE]}{'all'} = "$1";
      }
      # Match anything else and strip it from the output.
      elsif ( $string =~ /^.*$/m )
      {
         $string = $';
      }

      $string =~ s/^\s*//s;
   }
}

sub getPlatform ()
{
   my $platform = "unknown";

   # Prefer the user-defined platform type over any auto-detected value.
   if ( "$OS" ne '' )
   {
      $platform = "$OS";
   }
   elsif ( defined($ENV{'OS'}) )
   {
      $platform = "$ENV{'OS'}";
   }
   elsif ( defined($ENV{'OSTYPE'}) )
   {
      $platform = "$ENV{'OSTYPE'}";
   }
   elsif ( defined($ENV{'OS_TYPE'}) )
   {
      $platform = "$ENV{'OS_TYPE'}";
   }
   elsif ( defined($ENV{'HOSTTYPE'}) )
   {
      $platform = "$ENV{'HOSTTYPE'}";
   }
   # As a last resort, fall back on the use of uname(1).
   else
   {
      chomp($platform = `uname -s`);
   }

   # XXX: This is a hack to deal with weird OS strings such as "linux-gnu".
   # We just make the platform be "linux" unless the user set the platform
   # type on the command line.
   $platform = 'linux' if ! $OS && $platform =~ /linux/i;

   return $platform;
}

sub getHostname ()
{
   my $hostname = '';

   if ( defined($ENV{'HOSTNAME'}) )