odk/configure.pl

   1 #
   2 # configure.pl - a perl script to set a minimal environment for the SDK.
   3 #
   4 # Copyright 2000, 2010 Oracle and/or its affiliates.
   5 #
   6
   7 use IO::File;
   8 use File::Basename;
   9
  10 $main::hostname= $ARGV[0];
  11 $main::sdkpath= $ARGV[1];
  12 $main::OO_SDK_NAME= $ARGV[2];
  13
  14 $main::OO_MAJORVERSION=$main::OO_SDK_NAME;
  15 $main::OO_MINORVERSION=$main::OO_SDK_NAME;
  16 $main::OO_MAJORVERSION =~ s#[^\d]+(\d).(\d).+#$1#go;
  17 $main::OO_MINORVERSION =~ s#[^\d]+(\d).(\d).+#$2#go;
  18
  19 $main::OO_SDK_CONFIG_HOME= "$ENV{HOME}/$main::OO_SDK_NAME";
  20
  21 $main::operatingSystem = `$main::sdkpath/config.guess | cut -d"-" -f3,4`;
  22 chomp ($main::operatingSystem);
  23
  24 $main::OO_SDK_HOME = $main::sdkpath;
  25 #$main::OO_SDK_HOME = "";
  26 $main::OO_SDK_HOME_SUGGESTION = $main::sdkpath;
  27
  28 $main::OFFICE_OR_URE = "Office";
  29 $main::OFFICE_OR_URE_SUGGESTION = "Office";
  30
  31 $main::OFFICE_HOME = "";
  32
  33 $main::OO_SDK_URE_HOME = `cd $main::sdkpath/../ure-link && pwd`;
  34 chomp($main::OO_SDK_URE_HOME);
  35
  36 $main::OO_SDK_MAKE_HOME = "";
  37 $main::makeName = "make";
  38 if ( $main::operatingSystem =~ m/solaris/ ||
  39      $main::operatingSystem =~ m/freebsd/ )
  40 {
  41     $main::makeName = "gmake";
  42 }
  43 $main::OO_SDK_MAKE_HOME_SUGGESTION = searchprog($main::makeName);
  44 $main::makeVersion = "3.79.1";
  45 $main::correctVersion = 0;
  46
  47 $main::OO_SDK_ZIP_HOME = "";
  48 $main::OO_SDK_ZIP_HOME_SUGGESTION = searchprog("zip");
  49 $main::zipVersion = "2.3";
  50
  51 $main::OO_SDK_CPP_HOME = "";
  52 $main::cppName = "gcc";
  53 $main::cppVersion = "4.0.1";
  54 if ( $main::operatingSystem =~ m/solaris/ )
  55 {
  56     $main::cppName = "CC";
  57     $main::cppVersion = "5.2";
  58 }
  59 $main::OO_SDK_CC_55_OR_HIGHER = "";
  60 $main::OO_SDK_CPP_HOME_SUGGESTION = searchprog($main::cppName);
  61
  62 $main::OO_SDK_JAVA_HOME = "";
  63 $main::OO_SDK_JAVA_BIN_DIR = "bin";
  64 if ( $main::operatingSystem =~ m/darwin/ )
  65 {
  66     $main::OO_SDK_JAVA_BIN_DIR="Commands";
  67 }
  68 $main::OO_SDK_JAVA_HOME_SUGGESTION = searchprog("javac");
  69 $main::javaVersion = "1.5.0_01";
  70
  71 $main::SDK_AUTO_DEPLOYMENT = "";
  72 $main::SDK_AUTO_DEPLOYMENT_SUGGESTION = "YES";
  73
  74 $main::OO_SDK_OUTPUT_DIR_SUGGESTION = "$ENV{HOME}";
  75 $main::OO_SDK_OUTPUT_DIR = "";
  76 $main::skipOutputDir = 0;
  77
  78 $main::return = 0;
  79
  80 if ( $main::OFFICE_OR_URE eq "Office" )
  81 {
  82     if ( $main::operatingSystem =~ m/darwin/ )
  83     {
  84 # used for a SDK as part of the office installation
  85 #       $main::OFFICE_HOME = `cd $main::sdkpath/../../.. && pwd`;
  86 #       chomp($main::OFFICE_HOME);
  87 #       print " Used Office = $main::OFFICE_HOME\n";
  88         print " Used SDK = $main::OO_SDK_HOME\n\n";
  89
  90         $main::OFFICE_HOME_SUGGESTION = searchMacOffice();
  91         while ( (! -d "$main::OFFICE_HOME" ) ||
  92                 ((-d "$main::OFFICE_HOME") && (! -d "$main::OFFICE_HOME/Contents/MacOS")) )
  93         {
  94             print " Enter the Office installation directory [$main::OFFICE_HOME_SUGGESTION]: ";
  95             $main::OFFICE_HOME = readStdIn();
  96             chop($main::OFFICE_HOME);
  97             if ( $main::OFFICE_HOME eq "" )
  98             {
  99                 $main::OFFICE_HOME = $main::OFFICE_HOME_SUGGESTION;
 100             }
 101
 102             if ( ! -d "$main::OFFICE_HOME" )
 103             {
 104                 $main::OFFICE_HOME = "";
 105                 print " Error: An office installation is required, please specify the path to a valid installation.\n";
 106             }
 107
 108             # check more details
 109             if ( -d "$main::OFFICE_HOME/Contents/ure-link" ) {
 110                 $main::OO_SDK_URE_HOME = "$main::OFFICE_HOME/Contents/ure-link";
 111             } else {
 112                 $main::OFFICE_HOME = "";
 113                 $main::OO_SDK_URE_HOME = "";
 114                 print " Error: no URE found in office installation, please specify the path to a valid installation.\n";
 115             }
 116         }
 117     } else
 118     {
 119         $main::OFFICE_HOME_SUGGESTION = searchoffice();
 120
 121         if ( $main::OFFICE_HOME_SUGGESTION eq "" ) {
 122             # prepare Office path
 123             $main::OFFICE_HOME_SUGGESTION = searchprog("soffice");
 124         }
 125
 126         if ( ! $main::OFFICE_HOME_SUGGESTION eq "" )
 127         {
 128             my $tmpOffice = readlink "$main::OFFICE_HOME_SUGGESTION/soffice";
 129
 130             if ( $tmpOffice eq "" )
 131             {
 132                 $tmpOffice = "$main::OFFICE_HOME_SUGGESTION/soffice";
 133             }
 134
 135             my $offset = rindex($tmpOffice, "/program/soffice");
 136             if ( $offset != -1 )
 137             {
 138                 $main::OFFICE_HOME_SUGGESTION = substr($tmpOffice, 0, $offset);
 139             } else
 140             {
 141                 $offset = rindex($tmpOffice, "/soffice");
 142                 if ( $offset != -1 )
 143                 {
 144                     $main::OFFICE_HOME_SUGGESTION = substr($tmpOffice, 0, $offset);
 145                 } else
 146                 {
 147                     $main::OFFICE_HOME_SUGGESTION = "";
 148                 }
 149             }
 150         }
 151
 152         while ( (! -d "$main::OFFICE_HOME" ) ||
 153                 ((-d "$main::OFFICE_HOME") && (! -d "$main::OFFICE_HOME/program")) )
 154         {
 155             print " Enter the Office installation directory [$main::OFFICE_HOME_SUGGESTION]: ";
 156             $main::OFFICE_HOME = readStdIn();
 157             chop($main::OFFICE_HOME);
 158             if ( $main::OFFICE_HOME eq "" )
 159             {
 160                 $main::OFFICE_HOME = $main::OFFICE_HOME_SUGGESTION;
 161             }
 162
 163             if ( ! -d "$main::OFFICE_HOME" )
 164             {
 165                 $main::OFFICE_HOME = "";
 166                 print " Error: An office installation is required, please specify the path to a valid installation.\n";
 167             } else
 168             {
 169                 # special work for a network installation, no prgram directory but a link to the soffice binary
 170                 if ( (! -d "$main::OFFICE_HOME/program") && (-e "$main::OFFICE_HOME/soffice") )
 171                 {
 172                     my $soserver = `ls -l $OFFICE_HOME_SUGGESTION/soffice | sed -n 's/.* -> //p'`;
 173                     $soserver= substr($soserver, 0, rindex($soserver, "program") - 1);
 174
 175                     if ( ! -d $soserver )
 176                     {
 177                         $main::OFFICE_HOME = "";
 178                         print " Error: An office installation is required, please specify the path to a valid installation.\n";
 179                     } else
 180                     {
 181                         $main::OFFICE_HOME = $soserver;
 182                     }
 183                 }
 184             }
 185         }
 186     }
 187 }
 188 else
 189 {
 190     # prepare URE path
 191     $main::OO_SDK_URE_HOME_SUGGESTION = "/opt/openoffice.org/ure";
 192     $main::OO_SDK_URE_HOME_SUGGESTION = "" unless
 193         -e "$main::OO_SDK_URE_HOME_SUGGESTION/bin/uno";
 194     for (;;)
 195     {
 196         print " Enter the URE installation directory",
 197             " [$main::OO_SDK_URE_HOME_SUGGESTION]: ";
 198         $main::OO_SDK_URE_HOME = readStdIn();
 199         chop $main::OO_SDK_URE_HOME;
 200         $main::OO_SDK_URE_HOME = $main::OO_SDK_URE_HOME_SUGGESTION if
 201             $main::OO_SDK_URE_HOME eq "" &&
 202             $main::OO_SDK_URE_HOME_SUGGESTION ne "";
 203         last if -e "$main::OO_SDK_URE_HOME/bin/uno";
 204         print " Error: A valid URE installation is required.\n";
 205     }
 206 }
 207
 208 # prepare GNU make path
 209 while ( (!$main::correctVersion) &&
 210         ((! -d "$main::OO_SDK_MAKE_HOME" ) ||
 211          ((-d "$main::OO_SDK_MAKE_HOME") && (! -e "$main::OO_SDK_MAKE_HOME/$main::makeName"))) )
 212 {
 213     print " Enter GNU make ($main::makeVersion or higher) tools directory [$main::OO_SDK_MAKE_HOME_SUGGESTION]: ";
 214     $main::OO_SDK_MAKE_HOME = readStdIn();
 215     chop($main::OO_SDK_MAKE_HOME);
 216     if ( $main::OO_SDK_MAKE_HOME eq "" )
 217     {
 218         $main::OO_SDK_MAKE_HOME = $main::OO_SDK_MAKE_HOME_SUGGESTION;
 219     }
 220     if ( (! -d "$main::OO_SDK_MAKE_HOME") ||
 221          ((-d "$main::OO_SDK_MAKE_HOME") && (! -e "$main::OO_SDK_MAKE_HOME/$main::makeName")) )
 222     {
 223         $main::OO_SDK_MAKE_HOME = "";
 224         print " Error: GNU make is required, please specify a GNU make tools directory.\n";
 225     } else
 226     {
 227         #check version
 228         my $testVersion = `$OO_SDK_MAKE_HOME/$main::makeName --version`;
 229         if ( $testVersion eq "")
 230         {
 231             print " Set the environment variable OO_SDK_MAKE_HOME to your GNU build tools directory.\n";
 232             print " GNU make version $main::makeVersion can be obtained at ftp://ftp.gnu.org/gnu/make/\n";
 233         } else
 234         {
 235             if ($testVersion =~ m#((\d+\.)+\d+)# )
 236             {
 237                 $testVersion = $1;
 238             }
 239             $main::correctVersion = testVersion($main::makeVersion, $testVersion, "$main::OO_SDK_MAKE_HOME/$main::makeName", 1);
 240             if ( !$main::correctVersion )
 241             {
 242                 print " The '$main::makeName' command found at '$main::OO_SDK_MAKE_HOME' has a wrong version\n";
 243                 $main::OO_SDK_MAKE_HOME = "";
 244             }
 245         }
 246     }
 247 }
 248
 249 # prepare zip path
 250 $main::correctVersion = 0;
 251 while ( (!$main::correctVersion) &&
 252         ((! -d "$main::OO_SDK_ZIP_HOME" ) ||
 253          ((-d "$main::OO_SDK_ZIP_HOME") && (! -e "$main::OO_SDK_ZIP_HOME/zip"))) )
 254 {
 255     print " Enter zip ($main::zipVersion or higher) tool directory [$main::OO_SDK_ZIP_HOME_SUGGESTION]: ";
 256     $main::OO_SDK_ZIP_HOME = readStdIn();
 257     chop($main::OO_SDK_ZIP_HOME);
 258     if ( $main::OO_SDK_ZIP_HOME eq "" )
 259     {
 260         $main::OO_SDK_ZIP_HOME = $main::OO_SDK_ZIP_HOME_SUGGESTION;
 261     }
 262     if ( (! -d "$main::OO_SDK_ZIP_HOME") ||
 263          ((-d "$main::OO_SDK_ZIP_HOME") && (! -e "$main::OO_SDK_ZIP_HOME/zip")) )
 264     {
 265         $main::OO_SDK_ZIP_HOME = "";
 266         print " Error: zip tool is required, please specify a zip tool directory.\n";
 267     } else
 268     {
 269         #check version
 270         my $testVersion = `$OO_SDK_ZIP_HOME/zip -h 2>&1 | egrep Zip | head -n 1`;
 271         $testVersion =~ s#Zip ([\d.]+) .*#$1#go;
 272         if ( $testVersion eq "")
 273         {
 274             print " Set the environment variable OO_SDK_ZIP_HOME to your zip tool directory.\n";
 275             print " zip version $main::zipVersion can be obtained at ftp://www.info-zip.org/\n";
 276         } else
 277         {
 278             if ($testVersion =~ m#((\d+\.)+\d+)# )
 279             {
 280                 $testVersion = $1;
 281             }
 282             $main::correctVersion = testVersion($main::zipVersion, $testVersion, "$main::OO_SDK_MAKE_HOME/zip", 1);
 283             if ( !$main::correctVersion )
 284             {
 285                 print " The 'zip' command found at '$main::OO_SDK_ZIP_HOME' has a wrong version\n";
 286                 $main::OO_SDK_ZIP_HOME = "";
 287             }
 288         }
 289     }
 290 }
 291
 292 # prepare C++ compiler path
 293 $main::correctVersion = 0;
 294 while ( (!$main::correctVersion) &&
 295         ((! -d "$main::OO_SDK_CPP_HOME" ) ||
 296          ((-d "$main::OO_SDK_CPP_HOME") && (! -e "$main::OO_SDK_CPP_HOME/$main::cpp"))) )
 297 {
 298     print " C++ compilers where for example a language binding exist:\n";
 299     print "  - Solaris, Sun WorkShop 6 update 1 C++ 5.2 2000/09/11 or higher\n";
 300     print "  - Linux, GNU C++ compiler, gcc version 4.0.1 or higher\n";
 301     print "  - MacOS, GNU C++ compiler, gcc version 4.0.1 or higher\n";
 302     print " Enter the directory of the C++ compiler, the directory\n";
 303     print " where the compiler is located (optional) [$main::OO_SDK_CPP_HOME_SUGGESTION]: ";
 304
 305     $main::OO_SDK_CPP_HOME = readStdIn();
 306     chop($main::OO_SDK_CPP_HOME);
 307     if ( $main::OO_SDK_CPP_HOME eq "" )
 308     {
 309         $main::OO_SDK_CPP_HOME = $main::OO_SDK_CPP_HOME_SUGGESTION;
 310     }
 311
 312     if ( ! $main::OO_SDK_CPP_HOME eq "" )
 313     {
 314         if ( (! -d "$main::OO_SDK_CPP_HOME") ||
 315              ((-d "$main::OO_SDK_CPP_HOME") && (! -e "$main::OO_SDK_CPP_HOME/$main::cppName")) )
 316         {
 317             print " Error: Could not find directory '$main::OO_SDK_CPP_HOME'.\n";
 318             if ( skipChoice("C++ compiler") == 1 )
 319             {
 320                 $main::correctVersion = 1;
 321             }
 322             $main::OO_SDK_CPP_HOME = "";
 323         } else
 324         {
 325             #check version
 326             if ( $main::cppName eq "gcc" )
 327             {
 328                 my $testVersion = `$OO_SDK_CPP_HOME/$main::cppName -dumpversion`;
 329                 if ( $testVersion eq "")
 330                 {
 331                     print " The '$main::cppName' command found at $main::OO_SDK_CPP_HOME/$main::cppName is not a ";
 332                     print " GNU compiler.\nSet the environment variable OO_SDK_CPP_HOME to your GNU build tools ";
 333                     print " directory.\nA GNU compiler version $main::cppVersion can be obtained at ";
 334                     print " ftp://ftp.gnu.org/gnu/gcc/\n";
 335                 } else
 336                 {
 337                     $main::correctVersion = testVersion($main::cppVersion, $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 1);
 338                     if ( !$main::correctVersion )
 339                     {
 340                         print " The '$main::cppName' command found at '$main::OO_SDK_CPP_HOME' has a wrong version\n";
 341                         if ( skipChoice("C++ compiler") == 1 )
 342                         {
 343                             $main::correctVersion = 1;
 344                         }
 345
 346                         $main::OO_SDK_CPP_HOME = "";
 347                     }
 348                 }
 349             } else
 350             {
 351                 # for Solaris we have to check the version too
 352                 open(FILE, "$OO_SDK_CPP_HOME/$main::cppName -V 2>&1 |");
 353                 my @lines = <FILE>;
 354                 my $testVersion = $lines[0];
 355                 if ( $testVersion eq "")
 356                 {
 357                     print " The '$main::cppName' command found at $main::OO_SDK_CPP_HOME/$main::cppName is not a ";
 358                     print " Solaris C++ compiler.\nSet the environment variable OO_SDK_CPP_HOME to your Solaris C++ compiler directory.\n";
 359                 } else
 360                 {
 361                     if ($testVersion =~ m#((\d+\.)+\d+)# )
 362                     {
 363                         $testVersion = $1;
 364                     }
 365                     $main::correctVersion = testVersion($main::cppVersion, $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 1);
 366                     if ( !$main::correctVersion )
 367                     {
 368                         print " The '$main::cppName' command found at '$main::OO_SDK_CPP_HOME' has a wrong version\n";
 369                         if ( skipChoice("C++ compiler") == 1 )
 370                         {
 371                             $main::correctVersion = 1;
 372                         }
 373
 374                         $main::OO_SDK_CPP_HOME = "";
 375                     } else {
 376                         $main::correctVersion = testVersion("5.5", $testVersion, "$main::OO_SDK_CPP_HOME/$main::cppName", 2);
 377                         if ( $main::correctVersion ) {
 378                             $main::OO_SDK_CC_55_OR_HIGHER = $testVersion;
 379                         }
 380                     }
 381                 }
 382             }
 383         }
 384     } else
 385     {
 386         # the C++ compiler is optional
 387         $main::correctVersion = 1;
 388     }
 389 }
 390
 391
 392 # prepare Java path
 393 $main::correctVersion = 0;
 394
 395 # prepare Java suggestion (cut bin or Commands directory to be in the root of the Java SDK)
 396 $main::offset = rindex($main::OO_SDK_JAVA_HOME_SUGGESTION, "/$main::OO_SDK_JAVA_BIN_DIR");
 397 if ( $main::offset != -1 )
 398 {
 399     $main::OO_SDK_JAVA_HOME_SUGGESTION = substr($main::OO_SDK_JAVA_HOME_SUGGESTION, 0, $main::offset);
 400 }
 401
 402 while ( (!$main::correctVersion) &&
 403         ((! -d "$main::OO_SDK_JAVA_HOME" ) ||
 404          ((-d "$main::OO_SDK_JAVA_HOME") && (! -e "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac"))) )
 405 {
 406     print " Enter Java SDK (1.5, recommendation is 1.6 or higher) installation directory  (optional) [$main::OO_SDK_JAVA_HOME_SUGGESTION]: ";
 407     $main::OO_SDK_JAVA_HOME = readStdIn();
 408     chop($main::OO_SDK_JAVA_HOME);
 409     if ( $main::OO_SDK_JAVA_HOME eq "" )
 410     {
 411         $main::OO_SDK_JAVA_HOME = $main::OO_SDK_JAVA_HOME_SUGGESTION;
 412     }
 413     if ( ! $main::OO_SDK_JAVA_HOME eq "" )
 414     {
 415         if ( (! -d "$main::OO_SDK_JAVA_HOME") ||
 416              ((-d "$main::OO_SDK_JAVA_HOME") && (! -e "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac")) )
 417         {
 418             print " Error: Could not find directory '$main::OO_SDK_JAVA_HOME' or '$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/javac'.\n";
 419             if ( skipChoice("JAVA SDK") == 1 )
 420             {
 421                 $main::correctVersion = 1;
 422             }
 423             $main::OO_SDK_JAVA_HOME = "";
 424         } else
 425         {
 426             #check version
 427             my $testVersion = `$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/java -version 2>&1 | egrep "java version" | head -n 1 | sed -e 's#.*version "##' | sed -e 's#".*##'`;
 428             $testVersion =~ s#([^\n]+)\n#$1#go;
 429
 430             $main::correctVersion = testVersion($main::javaVersion, $testVersion, "$main::OO_SDK_JAVA_HOME/$main::OO_SDK_JAVA_BIN_DIR/java", 1);
 431             if ( !$main::correctVersion )
 432             {
 433                 if ( skipChoice("JAVA SDK") == 1 )
 434                 {
 435                     $main::correctVersion = 1;
 436                 }
 437                 $main::OO_SDK_JAVA_HOME = "";
 438             }
 439         }
 440     }else
 441     {
 442         # the Java SDK is optional
 443         $main::correctVersion = 1;
 444     }
 445 }
 446
 447
 448 # prepare output directory (optional)
 449 while ( (!$main::skipOutputDir) &&
 450         (! -d "$main::OO_SDK_OUTPUT_DIR") )
 451 {
 452     print " Default output directory is in your HOME directory.\n";
 453     print " Enter an existent directory if you prefer a different output directory (optional) [$main::OO_SDK_OUTPUT_DIR_SUGGESTION]: ";
 454
 455     $main::OO_SDK_OUTPUT_DIR = readStdIn();
 456
 457     chop($main::OO_SDK_OUTPUT_DIR);
 458     if ( $main::OO_SDK_OUTPUT_DIR eq "" )
 459     {
 460         $main::OO_SDK_OUTPUT_DIR = $main::OO_SDK_OUTPUT_DIR_SUGGESTION;
 461     }
 462     if ( ! $main::OO_SDK_OUTPUT_DIR eq "" )
 463     {
 464         if ( ! -d "$main::OO_SDK_OUTPUT_DIR" )
 465         {
 466             print " Error: Could not find directory '$main::OO_SDK_OUTPUT_DIR'.\n";
 467             if ( skipChoice("optional output directory") == 1 )
 468             {
 469                 $main::skipOutputDir = 1;
 470             }
 471             $main::OO_SDK_OUTPUT_DIR = "";
 472         }
 473     } else
 474     {
 475         # the output directory is optional
 476         $main::skipOutputDir = 1;
 477     }
 478 }
 479
 480 # prepare auto deployment
 481 if ( $main::OFFICE_OR_URE eq "Office" )
 482 {
 483     while ( $main::SDK_AUTO_DEPLOYMENT eq "" ||
 484          ((! $main::SDK_AUTO_DEPLOYMENT eq "YES") &&
 485           (! $main::SDK_AUTO_DEPLOYMENT eq "NO")) )
 486     {
 487         print " Automatic deployment of UNO components (YES/NO) [$main::SDK_AUTO_DEPLOYMENT_SUGGESTION]: ";
 488         $main::SDK_AUTO_DEPLOYMENT = uc <STDIN>;
 489         chop($main::SDK_AUTO_DEPLOYMENT);
 490         if ( $main::SDK_AUTO_DEPLOYMENT eq "" )
 491         {
 492             $main::SDK_AUTO_DEPLOYMENT = "YES";
 493         }
 494     }
 495 }
 496 else
 497 {
 498     $main::SDK_AUTO_DEPLOYMENT = "NO";
 499 }
 500
 501 prepareScriptFile("setsdkenv_unix.sh.in", "setsdkenv_unix.sh", 1);
 502 chmod 0644, "$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.sh";
 503
 504 prepareScriptFile("setsdkenv_unix.csh.in", "setsdkenv_unix.csh", 2);
 505 chmod 0644, "$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.csh";
 506
 507 print "\n";
 508 print " ************************************************************************\n";
 509 print " * ... your SDK environment has been prepared.\n";
 510 print " * For each time you want to use this configured SDK environment, you\n";
 511 print " * have to run the \"setsdkenv_unix\" script file!\n";
 512 print " * Alternatively can you source one of the scripts\n";
 513 print " *   \"$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.sh\"\n";
 514 print " *   \"$main::OO_SDK_CONFIG_HOME/$main::hostname/setsdkenv_unix.csh\"\n";
 515 print " * to get an environment without starting a new shell.\n";
 516 print " ************************************************************************\n\n";
 517
 518 exit $return;
 519
 520 sub skipChoice
 521 {
 522     my $msg = shift;
 523     my $skip = "";
 524     while ( !( $skip eq "yes" || $skip eq "no") )
 525     {
 526         print " Do you want to skip the choice of the '$msg' (YES/NO): [YES] ";
 527         $skip = lc <STDIN>;
 528         chop($skip);
 529         if ( $skip eq "" ) { $skip = "yes"; } # default
 530         if ( $skip eq "yes" )
 531         {
 532             return 1;
 533         }
 534     }
 535     return 0;
 536 }
 537
 538 sub resolveLink
 539 {
 540     my $base= shift;
 541     my $link= shift;
 542
 543     my $resolvedpath = "$base/$link";
 544     my $linktarget =  readlink "$resolvedpath";
 545     my $resolvedlink = "";
 546
 547     while ( $linktarget ne "") {
 548
 549     if ( $linktarget =~ m/^\/.*/ )
 550     {
 551         $resolvedpath = "$linktarget";
 552     } else {
 553         $resolvedpath = `cd $base/$linktarget; pwd`;
 554         chop $resolvedpath;
 555     }
 556     $base = dirname("$resolvedpath");
 557
 558     $linktarget = readlink "$resolvedpath";
 559     }
 560
 561     $resolvedlink = `cd $resolvedpath; pwd`;
 562     chop $resolvedlink;
 563     return $resolvedlink;
 564 }
 565
 566 sub searchprog
 567 {
 568     my $_search= shift;
 569     my $tmpPath = `echo "\$PATH"`;
 570     my @pathList = split(":" , $tmpPath);
 571     my $progDir = "";
 572
 573     if ( $_search eq "javac" )
 574     {
 575         if ( $main::operatingSystem =~ m/darwin/ ) {
 576             $progDir = resolveLink("/System/Library/Frameworks/JavaVM.Framework/Versions", "CurrentJDK");
 577
 578             if ( -e "$progDir/$main::OO_SDK_JAVA_BIN_DIR/javac" )
 579             {
 580                 return "$progDir/$main::OO_SDK_JAVA_BIN_DIR";
 581             }
 582         }
 583
 584         if ( $main::operatingSystem =~ m/solaris/ ) {
 585             $progDir = resolveLink("/usr/jdk", "latest");
 586             if ( -e "$progDir/$main::OO_SDK_JAVA_BIN_DIR/javac" )
 587             {
 588                 return "$progDir/$main::OO_SDK_JAVA_BIN_DIR";
 589             }
 590         }
 591     }
 592
 593     if ( $_search eq "gmake" && $main::operatingSystem =~ m/solaris/ ) {
 594         if ( -e "/usr/sfw/bin/gmake" )
 595         {
 596             return "/usr/sfw/bin";
 597         }
 598     }
 599
 600     foreach $i (@pathList)
 601     {
 602         chomp ($i);
 603
 604         if ( -e "$i/$_search" )
 605         {
 606
 607             if ( index($i, "/") == 0 )
 608             {
 609                 # # absolute path; leave unchanged
 610                 $progDir = $i;
 611             } else
 612             {
 613                 $progDir = `cd "$i"; pwd`;
 614             }
 615             return $progDir
 616         }
 617     }
 618     return $progDir
 619 }
 620
 621 sub searchMacOffice
 622 {
 623     if (-d "/Applications/LibreOffice.app" ) {
 624         return "/Applications/LibreOffice.app"
 625     }
 626     if (-d "/Applications/OpenOffice.org.app" ) {
 627         return "/Applications/OpenOffice.org.app"
 628     }
 629     if (-d "/Applications/Oracle Open Office.app" ) {
 630         return "/Applications/Oracle Open Office.app";
 631     }
 632     if (-d "/Applications/StarOffice.app" ) {
 633         return "/Applications/StarOffice.app";
 634     }
 635     if (-d "/Applications/StarSuite.app" ) {
 636         return "/Applications/StarSuite.app";
 637     }
 638
 639     return "";
 640 }
 641
 642 sub searchoffice
 643 {
 644     my $offset = rindex($main::sdkpath, "/libreoffice");
 645     my $tmpOffice = substr($main::sdkpath, 0, $offset);
 646     my $officepath = "$tmpOffice/libreoffice";
 647
 648 #   if ( $main::OO_MINORVERSION > 0) {
 649 #       $officepath = "$officepath$main::OO_MINORVERSION";
 650 #   }
 651
 652     # search corresponding office for this SDK
 653     if (-d $officepath && -e "$officepath/program/soffice") {
 654         return $officepath;
 655     }
 656     # fallback
 657     my $tmpversion = $main::OO_MAJORVERSION;
 658 #   if ( $main::OO_MINORVERSION > 0) {
 659 #       $tmpversion = "$tmpversion.$main::OO_MINORVERSION";
 660 #   }
 661
 662     $officepath = "$tmpOffice/oracle_open_office$tmpversion";
 663     if (-d $officepath && -e "$officepath/program/soffice") {
 664         return $officepath;
 665     }
 666
 667     my $tmpversion = $main::OO_MAJORVERSION + 6;
 668     if ( $main::OO_MINORVERSION > 0) {
 669         $tmpversion = "$tmpversion.$main::OO_MINORVERSION";
 670     }
 671
 672     $officepath = "$tmpOffice/staroffice$tmpversion";
 673     if (-d $officepath && -e "$officepath/program/soffice") {
 674         return $officepath;
 675     }
 676     $officepath = "$tmpOffice/StarOffice$tmpversion";
 677     if (-d $officepath && -e "$officepath/program/soffice") {
 678         return $officepath;
 679     }
 680     $officepath = "$tmpOffice/starsuite$tmpversion";
 681     if (-d $officepath && -e "$officepath/program/soffice") {
 682         return $officepath;
 683     }
 684     $officepath = "$tmpOffice/StarSuite$tmpversion";
 685     if (-d $officepath && -e "$officepath/program/soffice") {
 686         return $officepath;
 687     }
 688     $officepath = "";
 689
 690     # search other potential matching office versions
 691     my $path = "/opt/";
 692     my $entry = "";
 693     my $version = "0";
 694     for $entry (glob($path.'*')) {
 695         ## if the file is a directory
 696         if( -d $entry) {
 697
 698             if ($entry =~ m#(.+(o|O)ffice(\.org){0,1}(\d([\d\.]){0,2}))# ||
 699                 $entry =~ m#(.+(s|S)uite(.*)(\d([\d\.]){0,2}))# )
 700             {
 701                 if ($4 > $version) {
 702                     $version = $4;
 703                     $officepath = $entry;
 704                 }
 705             }
 706         }
 707     }
 708     return $officepath;
 709 }
 710
 711
 712
 713 sub testVersion
 714 {
 715     my $tmpMustBeVersion = shift;
 716     my $tmpTestVersion = shift;
 717     my $toolName = shift;
 718     # 1=check + message 2=check only
 719     my $checkOnly = shift;
 720     my @mustBeVersion = split(/\.|_|-/,$tmpMustBeVersion);
 721     my @testVersion = split(/\.|_|-/,$tmpTestVersion);
 722     my $length = $#mustBeVersion;
 723
 724     if ($#testVersion < $#mustBeVersion) {
 725         $length = $#testVersion;
 726     }
 727
 728     for ($i=0; $i <= $length; $i++ )
 729     {
 730         if ( @testVersion->[$i] > @mustBeVersion->[$i] )
 731         {
 732             return 1; # 1 indicates a correct version
 733         }
 734
 735         if ( @testVersion->[$i] < @mustBeVersion->[$i] )
 736         {
 737             if ( $#checkOnly == 1 ) {
 738                 print " The command '$toolName' has the version $tmpTestVersion.\n";
 739                 print " The SDK requires at least the version $tmpMustBeVersion.\n";
 740             }
 741             return 0;
 742         }
 743     }
 744
 745     return 1; # 1 indicates a correct version
 746 }
 747
 748 sub readStdIn
 749 {
 750     my $tmpstdin = <STDIN>;
 751     if ( index($tmpstdin, "\$") != -1)
 752     {
 753         return `echo $tmpstdin`;
 754     }
 755
 756     return $tmpstdin;
 757 }
 758
 759 sub prepareScriptFile()
 760 {
 761     my $inputFile = shift;
 762     my $outputFile = shift;
 763     # shell mode 1 = sh
 764     #            2 = csh
 765     my $shellMode = shift;
 766
 767     if ( ! -d "$main::OO_SDK_CONFIG_HOME/$main::hostname" )
 768     {
 769         system("mkdir -p $main::OO_SDK_CONFIG_HOME/$main::hostname");
 770     }
 771
 772     open ( FILEIN, "$main::sdkpath/$inputFile" ) || die "\nERROR: could not open '$main::sdkpath/$inputFile' for reading";
 773     open ( FILEOUT, ">$main::OO_SDK_CONFIG_HOME/$main::hostname/$outputFile" ) || die "\nERROR: could not open '$main::OO_SDK_CONFIG_HOME/$main::hostname/$outputFile' for writing";
 774
 775     while ( <FILEIN> )
 776     {
 777         $_ =~ s#\@OO_SDK_NAME\@#$main::OO_SDK_NAME#go;
 778         $_ =~ s#\@OO_SDK_HOME\@#$main::OO_SDK_HOME#go;
 779         $_ =~ s#\@OFFICE_HOME\@#$main::OFFICE_HOME#go;
 780         $_ =~ s#\@OO_SDK_URE_HOME\@#$main::OO_SDK_URE_HOME#go;
 781         $_ =~ s#\@OO_SDK_MAKE_HOME\@#$main::OO_SDK_MAKE_HOME#go;
 782         $_ =~ s#\@OO_SDK_ZIP_HOME\@#$main::OO_SDK_ZIP_HOME#go;
 783         $_ =~ s#\@OO_SDK_CPP_HOME\@#$main::OO_SDK_CPP_HOME#go;
 784         $_ =~ s#\@OO_SDK_CC_55_OR_HIGHER\@#$main::OO_SDK_CC_55_OR_HIGHER#go;
 785         $_ =~ s#\@OO_SDK_JAVA_HOME\@#$main::OO_SDK_JAVA_HOME#go;
 786         $_ =~ s#\@SDK_AUTO_DEPLOYMENT\@#$main::SDK_AUTO_DEPLOYMENT#go;
 787         $_ =~ s#\@OO_SDK_OUTPUT_DIR\@#$main::OO_SDK_OUTPUT_DIR#go;
 788
 789         print FILEOUT $_;
 790     }
 791
 792     close FILEIN;
 793     close FILEOUT;
 794 }