odk/config/configure.pl

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