home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / JBuilder8.iso / install_linux < prev    next >
Text File  |  2002-11-12  |  36KB  |  1,300 lines
  1. #!/bin/sh
  2. # LaunchAnywhere (tm) version 4.0
  3. # (c) Copyright 1999,2000 Zero G Software, Inc., all rights reserved.
  4. #
  5. #  To run this script you will need to have the following:
  6. #    1) a Java VM installed (however, it will handle a lack of Java nicely).
  7. #    2) a Java-style properties file having the same name as this script 
  8. #        with the suffix .lax.  If this script is appended to the
  9. #        self-extractor, it will look for the properties file in the
  10. #        directory specified by $seLaxPath; otherwise, it will look in
  11. #        the same directory that this script is in.
  12. #    3) a Java program in the file "lax.jar".
  13. #
  14. #  The .lax property file must contain at least the following properties:
  15. #    1)  lax.class.path  classpath (do not include the environment variable $CLASSPATH)
  16. #    2)  lax.nl.java.launcher.main.class  (main class of LaunchAnywhere Executable)
  17. #    3)  lax.currentVM  (VM to launch with)
  18. #
  19. #  This program is also used for the "Try It!" feature of the InstallAnywhere
  20. #  designer.  If the name of a VM is passed in as an argument when invoking
  21. #  this script, the VM will be checked for validity and used to run the 
  22. #  application specified in the .lax file.
  23.  
  24.  
  25. ####################################################################################
  26. # Set some constants
  27. if [ "$1" = "LAX_VM" ]; then
  28.     lax_vm="LAX_VM"
  29.     lax_vm_value="$2"
  30.     shift 2
  31. else
  32.     lax_vm=""
  33. fi 
  34. anyVMlist="JDK_J2 D12 JRE_J2 R12 JDK_J1 JRE_J1 JDK JRE ALL" 
  35.  
  36.  
  37. ####################################################################################
  38. # Format commandline args
  39. # To overcome the problem of quoted args (with internal spaces) to the launcher
  40. # is that they get "unquoted" or separated into discreet args when they are put
  41. # on the cmdline for the application.  This following block makes  sure the stay intact
  42. tmpArgs=""
  43. for arg in "$@"
  44. do
  45.         if [ "$arg" != "" ]
  46.         then
  47.                 tmpArgs="$tmpArgs \"$arg\""
  48.         fi
  49. done
  50. cmdLineArgs=$tmpArgs
  51. thisScript=$0
  52. # make sure thisScript is an abs path
  53. case $thisScript in
  54.     /*)
  55.     ;;
  56.     *)
  57.         thisScript="`pwd`/$thisScript"
  58.     ;;
  59. esac
  60.  
  61.  
  62. ####################################################################################
  63. #
  64. # WHere does the LAX_DEBUG output go?
  65. #
  66.  
  67. if [ "$LAX_DEBUG" = "file" ]; then
  68.     jx_log="`pwd`/jx.log"
  69.     rm -f "$jx_log"
  70.     touch "$jx_log"
  71.     if [ "$?" -gt "0" ]; then
  72.         jx_log_ok="false"
  73.         echo "Could not create $jx_log.  Sending debug output to console."
  74.     else 
  75.         jx_log_ok="true"
  76.     fi
  77. fi
  78.  
  79. debugOut()
  80. {
  81.     case "$LAX_DEBUG" in
  82.         "file" ) 
  83.             if [ "$jx_log_ok" = "true" ]; then
  84.                 echo "$1" >> "$jx_log"
  85.             else
  86.                 echo "$1"
  87.             fi
  88.         ;;
  89.         ""     )
  90.             echo "$1" >> /dev/null
  91.         ;;
  92.         *      )
  93.             echo "$1"
  94.         ;;
  95.     esac
  96. }
  97.  
  98. ####################################################################################
  99. #
  100. # UNIX ENVIRONMENT configuration
  101. #
  102. # Get os type , note that it is LOWER-CASED.  Used here and later on
  103. osName=`uname -s 2> /dev/null | tr "[:upper:]" "[:lower:]" 2> /dev/null`
  104. vmScript=".java_wrapper"
  105. case "$osName" in
  106.     *irix*)
  107.         cpuName="unknown"
  108.     ;;
  109.     *hp-ux*|*hpux*)
  110.         cpuName=`uname -m 2> /dev/null`
  111.     ;;
  112.     *solaris*|*sunos*)
  113.         cpuName=`uname -p 2> /dev/null`
  114.         THREADS_FLAG="";    export THREADS_FLAG 
  115.         PATH=/usr/bin:$PATH;    export PATH
  116.     ;;
  117.     *aix*)
  118.         cpuName="unknown"
  119.     ;;
  120.     *freebsd*)
  121.         cpuName=`uname -p 2> /dev/null`
  122.     ;;
  123.     *linux*)
  124.         cpuName=`uname -m 2> /dev/null`
  125.     ;;
  126.     *rhapsody*|*macos*)
  127.         cpuName=`uname -p 2> /dev/null`
  128.         vmScript=".java_command"
  129.     ;;
  130.     *compaq*|*dg*|*osf*)
  131.         cpuName="unknown"
  132.     ;;
  133.     *)
  134.         cpuName="unknown"
  135.     ;;
  136. esac
  137.  
  138. if [ -x /bin/ls ]; then
  139.     lsCMD="/bin/ls"
  140. else
  141.     lsCMD="/usr/bin/ls"
  142. fi
  143.  
  144. ####################################################################################
  145. # 
  146. # CREATE ENV.PROPERTIES and figure out if this is being exec'd from an installer
  147. #
  148. # Since USERENV is already set in the self-extractor, its its not set we know
  149. # this is not an installer but a separate launcher.  USERENV holds env variable
  150. # pairs
  151. #
  152. IS_INSTALLER=""
  153. if [ ! -z "$USERENV" ]; then
  154.     IS_INSTALLER="true"
  155. fi
  156. #
  157. # The sed command is used to escape backslashes so that when the properties
  158. # file is read by the java.util.Properties object, there is not a problem
  159. # with incorrectly interpreted escaped unicode.
  160. #
  161. USERENV=""; USERENV=`set | sed 's/\\\\/\\\\\\\\\\\\/g'`
  162. set x $USERENV; shift
  163. if [ -z "$envPropertiesFile" ]
  164. then
  165.     if [ -d /tmp ]
  166.     then
  167.         envPropertiesFile=/tmp/env.properties.$$
  168.     else
  169.         envPropertiesFile=$HOME/env.properties.$$
  170.     fi
  171. fi
  172. #
  173. # create the properties files BEFORE writing to it so that we can change is permissions to be more
  174. # secure... who knows? maybe the user has a password in an environment variable!
  175. #
  176. touch $envPropertiesFile
  177. chmod 600 $envPropertiesFile
  178. #
  179. # The first sed call is to escape spaces and tables from the RHS of environment values.
  180. # This white space would be interpreted as separate arguments to the for statement. So
  181. # this escaping with ||| for spaces and @@@ for tabs makes sure that env values with
  182. # such whitespace is accounted for
  183. OFS="$IFS"
  184. while test $# -gt 0; do
  185.     # line separator
  186.     case "x${1}x" in
  187.         *"="* ) BIFS=" "; ;;
  188.         *     ) BIFS="" ; ;;
  189.     esac
  190.     # word separator
  191.     case "x${2}x" in
  192.         *"="* ) AIFS=""; ;;
  193.         *     ) AIFS="" ; ;;
  194.     esac
  195.     INPUT="$INPUT$BIFS$1$AIFS"
  196.     shift
  197. done
  198.  
  199. while test "x$INPUT" != "x"; do
  200.     # get line
  201.     set x $INPUT; shift
  202.     X="$1"
  203.     shift
  204.     # remove word separators
  205.     INPUT="$@" 
  206.     IFS="=$AIFS"
  207.     set x $X; shift
  208.     IFS="$OFS"
  209.  
  210.     # assign values
  211.     lhs="$1"
  212.     shift
  213.     rhs="$@"
  214.  
  215.     #
  216.     # shove to file
  217.     #
  218.     # output in exact case stuff
  219.     echo lax.nl.env.exact_case.$lhs=$rhs >> $envPropertiesFile
  220.     # output the upper case stuff
  221.     lhs=`echo $lhs | tr [:lower:] [:upper:] 2> /dev/null`
  222.     echo lax.nl.env.$lhs=$rhs >> $envPropertiesFile
  223.     # output the lower case stuff
  224.     lhs=`echo $lhs | tr [:upper:] [:lower:] 2> /dev/null`
  225.     echo lax.nl.env.$lhs=$rhs >> $envPropertiesFile
  226. done
  227.  
  228. ####################################################################################
  229. #
  230. # Tracing symbolic links to actual launcher location
  231. #
  232.  
  233. resolveLink()
  234. {
  235.     rl_linked="true"
  236.     rl_operand="$1"
  237.     rl_origDir="`dirname "$1"`"
  238.  
  239.     # bypass the whole thing if this isnt a link
  240.     rl_ls=`$lsCMD -l "$rl_operand"`
  241.     case "$rl_ls" in
  242.         *"->"*)
  243.         ;;
  244.         *)
  245.             resolvedLink="$rl_operand"
  246.             return
  247.         ;;
  248.     esac 
  249.     
  250.     while [ "$rl_linked" = "true" ]; do
  251.         # if the operand is not of an abs path, get its abs path
  252.         case "$rl_operand" in
  253.             /*)
  254.                 rl_origDir=`dirname "$rl_operand"`
  255.             ;;
  256.             \./*)
  257.                 rl_origDir=`pwd`
  258.                 rl_operand="$rl_origDir/$rl_operand"
  259.             ;;
  260.             *)
  261.                 rl_operand="$rl_origDir/$rl_operand"
  262.             ;;
  263.         esac
  264.         #
  265.         # the prevPrev hack is here because .../java often points to .java_wrapper.
  266.         # at the end of the resolution rl_operand actually points to garbage
  267.         # signifying it is done resolving the link.  So prev is actually .java_wrapper.
  268.         # but we want the one just before that, its the real vm starting poiint we want
  269.         #
  270.         rl_prevOperand="$rl_operand"
  271.         rl_ls=`$lsCMD -l "$rl_operand"`
  272.         # get the output ls into a list
  273.         set x $rl_ls
  274.         # get rid of x and file info from ls -l
  275.         shift 9
  276.         
  277.         #is this a link?
  278.         case "$rl_ls" in
  279.             *"->"*)
  280.                 rl_linked="true"
  281.                 # is a link, shift past the "->"
  282.                 rl_linker=""
  283.                 while [ "$1" != "->" -a $# -gt 1 ]; do
  284.                     rl_linker="$rl_linker $1"
  285.                     shift
  286.                 done
  287.     
  288.                 if [ "$1" = "->" ]; then
  289.                     shift
  290.                 fi
  291.             ;;
  292.             *)
  293.                 # not a link, the rest must be the targets name
  294.                 rl_linked="false"
  295.             ;;
  296.         esac
  297.         # now grab what's left 
  298.         rl_linkee="$*"
  299.  
  300.         debugOut "Following link to LAX $rl_linker -> $rl_linkee"
  301.  
  302.         if [ "$rl_linked" = "true" -a "$rl_linkee" != "$vmScript" ]; then
  303.             # set to true incase the thing linked to is also a link and we can
  304.             # try again.  The current think linked to now becomes the operand
  305.             rl_operand="$rl_linkee"
  306.             # if the linkee is not abs, make it abs relative to the linker
  307.             case "$rl_operand" in
  308.                 /*)
  309.                 ;;
  310.                 *)
  311.                     rl_operand="$rl_origDir/$rl_operand"
  312.                 ;;
  313.             esac
  314.         else
  315.             # otherwise, this operand is not a link itself and we are done
  316.             rl_resolvedLink="$rl_prevOperand"
  317.             # however, do not resolve the last leg of a VMs linked scripts. this will
  318.             # disrupt their scripts.  it is expecting a link to the .java* script
  319.             # let us believe it is not linked and continue on...
  320.             if [ "$rl_linkee" = "$vmScript" ]; then
  321.                 rl_linked="false"
  322.             fi
  323.         fi
  324.         # make sure the path returned is absolute
  325.         case "$rl_operand" in
  326.             \.\/*)
  327.                 rl_operand="`pwd`/$rl_operand"
  328.             ;;
  329.         esac
  330.     done
  331.  
  332.     # remove "/./" in paths, make it "/"
  333.     # i,e,  "/a/b/./c" becomes "/a/b/c"
  334.     resolvedLink=`echo "$rl_resolvedLink" |  sed 's,/\./,/,'`
  335. }
  336.  
  337. ####################################################################################
  338. #
  339. #  FINDING THE LAX FILE
  340. #
  341. # If this is an installer, use $seLaxPath
  342. #
  343. debugOut ""
  344. debugOut "========= Analyzing LAX =============================================="
  345. olddir=`pwd`
  346. resolveLink "$thisScript"
  347. absLauncherName="$resolvedLink"
  348. cd "`dirname "$absLauncherName"`"
  349. if [ "$IS_INSTALLER" != "" ]; then
  350.     if [ ! -z "$seLaxPath" ]; then
  351.         propfname=$seLaxPath
  352.     else
  353.         # legacy for old self-extractors
  354.         propfname=$templaxpath
  355.     fi 
  356. else
  357.     propfname=$absLauncherName.lax
  358. fi
  359.  
  360.  
  361. if [ ! -r "$propfname" ]; then
  362.     debugOut "The file "$propfname" could not be found, and the"
  363.     debugOut "program cannot be run without it.  Try reinstalling the program."
  364.     exit;
  365. else 
  366.     debugOut "LAX found............................ OK."
  367. fi
  368.  
  369.  
  370. ####################################################################################
  371. # 
  372. # READING THE LAX FILE
  373. #
  374. OFS="$IFS"
  375. # run prop file through sed calls that do:
  376. # 1. transform first '=' on a line into a control-O
  377. # 2. transform all other ='s to control-F
  378. # 3. transform control-Os back to =
  379. # this is to differentiate the lhs=rhs processing from confusing the first = from other
  380. # = that might be part of the value.  Later on those =-tranformed-to-control-Fs are
  381. # transformed back to = signs.
  382. set x `cat "$propfname" | sed -e 's~^\([^\=]*\)\=\(.*\)~\1\\2~g' -e 's~=~~g' -e 's~~=~g' | grep '='`; shift
  383.  
  384. while test $# -gt 0; do
  385.     # line separator
  386.     case "x${1}x" in
  387.         *"="* ) BIFS=" "; ;;
  388.         *     ) BIFS="" ; ;;
  389.     esac
  390.     # word separator
  391.     case "x${2}x" in
  392.         *"="* ) AIFS=""; ;;
  393.         *     ) AIFS=""; ;;
  394.     esac
  395.     INPUT="$INPUT$BIFS$1$AIFS"
  396.     shift
  397. done
  398.  
  399. while test "x$INPUT" != "x"; do
  400.     set x $INPUT; shift
  401.     X="$1"
  402.     shift
  403.     INPUT="$@" 
  404.     IFS="=$AIFS"
  405.     set x $X; shift
  406.     IFS="$OFS"
  407.  
  408.     lhs="${1}"
  409.     shift
  410.     rhs="$@"
  411.  
  412.     # transform non lhs=rhs delimiting = signs back from ^F to =
  413.     case "$rhs" in
  414.         **)
  415.         rhs=`echo $rhs | sed 's~~=~g'`
  416.         ;;
  417.     esac
  418.  
  419.     # assing the values
  420.     case $lhs in
  421.         lax.class.path*)
  422.             lax_class_path="$rhs"
  423.         ;;
  424.         lax.main.class*)
  425.             lax_main_class="$rhs"
  426.         ;;
  427.         lax.nl.java.launcher.main.class*)
  428.             lax_nl_java_launcher_main_class="$rhs"
  429.         ;;
  430.         lax.nl.current.vm*)
  431.             lax_nl_current_vm="$rhs"
  432.         ;;
  433.         lax.user.dir*)
  434. #            lax_user_dir=`echo $lax_user_dir | sed 's;^[ ]*\(.*\)[ ]*$;\1;'`
  435.             # transform PWD to resolved dir
  436.             case "$rhs" in
  437.                 '$PWD')
  438.                    rhs=`pwd`/
  439.                    ;;
  440.             esac
  441.             lax_user_dir="$rhs"
  442.             debugOut "Lax_User_Dir..................$lax_user_dir"
  443.         ;;
  444.         lax.stdout.redirect*)
  445.             lax_stdout_redirect="$rhs"
  446.         ;;
  447.         lax.stderr.redirect*)
  448.             lax_stderr_redirect="$rhs"
  449.         ;;
  450.         lax.dir*)
  451.             # transform PWD to resolved dir
  452.             case "$rhs" in
  453.                 '$PWD')
  454.                    rhs=`pwd`/
  455.                    ;;
  456.             esac
  457.             lax_dir="$rhs"
  458.             debugOut "Lax_Dir..................$lax_dir"
  459.         ;;
  460.         lax.always.ask*)
  461.             lax_always_ask="$rhs"
  462.         ;;
  463.         lax.application.name*)
  464.             lax_application_name="$rhs"
  465.         ;;
  466.         lax.nl.message.vm.not.loaded*)
  467.             lax_nl_message_vm_loaded="$rhs"
  468.         ;;
  469.         lax.nl.valid.vm.list*)
  470.             # transform an blank value to "ALL"
  471.             case "$rhs" in
  472.                 "") rhs="ALL"; ;;
  473.             esac
  474.             lax_nl_valid_vm_list="$rhs"
  475.         ;;
  476.         lax.nl.java.option.check.source*)
  477.             verify_type="$rhs"
  478.         ;;
  479.         lax.nl.java.option.verify.mode*)
  480.             verify="$rhs"
  481.         ;;
  482.         lax.nl.java.option.verbose*)
  483.             verbo="$rhs"
  484.         ;;
  485.         lax.nl.java.option.garbage.collection.extent*)
  486.             gcxtnt="$rhs"
  487.         ;;
  488.         lax.nl.java.option.garbage.collection.background.thread*)
  489.             gcthrd="$rhs"
  490.         ;;
  491.         lax.nl.java.option.native.stack.size.max*)
  492.             nsmax="$rhs"
  493.         ;;
  494.         lax.nl.java.option.java.stack.size.max*)
  495.             jsmax="$rhs"
  496.         ;;
  497.         lax.nl.java.option.java.heap.size.max*)
  498.             jhmax="$rhs"
  499.         ;;
  500.         lax.nl.java.option.java.heap.size.initial*)
  501.             jhinit="$rhs"
  502.         ;;
  503.         lax.nl.java.option.debugging*)
  504.             debug="$rhs"
  505.         ;;
  506.         lax.nl.$osName.$cpuName.java.compiler*)
  507.             lax_nl_osname_cpuname_java_compiler="$rhs"
  508.         ;;
  509.         lax.nl.$osName.java.compiler*)
  510.             lax_nl_osname_java_compiler="$rhs"
  511.         ;;
  512.         lax.nl.java.compiler*)
  513.             lax_nl_java_compiler="$rhs"
  514.         ;;
  515.         lax.nl.java.option.additional*)
  516.             lax_nl_java_option_additional="$rhs"
  517.         ;;
  518.         ######################################################
  519.         # JIT overrides
  520.         lax.nl.unix.JDK_J1.java.compiler*)
  521.             lax_nl_unix_JDK_J1_java_compiler="$rhs"
  522.         ;;
  523.         lax.nl.unix.JDK_J2.java.compiler*)
  524.             lax_nl_unix_JDK_J2_java_compiler="$rhs"
  525.         ;;
  526.         lax.nl.unix.JRE_J1.java.compiler*)
  527.             lax_nl_unix_JRE_J1_java_compiler="$rhs"
  528.         ;;
  529.         lax.nl.unix.JRE_J2.java.compiler*)
  530.             lax_nl_unix_JRE_J2_java_compiler="$rhs"
  531.         ;;
  532.         lax.nl.unix.J1.java.compiler*)
  533.             lax_nl_unix_J1_java_compiler="$rhs"
  534.         ;;
  535.         lax.nl.unix.J2.java.compiler*)
  536.             lax_nl_unix_J2_java_compiler="$rhs"
  537.         ;;
  538.         lax.nl.unix.JRE.java.compiler*)
  539.             lax_nl_unix_JRE_java_compiler="$rhs"
  540.         ;;
  541.         lax.nl.unix.JDK.java.compiler*)
  542.             lax_nl_unix_JDK_java_compiler="$rhs"
  543.         ;;
  544.         lax.nl.unix.ALL.java.compiler*)
  545.             lax_nl_unix_ALL_java_compiler="$rhs"
  546.         ;;
  547.         #
  548.         lax.nl.JDK_J1.java.compiler*)
  549.             lax_nl_JDK_J1_java_compiler="$rhs"
  550.         ;;
  551.         lax.nl.JDK_J2.java.compiler*)
  552.             lax_nl_JDK_J2_java_compiler="$rhs"
  553.         ;;
  554.         lax.nl.JRE_J1.java.compiler*)
  555.             lax_nl_JRE_J1_java_compiler="$rhs"
  556.         ;;
  557.         lax.nl.JRE_J2.java.compiler*)
  558.             lax_nl_JRE_J2_java_compiler="$rhs"
  559.         ;;
  560.         lax.nl.J1.java.compiler*)
  561.             lax_nl_J1_java_compiler="$rhs"
  562.         ;;
  563.         lax.nl.J2.java.compiler*)
  564.             lax_nl_J2_java_compiler="$rhs"
  565.         ;;
  566.         lax.nl.JRE.java.compiler*)
  567.             lax_nl_JRE_java_compiler="$rhs"
  568.         ;;
  569.         lax.nl.JDK.java.compiler*)
  570.             lax_nl_JDK_java_compiler="$rhs"
  571.         ;;
  572.         lax.nl.ALL.java.compiler*)
  573.             lax_nl_ALL_java_compiler="$rhs"
  574.         ;;
  575.         #
  576.         lax.nl.$osName.JDK_J1.java.compiler*)
  577.             lax_nl_osname_JDK_J1_java_compiler="$rhs"
  578.         ;;
  579.         lax.nl.$osName.JDK_J2.java.compiler*)
  580.             lax_nl_osname_JDK_J2_java_compiler="$rhs"
  581.         ;;
  582.         lax.nl.$osName.JRE_J1.java.compiler*)
  583.             lax_nl_osname_JRE_J1_java_compiler="$rhs"
  584.         ;;
  585.         lax.nl.$osName.JRE_J2.java.compiler*)
  586.             lax_nl_osname_JRE_J2_java_compiler="$rhs"
  587.         ;;
  588.         lax.nl.$osName.J1.java.compiler*)
  589.             lax_nl_osname_J1_java_compiler="$rhs"
  590.         ;;
  591.         lax.nl.$osName.J2.java.compiler*)
  592.             lax_nl_osname_J2_java_compiler="$rhs"
  593.         ;;
  594.         lax.nl.$osName.JRE.java.compiler*)
  595.             lax_nl_osname_JRE_java_compiler="$rhs"
  596.         ;;
  597.         lax.nl.$osName.JDK.java.compiler*)
  598.             lax_nl_osname_JDK_java_compiler="$rhs"
  599.         ;;
  600.         lax.nl.$osName.ALL.java.compiler*)
  601.             lax_nl_osname_ALL_java_compiler="$rhs"
  602.         ;;
  603.         #
  604.         # JIT overrides
  605.         ######################################################
  606.     esac
  607. done
  608.  
  609. debugOut "LAX properties read.................. OK."
  610.  
  611. if [ "${lax_class_path:-""}" = "" ]; then
  612.     debugOut "The classpath specified in the LAX properties file"
  613.     debugOut "is invalid.  Try reinstalling the program."    
  614.     exit;
  615. fi
  616. if [ "${lax_nl_java_launcher_main_class:-""}" = "" ]; then
  617.     debugOut "The main class specified in the LAX properties file"
  618.     debugOut "is invalid.  Try reinstalling the program."
  619.     exit;
  620. fi
  621.  
  622. if [ ! -z "$INSTALLER_OVERRIDE_VMLIST" ]; then
  623.     lax_nl_valid_vm_list="$INSTALLER_OVERRIDE_VMLIST"
  624. fi
  625.  
  626.  
  627. ####################################################################################
  628. #
  629. # if  user.dir != .   then relative paths on the classpath will be broken.  they
  630. # are expecting the pwd to be '.' (meaning the install dir).  If user.dir is
  631. # any other directory, it will break
  632. lax_class_path=`echo "$lax_class_path" | sed 's^;^:^g'`
  633. #absInstallDir=`dirname "$absLauncherName"`
  634. #if [ $absInstallDir = '.' ]; then
  635. absInstallDir=$lax_dir
  636. #fi
  637. OFS="$IFS"
  638. IFS=":"
  639. set x $lax_class_path; shift
  640. IFS="$OFS"
  641. tmp_lcp=""
  642. while test $# -gt 0; do
  643.     case "$1" in
  644.         \/*)
  645.             tmp_lcp="$tmp_lcp:$1"
  646.         ;;
  647.         *|*\$ENV_CLASSPATH\$*)
  648.             tmp_lcp="$tmp_lcp:${absInstallDir}$1"
  649.         ;;
  650.     esac
  651.     shift
  652. done
  653. lax_class_path="$tmp_lcp"
  654.  
  655. # resolve $ENV_CLASSPATH$
  656. OFS="$IFS"
  657. IFS=":"
  658. set x $lax_class_path; shift
  659. IFS="$OFS"
  660. tmp_lcp=""
  661. while test $# -gt 0; do
  662.     case "$1" in
  663.         *\$ENV_CLASSPATH\$*)
  664.             tmp_lcp="$tmp_lcp:$CLASSPATH"
  665.         ;;
  666.         *)
  667.             tmp_lcp="$tmp_lcp:$1"
  668.         ;;
  669.     esac
  670.     shift
  671. done
  672. lax_class_path="$tmp_lcp"
  673.  
  674.  
  675.  
  676. ####################################################################################
  677. # just incase this the lax was written in DOS, be sure to make all ';' path
  678. # separators into :'s or it will fubar the commandline
  679. #
  680. case "$smclp" in
  681.     *\;*)
  682.         oldIFS=$IFS
  683.         IFS=";"
  684.         for smclp_piece in $smclp; do
  685.             tmp_smclp="$tmp_smclp:$smclp_piece"
  686.         done
  687.         IFS=$oldIFS
  688.         clp=$tmp_smclp
  689.     ;;
  690. esac
  691.  
  692. ##################################################################
  693. # Setting stdout and stderr redirection
  694. #
  695. if [ "$LAX_DEBUG" = "file" -o "$LAX_DEBUG" = "" ]; then
  696.     echo "lax.stderr.redirect=$lax_stderr_redirect" >> $envPropertiesFile
  697.     echo "lax.stdout.redirect=$lax_stdout_redirect" >> $envPropertiesFile
  698. else
  699.     echo "lax.stderr.redirect=console" >> $envPropertiesFile
  700.     echo "lax.stdout.redirect=console" >> $envPropertiesFile
  701.     lax_stdout_redirect="console"
  702.     lax_stderr_redirect="console"
  703. fi
  704.  
  705. lax_version="3.0"
  706.  
  707. validVMtypeList="$lax_nl_valid_vm_list"
  708.  
  709. # MMA 04.26.2000
  710. #
  711. # Added check for validVMtypeList not being set to any value, in
  712. # which case we should just set the valid list to all. 
  713. #
  714. if [ "$validVMtypeList" = "ALL" -o "$validVMtypeList" = "" ]; then
  715.     validVMtypeList=$anyVMlist
  716. fi
  717.  
  718.  
  719. #############################################################
  720. # PICK A VALID VM
  721. #
  722.  
  723. debugOut "" 
  724. debugOut "========= Finding VM ================================================="
  725. debugOut "Valid VM types....................... $validVMtypeList"
  726.  
  727. #
  728. # If the vm gets a relative path, we must make it absolute to the Install
  729. #   Directory    tm 3/3
  730. #
  731. if [ ! -z "${lax_nl_current_vm:-""}" ]; then
  732.     isABSpath=`expr $lax_nl_current_vm : '\/'`
  733.     if [ "$isABSpath" = "0" ]; then
  734.         abs_lax_nl_current_vm=$lax_dir$lax_nl_current_vm
  735.     else
  736.         abs_lax_nl_current_vm=$lax_nl_current_vm
  737.     fi
  738. fi
  739.  
  740.  
  741. # determine type of specific vm binary
  742. inspectVM()
  743. {
  744.     resolveLink "$1"
  745.     inspectee="$resolvedLink"
  746.     inspecteeDir=`dirname "$inspectee"`
  747.     inspecteeName=`basename "$inspectee"`
  748.     #
  749.     # is it JDK1.1 , JDK1.2  or JRE1.2?
  750.     #
  751.     if [ "$inspecteeName" = "oldjava" ]; then
  752.         inspectedOldVMtype="OLDJAVA"
  753.         inspectedVMtype="OLDJAVA"
  754.     elif [ "$inspecteeName" = "java" ]; then
  755.  
  756.         ############################################################
  757.         # Do some OS-specific quirky stuff
  758.         #
  759.         # MacOS X / Rhapsody
  760.         #
  761.         quirk_classesZip=""
  762.         if [ "$osName" = "rhapsody" ]; then
  763.             if [ "`expr "$inspecteeDIR" : ".*JavaVM.framework$"`" != "0" ]; then
  764.                 quirk_classesZip="$file/Classes/classes.jar"
  765.                 inspecteeDir="$inspecteeDir/Home/bin"
  766.             fi
  767.         fi
  768.         # END OS quirky stuff
  769.         ############################################################
  770.  
  771.         #
  772.         # is it JDK1.1?
  773.         # 
  774.         if [ -r "$inspecteeDir/../lib/classes.zip" -o -r "$quirk_classesZip" ]; then
  775.             inspectedOldVMtype="JDK"
  776.             inspectedVMtype="JDK_J1"
  777.         else
  778.             # JDK1.2
  779.             # 
  780.             # is the "java" JRE1.2 or JDK1.2?
  781.             #
  782.             if [ -r "$inspecteeDir/../lib/dt.jar" ]
  783.             then
  784.                 inspectedOldVMtype="D12"
  785.                 inspectedVMtype="JDK_J2"
  786.             else
  787.                 inspectedOldVMtype="R12"
  788.                 inspectedVMtype="JRE_J2"
  789.             fi
  790.         fi
  791.     elif [ "$inspecteeName" = "jre" ]; then
  792.         inspectedOldVMtype="JRE"
  793.         inspectedVMtype="JRE_J1"
  794.     else
  795.         inspectedOldVMtype="UNKNOWN"
  796.         inspectedVMtype="UNKNOWN"
  797.     fi
  798. }
  799.  
  800. # massage valid VM list.  Expand inclusive types (i.e. JRE = JRE_J1 and JRE_J2 )
  801. tmpValidVMlist=""
  802. for type in $validVMtypeList; do
  803.     case $type in
  804.         J1)        tmpValidVMlist="$tmpValidVMlist JRE_J1 JDK_J1" ;;
  805.         J2)        tmpValidVMlist="$tmpValidVMlist JRE_J2 JDK_J2" ;;
  806.         JRE)    tmpValidVMlist="$tmpValidVMlist JRE_J2 R12 JRE_J1" ;;
  807.         JDK)    tmpValidVMlist="$tmpValidVMlist JDK_J2 D12 JDK_J1" ;;
  808.         *)        tmpValidVMlist="$tmpValidVMlist $type " ;;
  809.     esac
  810. done
  811. validVMtypeList="$tmpValidVMlist"
  812. debugOut "Expanded Valid VM types.............. $validVMtypeList"
  813.  
  814. # if a VM was forced on the command line use it otherwise search
  815. if [ "$lax_vm" = "LAX_VM" ]; then
  816.     # Using VM passed in as argument
  817.     inspectVM "$lax_vm_value"
  818.     actvmType="$inspectedVMtype"
  819.     actvm="$lax_vm_value"
  820.     debugOut "* Using VM:........(LAX_VM).......... $actvm"
  821. else
  822.  
  823.     # 1st inspect the  lax.nl.current.vm.  As long as it is in the
  824.     # valid vm list it takes precedence over everything else.  
  825.     laxVMisValid="false"
  826.     # is the lax current vm is specifies
  827.     if [ ! -z "$abs_lax_nl_current_vm" -a -x "$abs_lax_nl_current_vm" ]; then
  828.         # inspect it
  829.         inspectVM "$abs_lax_nl_current_vm"
  830.         eval laxVMtype="$inspectedVMtype"
  831.         # if the type of this vm is in the valid list, deem it valid
  832.     
  833.  
  834.         case "$validVMtypeList" in
  835.             *$laxVMtype*)
  836.                 laxVMisValid="true"
  837.             ;;
  838.         esac
  839.     fi
  840.     # if the lax current vm is valid use it
  841.     if [ "$laxVMisValid" = "true" ]; then
  842.         actvm="$abs_lax_nl_current_vm"
  843.         actvmType="$laxVMtype"
  844.         debugOut "* Using VM....(lax.nl.current.vm).... $actvm"
  845.     else    
  846.     # other wise search the path
  847.         debugOut "WARNING! No valid lax.nl.current.vm available."
  848.         # sift through the path to look for VMs
  849.         vmNumber=0;
  850.         OFS=$IFS
  851.         IFS=":"
  852.         set x $PATH; shift
  853.         IFS=$OFS
  854.         debugOut "Searching for VMs in PATH:"
  855.         for pathDir in $*; do
  856.             debugOut "Looking in:.......................... $pathDir"
  857.             # For each type of binary vm name
  858.             for binaryName in java jre oldjava; do
  859.                 # if the binary exists, is executable and is not a directory...
  860.                 if [ -x "$pathDir/$binaryName" -a \( ! -d "$pathDir/$binaryName" \) ]; then
  861.                     resolveLink "$pathDir/$binaryName" 2> /dev/null
  862.                     vmPath="$resolvedLink"
  863.                     debugOut "  Found VM:.......................... $vmPath"
  864.                     inspectVM "$vmPath"
  865.                     # set up a Bourne-style array of VM props using var1, var2, etc...
  866.                     eval vmBinary$vmNumber="$vmPath"
  867.                     eval vmType$vmNumber="$inspectedVMtype"
  868.                     eval oldVMtype$vmNumber="$inspectedOldVMtype"
  869.                     vmNumber=`expr ${vmNumber:-0} + 1`
  870.                 fi
  871.             done
  872.         done
  873.     
  874.         #########################################
  875.         # VERIFY VMS against valid types
  876.         #
  877.         actvmType=""
  878.         vmHighNumber="$vmNumber"
  879.  
  880.         # for each type of valid VM
  881.         for validType in $validVMtypeList; do
  882.             vmNumber="0";
  883.  
  884.             # run through the list of VMs found
  885.             while [ "$vmNumber" -lt $vmHighNumber ]; do
  886.                 eval type="$"vmType$vmNumber""
  887.                 eval oldType="$"oldVMtype$vmNumber""
  888.                 eval  bin="$"vmBinary$vmNumber""
  889.         
  890.                 # if the type of this VM is of '$type' or '$oldType'
  891.                 # make it the actual vm (actvm) to use
  892.                 case "${type} ${oldType}" in
  893.                     *${validType}*)
  894.         
  895.                         actvm="$bin"
  896.                         actvmType="$type"
  897.                         debugOut "* Using VM:.......................... $actvm"
  898.                         break 2
  899.                     ;;
  900.                 esac
  901.                 vmNumber=`expr ${vmNumber:-0} + 1`
  902.             done
  903.         done    
  904.     fi
  905. fi
  906.  
  907.     # If no VMs are found in path
  908.     if [ -z "$actvm" ]
  909.     then
  910.         echo "No Java virtual machine could be found from your PATH"
  911.         echo "environment variable.  You must install a VM prior to"
  912.         echo "running this program."
  913.         
  914.         # Mikey [5/16/2000] -- If this was SEA'd then remove the temp directory
  915.         if [ "$IS_INSTALLER" = "true" ]; then
  916.             echo "Remove temporary installation directory: \"$lax_user_dir\""
  917.             rm -rf "$lax_user_dir"
  918.         fi
  919.         
  920.         cd $olddir
  921.         exit
  922.     fi
  923.  
  924.     # noLaxBackup is true for self-extractor, and the current vm should not
  925.     # be changed the LAX_VM is used
  926.     noLaxBackup=${noLaxBackup:="false"}
  927.     if [ "$lax_vm" != "LAX_VM" -a "$noLaxBackup" != true -a -w "$propfname" ]
  928.     then
  929.         sedscript="s;^lax.nl.current.vm.*;lax.nl.current.vm=$actvm;"
  930.         sed $sedscript "$propfname">file.lax 
  931.         mv "$propfname" "$propfname.bak" > /dev/null 2>&1
  932.         mv file.lax "$propfname" > /dev/null 2>&1
  933.         rm "$propfname.bak" > /dev/null 2>&1
  934.     fi
  935.  
  936.     # set up a variable to esilty know if we are going to run 1.1 or 1.2 
  937.     # for setting up VM cmd line options later on
  938.     case "$actvmType" in
  939.         "JRE" | "JDK" | "JRE_J1" | "JDK_J1" )
  940.             actvmVersion="1.1"
  941.         ;;
  942.         "R12" | "D12" | "JDK_J2" | "JRE_J2" | "OLDJAVA")
  943.             actvmVersion="1.2"
  944.         ;;
  945.         *)
  946.             actvmVersion=""
  947.         ;;
  948.     esac
  949.  
  950. #
  951. # end of finding VMs
  952. ##########################################################################################
  953.  
  954. ####################################################################################
  955. # Determining VM invocation options to use
  956. #
  957.  
  958. #
  959. # Verification
  960. #
  961. verify=${verify:="null"}
  962. if [ "$actvmVersion" = "1.1" ]; then
  963.     if [ "$verify" = "remote" -o "$verify_type" = "remote" ]; then
  964.             options="-verifyremote"
  965.     elif [ "$verify" = "all" ]; then
  966.         if [ "$verify_type" = "remote" ]; then
  967.             options="-verifyremote"
  968.         else
  969.             options="-verify"
  970.         fi
  971.     elif [ "$verify" = "none"  -o "$verify_type" = "remote" ]; then
  972.         options="-noverify"
  973.     fi
  974. fi
  975. verbo=${verbo:="none"}
  976. if [ $verbo = "normal" ]; then
  977.     if [ "$actvmVersion" = "1.1" ]; then
  978.         options="$options -verbose"
  979.     elif [ "$actvmVersion" = "1.2" ]; then
  980.         options="$options -verbose:class"
  981.     fi
  982. elif [ $verbo = "all" ]; then
  983.     if [ "$actvmVersion" = "1.1" ]; then
  984.         options="$options -verbose -verbosegc"
  985.     elif [ "$actvmVersion" = "1.2" ]; then
  986.         options="$options -verbose:class -verbose:gc"
  987.     fi
  988. elif [ $verbo = "gc" ]; then
  989.     if [ "$actvmVersion" = "1.1" ]; then
  990.         options="$options -verbosegc"
  991.     elif [ "$actvmVersion" = "1.2" ]; then
  992.         options="$options -verbose:gc"
  993.     fi    
  994. fi
  995.  
  996. #
  997. # Memory mgnt
  998. #
  999. gcxtnt=${gcxtnt:="none"}
  1000. if [ $gcxtnt = "min" ]
  1001. then
  1002.     if [ "$actvmVersion" = "1.1" ]; then
  1003.         options="$options -noclassgc"
  1004.     elif [ "$actvmVersion" = "1.2" ]; then
  1005.         options="$options -Xnoclassgc"
  1006.     fi
  1007. fi
  1008.  
  1009. gcthrd=${gcthrd:="none"}
  1010. if [ "$actvmVersion" = "1.1" ]; then
  1011.     if [ $gcthrd = "off" ]
  1012.     then
  1013.         options="$options -noasyncgc"
  1014.     fi
  1015. fi
  1016.  
  1017. nsmax=${nsmax:="none"}
  1018. jsmax=${jsmax:="none"}
  1019. if [ "$actvmVersion" = "1.1" ]; then
  1020.     if [ "$nsmax" != "none" ]; then
  1021.         options="$options -ss$nsmax"
  1022.     fi
  1023.     
  1024.     if [ "$jsmax" != "none" ]; then
  1025.             options="$options -oss$jsmax"
  1026.     fi
  1027. fi
  1028.  
  1029. jhmax=${jhmax:="none"}
  1030. if [ "$jhmax" != "none" ]; then
  1031.     if [ "$actvmVersion" = "1.1" ]; then
  1032.         options="$options -mx$jhmax"
  1033.     elif [ "$actvmVersion" = "1.2" ]; then
  1034.         options="$options -Xmx$jhmax"
  1035.     fi
  1036. fi
  1037.  
  1038. jhinit=${jhinit:="none"}
  1039. if [ "$jhinit" != "none" ]; then
  1040.     if [ "$actvmVersion" = "1.1" ]; then
  1041.         options="$options -ms$jhinit"
  1042.     elif [ "$actvmVersion" = "1.2" ]; then
  1043.         options="$options -Xms$jhinit"
  1044.     fi
  1045. fi
  1046.  
  1047. debug=${debug:-"off"}
  1048. if [ $debug != "off" ]; then
  1049.     if [ "$actvmVersion" = "1.1" ]; then
  1050.         options="$options -debug"
  1051.     elif [ "$actvmVersion" = "1.2" ]; then
  1052.         options="$options -Xdebug"
  1053.     fi
  1054. fi
  1055.  
  1056. ###############################################################
  1057. # JIT options
  1058. # Resetting java home and JIT compiler environment variables
  1059. #
  1060. jitOnOrOff=on;
  1061. #
  1062. # turn off according to VM type
  1063. #
  1064. if   [ ! -z "$lax_nl_osname_JDK_J1_java_compiler" -a "$actvmType" = "JDK_J1" ]; then
  1065.     jitOnOrOff=$lax_nl_osname_JDK_J1_java_compiler
  1066. elif [ ! -z "$lax_nl_osname_JDK_J2_java_compiler" -a "$actvmType" = "JDK_J2" ]; then
  1067.     jitOnOrOff=$lax_nl_osname_JDK_J2_java_compiler
  1068. elif [ ! -z "$lax_nl_osname_JRE_J1_java_compiler" -a "$actvmType" = "JRE_J1" ]; then
  1069.     jitOnOrOff=$lax_nl_osname_JRE_J1_java_compiler
  1070. elif [ ! -z "$lax_nl_osname_JRE_J2_java_compiler" -a "$actvmType" = "JRE_J2" ]; then
  1071.     jitOnOrOff=$lax_nl_osname_JRE_J2_java_compler
  1072. elif [ ! -z "$lax_nl_osname_J1_java_compiler" -a "$actvmType" = "J1" ]; then
  1073.     jitOnOrOff=$lax_nl_osname_J1_java_compiler
  1074. elif [ ! -z "$lax_nl_osname_J2_java_compiler" -a "$actvmType" = "J2" ]; then
  1075.     jitOnOrOff=$lax_nl_osname_J2_java_compiler
  1076. elif [ ! -z "$lax_nl_osname_JRE_java_compiler" -a "$actvmType" = "JRE" ]; then
  1077.     jitOnOrOff=$lax_nl_osname_JRE_java_compiler
  1078. elif [ ! -z "$lax_nl_osname_JDK_java_compiler" -a "$actvmType" = "JDK" ]; then
  1079.     jitOnOrOff=$lax_nl_osname_JDK_java_compiler
  1080. elif [ ! -z "$lax_nl_osname_ALL_java_compiler" ]; then
  1081.     jitOnOrOff=$lax_nl_osname_ALL_java_compiler
  1082. #
  1083. elif [ ! -z "$lax_nl_unix_JDK_J1_java_compiler" -a "$actvmType" = "JDK_J1" ]; then
  1084.     jitOnOrOff=$lax_nl_unix_JDK_J1_java_compiler
  1085. elif [ ! -z "$lax_nl_unix_JDK_J2_java_compiler" -a "$actvmType" = "JDK_J2" ]; then
  1086.     jitOnOrOff=$lax_nl_unix_JDK_J2_java_compiler
  1087. elif [ ! -z "$lax_nl_unix_JRE_J1_java_compiler" -a "$actvmType" = "JRE_J1" ]; then
  1088.     jitOnOrOff=$lax_nl_unix_JRE_J1_java_compiler
  1089. elif [ ! -z "$lax_nl_unix_JRE_J2_java_compiler" -a "$actvmType" = "JRE_J2" ]; then
  1090.     jitOnOrOff=$lax_nl_unix_JRE_J2_java_compler
  1091. elif [ ! -z "$lax_nl_unix_J1_java_compiler" -a "$actvmType" = "J1" ]; then
  1092.     jitOnOrOff=$lax_nl_unix_J1_java_compiler
  1093. elif [ ! -z "$lax_nl_unix_J2_java_compiler" -a "$actvmType" = "J2" ]; then
  1094.     jitOnOrOff=$lax_nl_unix_J2_java_compiler
  1095. elif [ ! -z "$lax_nl_unix_JRE_java_compiler" -a "$actvmType" = "JRE" ]; then
  1096.     jitOnOrOff=$lax_nl_unix_JRE_java_compiler
  1097. elif [ ! -z "$lax_nl_unix_JDK_java_compiler" -a "$actvmType" = "JDK" ]; then
  1098.     jitOnOrOff=$lax_nl_unix_JDK_java_compiler
  1099. elif [ ! -z "$lax_nl_unix_ALL_java_compiler" ]; then
  1100.     jitOnOrOff=$lax_nl_unix_ALL_java_compiler
  1101. #
  1102. elif [ ! -z "$lax_nl_JDK_J1_java_compiler" -a "$actvmType" = "JDK_J1" ]; then
  1103.     jitOnOrOff=$lax_nl_JDK_J1_java_compiler
  1104. elif [ ! -z "$lax_nl_JDK_J2_java_compiler" -a "$actvmType" = "JDK_J2" ]; then
  1105.     jitOnOrOff=$lax_nl_JDK_J2_java_compiler
  1106. elif [ ! -z "$lax_nl_JRE_J1_java_compiler" -a "$actvmType" = "JRE_J1" ]; then
  1107.     jitOnOrOff=$lax_nl_JRE_J1_java_compiler
  1108. elif [ ! -z "$lax_nl_JRE_J2_java_compiler" -a "$actvmType" = "JRE_J2" ]; then
  1109.     jitOnOrOff=$lax_nl_JRE_J2_java_compler
  1110. elif [ ! -z "$lax_nl_J1_java_compiler" -a "$actvmType" = "J1" ]; then
  1111.     jitOnOrOff=$lax_nl_J1_java_compiler
  1112. elif [ ! -z "$lax_nl_J2_java_compiler" -a "$actvmType" = "J2" ]; then
  1113.     jitOnOrOff=$lax_nl_J2_java_compiler
  1114. elif [ ! -z "$lax_nl_JRE_java_compiler" -a "$actvmType" = "JRE" ]; then
  1115.     jitOnOrOff=$lax_nl_JRE_java_compiler
  1116. elif [ ! -z "$lax_nl_JDK_java_compiler" -a "$actvmType" = "JDK" ]; then
  1117.     jitOnOrOff=$lax_nl_JDK_java_compiler
  1118. elif [ ! -z "$lax_nl_ALL_java_compiler" ]; then
  1119.     jitOnOrOff=$lax_nl_ALL_java_compiler
  1120. #
  1121. elif [ ! -z "$lax_nl_osname_java_compiler" ]; then
  1122.     jitOnOrOff=$lax_nl_osname_java_compiler
  1123. elif [ ! -z "$lax_nl_java_compiler" ]; then
  1124.     jitOnOrOff=$lax_nl_java_compiler
  1125. else
  1126.     jitOnOrOff=on
  1127. fi
  1128.  
  1129. # JIT is ON by default, so we only need to change its status
  1130. # the above else-if lists figures it should be OFF
  1131. if [ "$jitOnOrOff" = "off" ]; then
  1132.     if [ "$actvmVersion" = "1.1" ]; then
  1133.         case "$osName" in
  1134.             *irix*)
  1135.                 jitinvoc="-nojit"
  1136.                 JIT_OPTIONS="-nojit"
  1137.                 export JIT_OPTIONS
  1138.             ;;
  1139.             *hp-ux*|*hpux*)
  1140.                 JIT_OPTIONS="-nojit"
  1141.                 export JIT_OPTIONS
  1142.                 jitinvoc="-nojit"
  1143.             ;;
  1144.             *solaris*|*sunos*)
  1145.                 jitinvoc="-Djava.compiler="
  1146.             ;;
  1147.             *aix*)
  1148.                 JAVA_COMPILER=off
  1149.                 export JAVA_COMPILER
  1150.             ;;
  1151.             *freebsd*)
  1152.                 jitinvoc="-Djava.compiler="
  1153.             ;;
  1154.             *linux*)
  1155.                 jitinvoc="-Djava.compiler="
  1156.             ;;
  1157.             *rhapsody*|*macos*)
  1158.             ;;
  1159.             *compaq*|*dg*|*osf*)
  1160.                 jitinvoc="-nojit"
  1161.             ;;
  1162.             *)
  1163.                 debugOut "Unknown OS name (\"$osName\"). Cannot set JIT Options."
  1164.             ;;
  1165.         esac
  1166.     elif [ "$actvmVersion" = "1.2" ]; then
  1167.         jitinvoc="-Djava.compiler="
  1168.     else
  1169.         debugOut "Unknown VM version. Cannot set JIT Options."
  1170.     fi
  1171. fi
  1172.  
  1173. options="$jitinvoc $options"
  1174.  
  1175. ##################################################################
  1176. # Passing in addtional stuff
  1177. options="$options $lax_nl_java_option_additional"
  1178.  
  1179.  
  1180. # Changing working directory
  1181. if [ ! "$lax_user_dir" = "" ]
  1182. then
  1183.     if [ ! "$lax_user_dir" = "." ];
  1184.     then
  1185.         cd "$lax_user_dir"
  1186.     fi
  1187. else
  1188.     cd "$olddir"
  1189. fi
  1190.  
  1191. # Optional printout of all variable values for debugging purposes
  1192.  
  1193. debugOut ""
  1194. debugOut "========= Virtual Machine Options ===================================="
  1195. debugOut "LAX properties incorporated.......... OK."
  1196. debugOut "classpath............................ \"$lax_class_path\""
  1197. debugOut "main class........................... \"$lax_main_class\""
  1198. debugOut ".lax file path....................... \"$propfname\""
  1199. debugOut "user directory....................... \"$lax_user_dir\""
  1200. debugOut "stdout to............................ \"$lax_stdout_redirect\""
  1201. debugOut "sterr to............................. \"$lax_stderr_redirect\""
  1202. debugOut "install directory.................... \"$lax_dir\""
  1203. debugOut "JIT.................................. ${jittype:-"none"}"
  1204. debugOut "option (verify)...................... ${verify:-"none"}"
  1205. debugOut "option (verbosity)................... ${verbo:-"none"}"
  1206. debugOut "option (garbage collection extent)... ${gcxtnt:-"none"}"
  1207. debugOut "option (garbage collection thread)... ${gcthrd:-"none"}"
  1208. debugOut "option (native stack max size)....... ${nsmax:-"none"}"
  1209. debugOut "option (java stack max size)......... ${jsmax:-"none"}"
  1210. debugOut "option (java heap max size).......... ${jhmax:-"none"}"
  1211. debugOut "option (java heap initial size)...... ${jhinit:-"none"}"
  1212.  
  1213. resolveLink "$actvm"
  1214. actvm="$resolvedLink"
  1215.  
  1216. actvmBinaryName=`basename $actvm`
  1217. # get dirname of binary
  1218. actvmHome=`dirname "$actvm"`
  1219. # is the dir the binary is in named "bin"?
  1220. if [ "`basename $actvmHome`" = "bin" ]; then
  1221.     # if so then the dir above bin is the java home
  1222.     JAVA_HOME=`dirname "$actvmHome"`
  1223. else
  1224.     JAVA_HOME=
  1225. fi
  1226.  
  1227.  
  1228.  
  1229.  
  1230. # LAUNCH VMS
  1231.  
  1232. # Making $JAVA_HOME available to the application.
  1233. export JAVA_HOME
  1234.  
  1235. if [ "$actvmBinaryName" = "jre" ]; then
  1236.  
  1237.     CLASSPATH=
  1238.     export CLASSPATH
  1239.     # MMA - clear ENV to address a problem where the shell initialization
  1240.     # file (.Xshrc) pointed to by ENV may overide the classpath we have just set,
  1241.     # causing the app to fail.  Drawback is that other environment variables set
  1242.     # in the init file will not be available in the environment (they will be
  1243.     # available as Java system properties, however).  Comment out the two lines
  1244.     # below to change this behavior.
  1245.     ENV=
  1246.     export ENV
  1247.     # I split these up so they would be a bit clearer on the screen.
  1248.     debugOut ""
  1249.     debugOut "========= VM Command Line ============================================"
  1250.     debugOut "$actvm $options -cp \"$lax_class_path\" $lax_nl_java_launcher_main_class \"$propfname\" $envPropertiesFile $cmdLineArgs"
  1251.     # Here is where we actually run the app in Java:
  1252.     debugOut ""
  1253.     debugOut "========= Executing JRE =============================================="
  1254.     eval $actvm $options -cp \"$lax_class_path\" $lax_nl_java_launcher_main_class \"$propfname\" $envPropertiesFile $cmdLineArgs
  1255.     exitValue=$?
  1256.     debugOut "========= JRE Finished ==============================================="
  1257.     debugOut ""
  1258.  
  1259. elif [ "$actvmBinaryName" = "java" -o "$actvmBinaryName" = "oldjava" ]; then
  1260.  
  1261.     CLASSPATH=$lax_class_path
  1262.       export CLASSPATH 
  1263.     # MMA - clear ENV to address a problem where the shell initialization
  1264.     # file (.Xshrc) pointed to by ENV may overide the classpath we have just set,
  1265.     # causing the app to fail.  Drawback is that other environment variables set
  1266.     # in the init file will not be available in the environment (they will be
  1267.     # available as Java system properties, however).  Comment out the two lines
  1268.     # below to change this behavior.
  1269.     ENV=
  1270.     export ENV
  1271.     # I split these up so they would be a bit clearer on the screen.
  1272.     debugOut ""
  1273.     debugOut "========= VM Command Line ============================================"
  1274.     debugOut "CLASSPATH=\"$lax_class_path\""
  1275.     debugOut "$actvm $options $lax_nl_java_launcher_main_class \"$propfname\" $envPropertiesFile $cmdLineArgs"
  1276.     # Here is where we actually run the app in Java:
  1277.     debugOut ""
  1278.     debugOut "========= Executing JAVA ============================================="
  1279.     eval $actvm $options $lax_nl_java_launcher_main_class \"$propfname\" $envPropertiesFile $cmdLineArgs
  1280.     exitValue=$?
  1281.     debugOut "========= JAVA Finished =============================================="
  1282.     debugOut ""
  1283.  
  1284. else
  1285.  
  1286.     debugOut VMTYPE_UNKNOWN=\"$actvmBinaryName\"
  1287.  
  1288. fi
  1289.  
  1290. #  Change back to directory used priory to this script running.
  1291.  
  1292. cd "$olddir"
  1293.  
  1294. if [ "$IS_INSTALLER" = "true" ]; then
  1295.     debugOut "Removing tmp install dir: \"$lax_user_dir\""
  1296.     rm -rf "$lax_user_dir"
  1297. fi
  1298. rm -f "$envPropertiesFile"
  1299. exit $exitValue
  1300.