Attachment #5758 for issue #12442

View | Details | Raw Unified | Return to issue 12442
Collapse All | Expand All




#--------------------------------------------------------
#
my ( $outfile, $outfile_sh, $outfile_bat, $bootfile, $newline, $comment, $comment4nt, $compiler, $unsetenv, $setenv, $unset, $set, $ds, $ps, $cur_dir, 
     $par_dir, $I, $L, $D, $buildenv, $answer, $tmp, $Solaris, $Linux, $FreeBSD, $NetBSD, $Tru64, $Irix, $Irix64, $Winnt, $Macosx, $MINGWIN32,
     $WScomp, $GNUcomp, $platform, $cygwinver, $machine_type, $empty, $no_ant, $no_stl, $no_gcc_home, $no_gcc_include, 
     $no_gxx_include, $warnfile, $Warning, $result, $unsetvars, $unsetvarssh, $unsetvarsbat, $exportvars, $win_format_var, $perl_os);
#

#
# Help variables.
my ( $USR, $ETC, $BIN, $LIB, $INC, $INCLUDE, $DEV, $OPT, $LOCAL, $SOLENV, $SOLVER, $CONFIG, 
     $USR_BIN, $USR_LIB, $USR_LOCAL, $USR_CCS, $JAVA_LIB,
     $SOLARENVINC, $USR_DT, $USR_OPENWIN, $TCSH_PATH, $XLIB, $XINC,
     $CYGWIN, $language, $ASM_PATH, $UNZIP_PATH, $ps_STLPORT_LIB, $L_STLPORT_LIB,
     $STLPORT_stlport, $STLPORT_inc_stlport, $PERL_PATH );

# Environment variables.
my ( $oldPATH, $SRC_ROOT, $SO_HOME, $JAVA_HOME, $SHELL,
     $UPD, $SOLARUPD, $WORK_STAMP, $TF_ONE51, $TF_UCB, 
     $URD_ONLY, $SOLARROOT, $SOLARSRC, $RSCRES, $DEVROOT, $SOLARVER, $SOLARVERSION, $SOLARENV, 
     $STAR_INIROOT, $STAR_INIROOTOLD, $STAR_STANDLST, $STAR_SSCOMMON, $STAR_SSOLARINI, 

$Warning        = "";               # container for warning messages
$STLPORT4	= '@STLPORT4@';     # Location of STLport4
$MINGWIN32	= '@WITH_MINGWIN@'; # use MINGWIN32
$USE_SHELL	= '@USE_SHELL@';    # preferred shell
$USE_GCC3	= '@USE_GCC3@';     # use gcc3 (only for unxlngi4 and unxfbsd5i at the moment)
$CC			= '@CC@';           # C compiler
$CXX		= '@CXX@';          # C++ compiler
$EXCEPTIONS	= '@EXCEPTIONS@';   # Exception handling type
$ENABLE_DEBUG	= '@ENABLE_DEBUG@';  # Enable a debug build
$WRAPCMD	= "";				# Wrapper (only for Winnt)

#
#---------------------------------------------------------------

$ENABLEUNICODE        = "TRUE";
$NEW_JAR_PACK         = "TRUE";
$NO_BSYMBOLIC         = "TRUE";
$comment              = "#";           # UNIX script comment character
$comment4nt           = "rem";         # Windows 4nt script comment character
$GLIBC                = "";            # GLibc used, empty = no.

# Setting platform dependent constant values.
if ( $platform eq $Solaris ) 
{     print "Setting Solaris specific values... ";
if ($machine_type eq "i86pc")
{     $outfile        = "SolarisIntelEnv.Set";

      $PATH_SEPERATOR = $ps;
      $PROSWITCH      = "-DPRODUCT";
}
elsif ( $platform eq $NetBSD ) 
{  print "Setting NetBSD Sparc specific values... ";
   $outfile        = "NetBSDSparcEnv.Set"; 
   $BIG_SVX        = "TRUE";

   $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."sparc".$ds."client";
   $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."sparc".$ds."native_threads";
} 
elsif ( $platform eq $FreeBSD ) 
{     print "Setting FreeBSD specific values... ";
      $outfile        = "FreeBSDEnv.Set"; 
      $BIG_SVX        = "TRUE";

      $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."i386".$ds."client";
      $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."i386".$ds."green_threads";
} 
elsif ( $platform eq $Linux ) 
{
#Set machine_type specific values: 
   if (($machine_type eq "i686") or ($machine_type eq "i586"))

      $JRELIBDIR      = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."i386";
      $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."i386".$ds."client";
      $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."i386".$ds."native_threads";
      if ($USE_GCC3 eq  "TRUE")
	  {
         $OUTPATH     = "unxlngi4";
      }
      else
      {
         $OUTPATH     = "unxlngi3";
      }
   }
   elsif ($machine_type eq "sparc")
   {  print "Setting Linux Sparc specific values... ";

      $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."arm".$ds."client";
      $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."arm".$ds."native_threads";
   }
   #Conditional setting depending on gcc3 (on x86):
   if ($USE_GCC3 eq  "TRUE")
   {
      $CVER           = "C300";
   if (($machine_type eq "i686") or ($machine_type eq "i586"))
      {
        $OUTPATH      = "unxlngi4"
      }
   }
   else
   {
      $CVER           = "C295";
   if (($machine_type eq "i686") or ($machine_type eq "i586"))
      {
	$OUTPATH      = "unxlngi3"
      }
   }
   # General Linux settings:

      $BIG_SVX        = "TRUE";
      $COM            = "GCC";

      $PROSWITCH      = "-DPRODUCT";
      $XPVERSION      = "3"; 
}
elsif ( $platform eq $Tru64 ) 
{     print "Setting Tru64 specific values... ";
      $outfile        = "Tru64AlphaEnv.Set"; 
      $BIG_SVX        = "TRUE";

      $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."alpha".$ds."client";
      $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."alpha".$ds."native_threads";
} 
elsif ( $platform eq $Irix || $platform eq $Irix64 )
{     print "Setting Irix specific values... ";
      $outfile        = "IrixMipsEnv.Set";
      $BIG_SVX        = "TRUE";

            } else {
              $CVER           = "C295";
            }
      } else {
	  	$COM            = "C730";
        $CVER           = "C730";
        $OUTPATH        = "unxirxm3";

      $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."mips".$ds."client";
      $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."mips".$ds."native_threads";
}
elsif ( $platform eq $Winnt ) 
{ 
      $COMPATH        = PosixFormat('@COMPATH@');
      $PSDK_HOME      = PosixFormat('@PSDK_HOME@');

      $emergency      = "FALSE";
      $use_shl_versions = "TRUE";
      $MULTITHREAD_OBJ = "TRUE";
    if ( $MINGWIN32 eq "yes" )
    { print "Setting Windows NT cygwin mingwin32 specific values... ";
      $outfile        = "winmingw.set"; 
      $COM            = "GCC";
      # Change path to lower case.

      $INPATH         = $OUTPATH.$PROEXT;
      $GVERDIR        = $INPATH;
      $PATH_SEPERATOR = ':';
    }
    elsif ( '@USE_SHELL@' ne "4nt" )
    { print "Setting Windows NT cygwin without 4NT specific values... ";
      $outfile        = "winenv.set"; 
      $COM            = "MSC";
	  $WRAPCMD        = "guw.pl";

	  $CXX            = $WRAPCMD." ".$CXX;
      # Change path to lower case.
      # not realy usefull for *sh
      # $COMPATH      = lc $COMPATH;
      $CVER           = "MI200";
      $DLLSUFFIX      = "mi";
      $OUTPATH        = "wntmsci7";

      $GVERDIR        = $INPATH;
      $PATH_SEPERATOR = ':';
      $COMEX          = 7;
    }
    else
    { print "Setting Windows NT specific values... ";
      $outfile        = "winenv.set"; 
      $COM            = "MSC";
      # Change path to lower case.

      $GVERDIR        = $INPATH;
      $PATH_SEPERATOR = ';';
      $COMEX          = 7;
      $comment        = "rem";         # Windows script comment character
    }
}
elsif ( $platform eq $Macosx ) 
{     print "Setting Mac OS X/Darwin specific values... ";
      $outfile        = "MacosxEnv.Set"; 
      $BIG_SVX        = "TRUE";

      $PROSWITCH      = "-DPRODUCT";
      # GUIBASE is set below; may be "aqua" or "unx".
}
elsif ( $platform eq "AIX" )
{
   $machine_type = `uname -p`;  # trust AIX to be different!
   chomp( $machine_type );
   if( $machine_type ne "powerpc" )
   {
   		print "\nAIX has only been ported and tested on powerpc\n";
		AddWarn( "set_soenv", "Machine type $machine_type has not been tested");
   }
   print "Setting Linux PPC specific values... ";
   $outfile        = "aixPPCEnv.Set"; 
   $CPU            = "P";
   $CPUNAME        = "POWERPC";
   $DLLSUFFIX      = "ap";
   $OUTPATH        = "unxlngppc";
   $JRELIBDIR      = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."ppc";
   $JRETOOLKITDIR  = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."ppc".$ds."classic";
   $JRETHREADDIR   = '$JAVA_HOME'.$ds."jre".$ds."lib".$ds."ppc".$ds."native_threads";
   $BIG_SVX        = "TRUE";
   $COM            = "GCC";
   $COMPATH        = '@COMPATH@'; 
   # $GLIBC          = "2REDHAT60";
   $GUI            = "UNX";
   $GUIBASE        = "unx";
   $GUIENV         = "sal";
   $GVER           = "VCL";
   $INPATH         = $OUTPATH.$PROEXT;
   $GVERDIR        = $INPATH;
   $OS             = "AIX";
   $PATH_SEPERATOR = $ps;
   $PROSWITCH      = "-DPRODUCT";
   $XPVERSION      = "3"; 
}
else {
	print "\nset_soenv:  Cannot figure out what platform you are running\n";
	print "For $platform and machine type $machine_type\n";
	exit 1;
}
print "done\n";

#

# JAVA_HOME as argument from autoconf.
$JAVA_HOME = PosixFormat('@JAVA_HOME@') ;

if ( $platform eq $Winnt ) {
   $JAVA_HOME =~ s/[\s\/]+$//;	# remove trailing \n or \/ if there is any.
}
# 3. Tcsh path.
# Check whether autoconf found the Tcsh path.
if ('@USE_SHELL@' eq "tcsh") 
{  # SHELL as argument from autoconf.
   $SHELL = '@TCSH@'."\/tcsh";
   $TCSH_PATH = '@TCSH@';


if ( '@STLPORT4@' eq $no_stl )
{
   $STLPORT4 = $no_stl;
}

# ml.exe assembler path for Windows users.
if ($platform eq "$Winnt")
{  $ASM_PATH = PosixFormat('@ASM_HOME@');
}
# unzip.exe path for Windows users.
if ($platform eq $Winnt)
{  $ASM_PATH = PosixFormat('@ASM_HOME@');
   $UNZIP_PATH = PosixFormat('@UNZIP_HOME@');
# 4. Gcc path.
# Check whether autoconf found the compiler path.
if (($platform eq $Linux) or ($platform eq $NetBSD) or ($platform eq $FreeBSD) or 
    ( ($platform eq $Irix ) or ($platform eq $Irix64) and ($compiler eq "gcc")) ) 
{    # GCC_HOME is not needed.
      $GCC_HOME = $no_gcc_home;
}

#
# E. Determining the envionment values based on the information
#    that was gathered earlier on.

$COMMON_BUILD_TOOLS   = '$SRC_ROOT'.$ds."external".$ds."common";

# Generate alternate output file for sh?
if ('@USE_SHELL@' eq "tcsh")
{  $outfile_sh = $outfile.".sh";
}
else

}

# Generate output file for 4nt?
if ('@USE_SHELL@' eq "4nt")
{  $outfile_bat = $outfile;
   $outfile_bat =~ s/set$/bat/i;
}



# Windows NT only variables
if ($platform eq $Winnt)
{  
   if ( $JAVA_HOME ne "" )
   {

   $WIN_TOUCH            = '$CYGWIN'.$ds."touch.exe";
}

if ( $JAVA_HOME ne "" )
{
   $JAVA_BIN             = $JAVA_HOME.$BIN;
   $JAVA_INCLUDE         = $JAVA_HOME.$ds."include";
}
$PERL                 = PosixFormat('@PERL@'); # Perl program
$PERL_PATH            = dirname('@PERL@'); # Perl Path 
$XLIB                 = PosixFormat('@XLIB@'); # X11 libraries



# Mac OS X/Darwin only variables.
if ( $platform eq $Macosx )
{  $FRAMEWORKSHOME       = $ds."System".$ds."Library".$ds."Frameworks";
   if ( $XLIB eq "no_x_libraries" ) {
      $GUIBASE  = "aqua";

# Location of the JDK supported standard classes.zip file.
# see above for why the change
$XCLASSPATH           = '$JAVA_HOME'.$ds.'jre'.$LIB.$ds."rt.jar".$ps.'.';

# Paths to run time shared libraries.
if ($platform eq $Solaris) 
{  $LD_LIBRARY_PATH   = $cur_dir.
                        $ps.$USR_DT.$LIB.
                        $ps.$USR_OPENWIN.$LIB.

                        $ps.$JRETHREADDIR.
                        $ps.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB;
}
elsif (($platform eq $Linux) || ($platform eq $NetBSD) ||
       ($platform eq $Tru64) || ($platform eq $FreeBSD) ||
	   ($platform = "AIX") )
{  $LD_LIBRARY_PATH   = $cur_dir.
                        $ps.'$SOLARENV'.$ds.'$INPATH'.$LIB.
                        $ps.$JRELIBDIR.

                        $ps.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                       $ps.$ENV{'LD_LIBRARY_PATH'};
}
elsif ($platform eq $Irix || $platform eq $Irix64)
{  $LD_LIBRARY_PATH   = $cur_dir.
                        $ps.'$SOLARENV'.$ds.'$INPATH'.$LIB.
                        $ps.$JRELIBDIR.
                        $ps.$JRETOOLKITDIR.
                        $ps.$JRETHREADDIR.
                        $ps.$par_dir.$LIB.
			$ps_STLPORT_LIB.
                        $ps.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB;
}
elsif ($platform eq "$Irix" || $platform eq "$Irix64")
{  $LD_LIBRARY_PATH   = $cur_dir.
                        $ps.'$SOLARENV'.$ds.'$INPATH'.$LIB.
                        $ps.$JRELIBDIR.

{  $LD_LIBRARY_PATH   = '$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                        $ps_STLPORT_LIB;
}
else
{  AddWarning( "set_soenv", "$platform not configured for runtime shared libraries" );
}
	
# Compiler directives.
if ($platform eq $Solaris) 
{  $SOLARDEF          = $D."UNX".
                        $D.$COM.
                        $D.$GVER.
                        $D."_PTHREADS".
                        $D."NO_AUDIO".
                        $D."SYSV".
                        $D.$OS.
                        $D.$CPUNAME.

                        $D."PRODUCT".
                        $D."UPDVER=".'""'."'".'"'."'".'"'."SV$UPD".'"'."'".'"'."'".'"'.'"';
}
elsif (($platform eq $Linux) || ($platform eq $NetBSD) ||
       ($platform eq $FreeBSD) || ($platform eq $Tru64) ||
	   ($platform eq $Irix) || ($platform eq $Irix64) || ($platform eq "AIX") )
{  $SOLARDEF          = $D."UNX".
                        $D.$COM.
                        $D.$CVER.
                        $D.$GVER.
                        $D.$OS.
                        $D.$CPUNAME;
    if  ($platform eq $FreeBSD)
    {  $SOLARDEF     .= $D."X86".
                        $D."OSVERSION=$OSVERSION".
			" ".$PTHREAD_CFLAGS;
    }
    $SOLARDEF        .= $D."_REENTRANT".
                            $D."_POSIX_PTHREAD_SEMANTICS";
    if  ($GLIBC ne "" )
    {  $SOLARDEF     .= $D."GLIBC=".$GLIBC;
    }
    $SOLARDEF        .= $D."SUPD=$UPD".
                        $D."PRODUCT".
                        $D."UPDVER=".'""'."'".'"'."'".'"'."SV$UPD".'"'."'".'"'."'".'"'.'"';
}
else
{  AddWarning( "set_soenv", "$platform not configured for compiler directives" );
}

# Location used by the linker to create libraries.
if ($platform eq $Solaris) 
{  $SOLAREXTRALIB     = $L.$par_dir.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$ds."lib.solaris.2.6".
                        $L.$LIB.

                        $L.$USR_DT.$LIB.
                        $L.$USR_OPENWIN.$LIB;
}
elsif (($platform eq $Linux) || ($platform eq $NetBSD) ||
       ($platform eq $Tru64) || ($platform eq $Irix) ||
	   ($platform eq $Irix64) || ($platform eq $FreeBSD) || ($platform eq "AIX"))
{
   $SOLAREXTRALIB     = $L.$par_dir.$LIB;
}
elsif ($platform eq $Macosx) 
{  $SOLAREXTRALIB     = $L.$LIB.
                        $L.$USR.$LIB;
}
else
{  AddWarning( "set_soenv", "$platform not configured for linkage create libraries" );
}

# Compiler include search directory paths.
if (($platform eq $Solaris) || ($platform eq $Linux) ||
    ($platform eq $FreeBSD) || ($platform eq $NetBSD) ||
	($platform eq $Tru64)   || ($platform eq $Irix) ||
	($platform eq $Irix64)  || ($platform eq "AIX" )) 
{  $SOLARINCLUDES     = $I.'$SOLARENV'.$INC;
}
elsif ($platform eq $Winnt)
{  $SOLARINCLUDES     = $I.$SOLARVER.$INC.
                        $I.$SOLARENV.$ds.$INPATH.$INC.
                        $I.$SOLARENV.$INC.
                        $I."'".$PSDK_HOME.$INCLUDE."'".
                        $I.'$COMPATH'.$ds."include";
}
elsif ($platform eq $Macosx)
{  $SOLARINCLUDES     = $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.
                        $I.'$SOLARENV'.$ds.'$OUTPATH'.$INC.
                        $I.'$SOLARENV'.$INC.
                        $I.'$SRC_ROOT'.$ds."res";
}                        
else
{  AddWarning( "set_soenv", "$platform not configured for compiler search paths" );
}
                        
# Windows NT only variables
if ($platform eq $Winnt)
{  $COMP_ENV          = $OUTPATH;

   $JAVAHOME          = '$JAVA_HOME';

}
     
# The general environment path.
if ($platform eq $Solaris) 
{  $PATH              = $cur_dir.
                        $ps.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$BIN.
                        $ps.'$SOLARENV'.$ds.'$OUTPATH'.$BIN.


   $PATH             .= $ps.$oldPATH;
}
elsif (($platform eq $Linux)  || ($platform eq $NetBSD) ||
       ($platform eq $Tru64)  || ($platform eq $Irix) ||
	   ($platform eq $Irix64) || ($platform eq $FreeBSD) || ($platform = "AIX"))
{  $PATH              = $cur_dir.
                        $ps.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$BIN.
                        $ps.'$SOLARENV'.$ds.'$OUTPATH'.$BIN.


}

elsif ($platform eq $Winnt)
{ 
   my ( $noldPATH );
   $noldPATH = $oldPATH;

	$PATH          .= $ps.'${PERL_PATH}';
   }
   # Check if $TCSH_PATH is already set in PATH
   if ( ( "'@USE_SHELL@'" eq "tcsh" ) && ( ! $noldPATH =~ /(?:[:]|\A)(?:$TCSH_PATH)(?:[:]|\Z)/ ) )
   {   $PATH          .= $ps.$TCSH_PATH;
   }
   if ($ASM_PATH ne "ASM_IN_PATH")

                        $ps.$USR.$ds."X11R6".$BIN.
                        $ps.$USR_LOCAL.$ds."sbin";
                        
  # PATHEXTRA variable for Macosx.
  $PATHEXTRA         = $USR_BIN.
                        $ps.$BIN.
                        $ps.$USR.$ds."sbin".
                        $ps.$ds."sbin".
                        $ps.'$SOLARENV'.$BIN;
}
else
{  AddWarning( "set_soenv", "$platform not configured for general environment paths" );
}

# Linker library search directory paths. 
if ($platform eq $Solaris) 
{  $SOLARLIB          = $L.$par_dir.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB.
                        $L.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.

                        $L_STLPORT_LIB.
                        $L.$XLIB;
}
elsif (($platform eq $Linux)  || ($platform eq $NetBSD) ||
       ($platform eq $Tru64)  || ($platform eq $Irix) ||
	   ($platform eq $Irix64) || ($platform eq "AIX"))
{  $SOLARLIB          = $L.$par_dir.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB.
                        $L.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB.
                        $L.'$JAVA_HOME'.$LIB.

                        $L_STLPORT_LIB.
                        $L.$XLIB;
}
elsif ($platform eq $FreeBSD)
{  $SOLARLIB          = $L.$par_dir.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB.
                        $L.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB.
                        $L.'$JAVA_HOME'.$LIB.
                        $L_STLPORT_LIB.
                        $L.$XLIB;
}
elsif ($platform eq $Winnt)
{  $SOLARLIB          = $L.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                        $L.$par_dir.$LIB.
                        $L_STLPORT_LIB.
                        $L.'$SOLARENV'.$ds.'$OUTPATH'.$LIB;
} 
elsif ($platform eq $Macosx) 
{  $SOLARLIB          = $L.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$LIB.
                        $L_STLPORT_LIB.
                        $L.$USR_LIB;
    # [ed] 6/15/02 Add in X11 libraries onto the library path
    if ($GUIBASE eq "unx") {
       $SOLARLIB      .= $L.$XLIB;
    }

}
else
{  AddWarning( "set_soenv", "$platform not configured for linker search directories" );
                        $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.$ds."stl".
                        $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.$ds."external".
                        $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.
                        $I.'$SOLARENV'.$ds.'$OUTPATH'.$INC.
                        $I.'$SOLARENV'.$INC.
                        $I.'$SRC_ROOT'.$ds."res";

if (($platform eq "$Solaris") or ($platform eq "$Linux") or ($platform eq "$Tru64") or ($platform eq "$FreeBSD") or ($platform eq "$NetBSD") or ($platform eq "$Irix") or ($platform eq "$Irix64"))
{
$SOLARINC	     .= $STLPORT_stlport;
if ($platform eq "$Linux" || $platform eq "$FreeBSD")
{
# This simply adds an include path, so even cases that break the FHS work
$SOLARINC            .= $STLPORT_inc_stlport;
}
if ($platform eq "$Solaris")
{
$SOLARINC            .= '/SC5 ';
}
# Platform dependent include path at the top of this list of include paths
if ($platform eq "$Solaris") 
{  $SOLARINC         .= $I.'$COMPATH'.$ds."include";
}

# Location of the compiler include search directory paths.
$SOLARINC         = $I.$cur_dir.
                    $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.$ds."stl".
                    $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.$ds."external".
                    $I.'$SOLARVER'.$ds.'$UPD'.$ds.'$INPATH'.$INC.
                    $I.'$SOLARENV'.$ds.'$OUTPATH'.$INC.
                    $I.'$SOLARENV'.$INC.
                    $I.'$SRC_ROOT'.$ds."res";

if (($platform eq $Solaris) || ($platform eq $Linux) || ($platform eq $Tru64) ||
    ($platform eq $FreeBSD) || ($platform eq $NetBSD) || ($platform eq $Irix) ||
	($platform eq $Irix64)  || ($platform eq "AIX"))
{
    $SOLARINC	  .= $STLPORT_stlport;
    if ($platform eq $Linux || $platform eq $FreeBSD)
    {
      # This simply adds an include path, so even cases that break the FHS work
      $SOLARINC   .= $STLPORT_inc_stlport;
    }
    # Platform dependent include path at the top of this list of include paths
    elsif ($platform eq $Solaris) 
    {  $SOLARINC  .= '/SC5 '.
                     $I.'$COMPATH'.$ds."include";
    }

   $SOLARINC      .= $I.'$SOLARENV'.$INC.$ds."Xp31".
                     $I.'$JAVA_HOME'.$INCLUDE;

   #include system dependent Java include directory

   if ($platform eq $Solaris)
   {  $SOLARINC   .=$I.'$JAVA_HOME'.$INCLUDE.$ds."solaris";
   }
   elsif  (($platform eq $Linux) || ($platform eq $Tru64))
   {  $SOLARINC   .=$I.'$JAVA_HOME'.$INCLUDE.$ds."linux";
   }
   elsif ($platform eq $FreeBSD)
   {  $SOLARINC   .=$I.'$JAVA_HOME'.$INCLUDE.$ds."freebsd";
   }
   elsif ($platform eq $NetBSD)
   {  $SOLARINC   .=$I.'$JAVA_HOME'.$INCLUDE.$ds."netbsd";
   }
   elsif (($platform eq $Irix) || ($platform eq $Irix64))
   {  $SOLARINC   .=$I.'$JAVA_HOME'.$INCLUDE.$ds."irix";
   }

   #java threads include path

   if ($platform eq $FreeBSD)
    {  $SOLARINC  .=$I.'$JAVA_HOME'.$INCLUDE.$ds."green_threads".$ds."include";
    }
    else
    {  $SOLARINC  .=$I.'$JAVA_HOME'.$INCLUDE.$ds."native_threads".$ds."include";
    }

    #The tail, if needed
    if (($platform eq $Linux) || ($platform eq $FreeBSD) ||
	   ($platform eq $NetBSD) || ($platform eq $Irix) || ($platform eq $Irix64))
    {  $SOLARINC  .= $I.$XINC;
    }
    elsif ($platform eq $Tru64) 
    {  $SOLARINC  .= $I.$XINC.
                     $I.$USR.$INCLUDE;
    }
{  $SOLARINC         .= $I.$XINC;
}
}
elsif ($platform eq $Winnt)
{  $SOLARINC         .= $STLPORT_stlport.
                        $I.'$JAVA_HOME'.$ds."include".$ds."win32".
                        $I.'$JAVA_HOME'.$ds."include".
                        $I."'".$PSDK_HOME.$INCLUDE."'".
                        $I.'$COMPATH'.$ds."include";
}
elsif ($platform eq $Macosx)
{  $SOLARINC         .= $STLPORT_stlport.
                        $I.$FRAMEWORKSHOME.$ds."JavaVM.framework".$ds."Headers";
   # [ed] 6/15/02 Add in X11 headers as appropriate for the build
   if ($GUIBASE eq "unx") {
      $SOLARINC      .= $I.$XINC.
                        $I.$XINC.$ds."freetype2";
   }
}
else
{  AddWarning( "set_soenv", "$platform not configured for system dependant include dir" );
}
#
print "done\n";

#
# F. Setting the different aliases.
#

# There may be a better way to do this, like splitting unxmacxp into two, but
# hopefully this hack will work for now...

if ($platform eq $Macosx)
{
    my $macosxCdefs="";
    

# Writing the variables to file.
# (c = comment, e = environment variable, a = alias, n = newline )
ToFile( "Variable values.",  $empty,             "c" );
if ( $platform eq $Winnt )
{  ToFile( "CYGWIN",            $CYGWIN,            "e" );
   ToFile( "PSDK_HOME",         $PSDK_HOME,         "e" );
   ToFile( "USE_NEW_SDK",       $USE_NEW_SDK,       "e" );

ToFile( "DMAKEROOT",         $DMAKEROOT,         "e" );
ToFile( "CLASSPATH",         $CLASSPATH,         "e" );
ToFile( "XCLASSPATH",        $XCLASSPATH,        "e" );
if ( $platform eq $Macosx )
{  ToFile( "DYLD_LIBRARY_PATH", $LD_LIBRARY_PATH,   "e" );
}
else {
  if ( $platform eq $Irix || $platform eq $Irix64 ) { 
    ToFile( "LD_LIBRARYN32_PATH",   $LD_LIBRARY_PATH,   "e" );
  }
  else {

ToFile( "ENVCFLAGSCXX",      "@ENVCFLAGSCXX@",    "e" );
ToFile( "GXX_INCLUDE_PATH",  "@GXX_INCLUDE_PATH@","e" );
ToFile( "COMMON_BUILD_TOOLS",$COMMON_BUILD_TOOLS, "e" );
if ($platform ne $Winnt)
{  ToFile( "TEMP",              $TEMP,              "e" );
   ToFile( "TMP",               $TEMP,              "e" );
}
if (( $platform eq $Winnt ) and ( '@USE_SHELL@' ne "4nt" )) {
   ToFile( "SOLARSRC",          $SOLARSRC   ,       "j" );
} else {
   ToFile( "SOLARSRC",          $SOLARSRC,          "e" );
}
if ( $platform eq $Winnt )
{
   # these variables marked with "j" are used with cygwin only
   ToFile( "LIB",               $WIN_LIB,           "j" );

   ToFile( "GNUCOPY",           $WIN_GNUCOPY,       "e" );
   ToFile( "TOUCH",             $WIN_TOUCH,         "e" );
}
elsif ($platform eq $Macosx )
{  ToFile( "LIB",               $MAC_LIB,           "e" );
}
if (( $platform eq $Winnt ) and ( '@USE_SHELL@' eq "4nt" )) {
  my ($tempstring);
  $tempstring="perl ".WinFormat(${SOLARENV}.${BIN}.${ds}."deliver.pl");
  if ( $perl_os =~ /cygwin/ ) { $tempstring =~ s#\\#\\\\#g; }

  ToFile( "ZIPDEP",            "zipdep.pl",         "e" );
  ToFile( "GCCINSTLIB",        "gccinstlib.pl",    "e" );
}
ToFile( "USE_SHELL",         '@USE_SHELL@',         "e" );
#
# Writing the aliases to file.
# (c = comment, e = environment variable, a = alias )

ToFile( "alias deliver",     $deliver,           "a" );
ToFile( "alias build",       $build,             "a" );
ToFile( "alias zipdep",      $zipdep,            "a" );
if ( $platform ne $Winnt )
{  ToFile( "alias nmake",       $nmake,             "a" );
}
# write make command for dmake for windows
# (x = write as is)

if ( $platform eq $Winnt and '@USE_SHELL@' eq "4nt" )
{
  ToFile( "build the dmake executable.", $empty, "c");
  ToFile( "if not exist \%SRC_ROOT\\dmake\\dmake.exe (cd \%SRC_ROOT\\dmake \^ call make.bat win95-vpp40 \^ cd \%SRC_ROOT)", $empty, "x");

#
#
print "*********************************************************".
      "******************* $newline"."*".$newline;
print "* OpenOffice.org $UPD configuration. $newline";
for ( $tmp = 0; $tmp < 2; $tmp++ ) 
{  print "* $newline";


if ( $Warning ne "" ) 
{  print "$Warning*"; 
   print $newline;
}

print "$newline* USAGE: $newline";
print "* Source $outfile (in tcsh)";
print " or $outfile.sh (in sh)" if defined($outfile_sh);
print $newline;
print "* in order to set up the build-environment variables.$newline";
for ( $tmp = 0; $tmp < 2; $tmp++ ) 
{  print "* $newline";

$bootfile = "bootstrap";
open( OUT, ">$bootfile" ) ||
die "Cannot open $bootfile: $!\n";
if ( '@USE_SHELL@' eq "4nt" )
{  $SHELL="tcsh";
}
print OUT "#!$SHELL\n";

}

print "Configure completed\n";
if ($platform ne $Winnt) {
	print "You may now run $tmp in $SRC_ROOT\n";
}
#

#-----------------
#
#-------------------------------------------------------------
# Function name: CheckPathName 
# Description:   chops off the '/' character if it's the last
#                character in a pathname. also adds the '/'
#                character if it's not the first character
#                in a path.
# Arguments:     1. Path (string)
# Return value:  Path (string)
#-------------------------------------------------------------
sub CheckPathName 
{  my $retrn = $_[ 0 ];
   if (($platform ne "$Winnt") or ( $USE_SHELL ne "4nt" ))
   {  # Check if the first character is not a '/'.
      if ( !( $_[ 0 ] =~ /^\// ) ) 
      {  $retrn = $ds.$_[ 0 ];
      }
   }
   # kill the last '/','\','\n' if they exists.
   $retrn =~ s![\s/\\]+$!!;
   # Done!
   return( $retrn );
}
#-------------------------------------------------------------
# Function name: CheckPathExist 
# Description:   Checks whether the directory that is given
#                as an argument exists. If not it asks the     

#-------------------------------------------------------------
sub CheckPathExist 
{  my $dir = $_[ 0 ];
   if ( !( -d $dir ) and $platform ne $Winnt) 
   {  printf "The directory $_[ 0 ] does not exist. Want to create it (y/n)?: ";
      my $answer = <STDIN>; 
      chomp( $answer );

      return "false";
   }
   else
   {   # Don't check under $Winnt. The path is possibly posix and you could use a native NT perl!  
	   return "true";
   }
}

   }
   elsif ( $_[ 2 ] eq "c" ) 
   {  # Write a comment to file.
      print $newline;
      print "$comment $newline";
      print "$comment $_[ 0 ] $newline"; 
      print "$comment $newline";     
      print OUT $newline;
      print OUT "$comment $newline";
      print OUT "$comment $_[ 0 ] $newline"; 
      print OUT "$comment $newline";     
#      print OUT "$newline";
      if(defined($outfile_sh))
      {
          print OUT_SH $newline;
          print OUT_SH "$comment $newline";
          print OUT_SH "$comment $_[ 0 ] $newline"; 
          print OUT_SH "$comment $newline";     
      }
      if(defined($outfile_bat))
      {
          print OUT_BAT $newline;
          print OUT_BAT "$comment4nt $newline";
          print OUT_BAT "$comment4nt $_[ 0 ] $newline"; 
          print OUT_BAT "$comment4nt $newline";     

   }
   elsif ( $_[ 2 ] eq "n" ) 
   {  #Write a newline to a file
      print OUT $newline;
      print OUT_SH $newline if defined($outfile_sh);
      print OUT_BAT $newline if defined($outfile_bat);
   }
   elsif ( $_[ 2 ] eq "x" )
   {

   }
   elsif ( $_[ 2 ] eq "j" )
   {
      if ((defined $_[ 1 ]) and ( $platform eq $Winnt )) 
      {  printf("%-12s %-17s %-10s %-39s\n", "The variable", $_[ 0 ], "is set to:", $_[ 1 ]) ; # to stdout
         $win_format_var = WinFormat( $_[ 1 ] );  #Filter for Windows
         $win_format_var =~ s/\\/\\\\/g;

{  my ( $variable );
   $variable = $_[ 0 ];
   # ToDo: Do the replacement only if "Winnt" and var contains "\" and ":"
   if ( $platform eq $Winnt )
   {   $variable =~ s/(\$\{?\w+\}?)/$1/eeg ;         # expand the variables
       $variable =~ s/(\$\{?\w+\}?)/$1/eeg ;         # expand the variables twice!
   	   if ( ( $variable =~ /\\/ ) and ( $variable =~ /:/ ) )

sub CheckBuildEnv 
{  my ( $src_root );
   $src_root  = $_[ 0 ];
   if ( !( -d $src_root ) and $platform ne $Winnt) 
   {  return 0;
   }
   return 1;

Return to issue 12442